public void ManageNamespace(XamlReader reader)
        {
            switch (reader.NodeType)
            {
            case XamlNodeType.NamespaceDeclaration:
                tempNamespaceList.Add(reader.Namespace.Prefix,
                                      new NamespaceDeclaration(
                                          XamlBuildTaskServices.UpdateClrNamespaceUriWithLocalAssembly(reader.Namespace.Namespace, this.localAssemblyName),
                                          reader.Namespace.Prefix));
                break;

            case XamlNodeType.StartObject:
            case XamlNodeType.StartMember:
            case XamlNodeType.GetObject:
                if (tempNamespaceList != null)
                {
                    namespaceStack.Push(tempNamespaceList);
                    tempNamespaceList = new Dictionary <string, NamespaceDeclaration>();
                }
                break;

            case XamlNodeType.EndMember:
            case XamlNodeType.EndObject:
                namespaceStack.Pop();
                break;

            default:
                break;
            }
        }
        bool GetAppDomainAndExecute()
        {
            AppDomain appDomain = null;

            try
            {
                appDomain = CreateNewAppDomain();
                bool ret = ExecuteInternal(appDomain);
                return(ret);
            }
            catch (Exception e)
            {
                if (Fx.IsFatal(e))
                {
                    throw;
                }

                XamlBuildTaskServices.LogException(this.Log, e.Message);
                return(false);
            }
            finally
            {
                if (appDomain != null)
                {
                    AppDomain.Unload(appDomain);
                }
            }
        }
Esempio n. 3
0
        protected override XamlType GetXamlType(string xamlNamespace, string name, params XamlType[] typeArguments)
        {
            XamlType xamlType = base.GetXamlType(xamlNamespace, name, typeArguments);

            if (xamlType == null || xamlType.IsUnknown)
            {
                xamlNamespace = XamlBuildTaskServices.UpdateClrNamespaceUriWithLocalAssembly(xamlNamespace, this.localAssemblyName, this.realAssemblyName);
                xamlType      = base.GetXamlType(xamlNamespace, name, typeArguments);
            }
            else if (!xamlType.UnderlyingType.Assembly.ReflectionOnly &&
                     xamlType.UnderlyingType.Assembly != typeof(object).Assembly)
            {
                // Types from XamlLanguage are live; but we want the ROL equivalent, so that we can validate
                // against expected member types. We do this by looking it up via its clr-namespace form.
                // Note this means that the resulting XamlType will only have its clr-namespace, not the XAML2006 namespace.
                IList <string> namespaces = xamlType.GetXamlNamespaces();
                Fx.Assert(namespaces.Contains(XamlLanguage.Xaml2006Namespace) && xamlType.TypeArguments == null,
                          "This should only happen for XamlLanguage types, none of which are generic");
                string   clrNamespace = namespaces[namespaces.Count - 1];
                XamlType rolType      = base.GetXamlType(clrNamespace, xamlType.UnderlyingType.Name);
                if (rolType != null)
                {
                    xamlType = rolType;
                }
            }
            return(xamlType);
        }
Esempio n. 4
0
        PropertyData LoadProperty(XamlReader xamlReader)
        {
            if (xamlReader == null)
            {
                throw FxTrace.Exception.ArgumentNull("xamlReader");
            }

            PropertyData property = new PropertyData();

            while (xamlReader.Read())
            {
                if (xamlReader.NodeType == XamlNodeType.StartMember)
                {
                    XamlMember member = xamlReader.Member;
                    switch (member.Name)
                    {
                    case "Name":
                        property.Name = ReadValueAsString(xamlReader.ReadSubtree());
                        break;

                    case "Type":
                        property.Type = ReadPropertyType(xamlReader.ReadSubtree());
                        break;

                    case "Attributes":
                        foreach (AttributeData attribute in ReadAttributesCollection(xamlReader.ReadSubtree()))
                        {
                            property.Attributes.Add(attribute);
                        }
                        break;

                    case "Modifier":
                        string propertyModifier = ReadValueAsString(xamlReader.ReadSubtree());
                        property.Visibility = XamlBuildTaskServices.GetMemberVisibility(propertyModifier);
                        break;

                    default:
                        // Ignore AttachedProperties on property
                        if (!member.IsAttachable)
                        {
                            throw FxTrace.Exception.AsError(LogInvalidOperationException(xamlReader, SR.UnknownPropertyMember(member.Name)));
                        }
                        break;
                    }
                }
            }
            if (string.IsNullOrEmpty(property.Name))
            {
                throw FxTrace.Exception.AsError(LogInvalidOperationException(xamlReader, SR.PropertyNameRequired));
            }
            if (property.Type == null)
            {
                throw FxTrace.Exception.AsError(LogInvalidOperationException(xamlReader, SR.PropertyTypeRequired(property.Name)));
            }
            return(property);
        }
        // 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());
        }
Esempio n. 6
0
 XamlType ReadPropertyType(XamlReader xamlReader)
 {
     while (xamlReader.Read())
     {
         if (xamlReader.NodeType == XamlNodeType.Value && xamlReader.Value is string)
         {
             return(XamlBuildTaskServices.GetXamlTypeFromString((string)xamlReader.Value, this.namespaceTable, xamlReader.SchemaContext));
         }
     }
     return(null);
 }
        // 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));
        }
Esempio n. 8
0
        public override bool Execute()
        {
            AppDomain appDomain = null;

            try
            {
                ValidateRequiredDev11Properties();

                appDomain = XamlBuildTaskServices.CreateAppDomain("CompilationPass2AppDomain_" + Guid.NewGuid(), BuildTaskPath);

                CompilationPass2TaskInternal wrapper = (CompilationPass2TaskInternal)appDomain.CreateInstanceAndUnwrap(
                    Assembly.GetExecutingAssembly().FullName,
                    typeof(CompilationPass2TaskInternal).FullName);

                PopulateBuildArtifacts(wrapper);

                bool ret = wrapper.Execute();

                ExtractBuiltArtifacts(wrapper);

                if (!ret)
                {
                    foreach (LogData logData in wrapper.LogData)
                    {
                        XamlBuildTaskServices.LogException(
                            this.Log,
                            logData.Message,
                            logData.FileName,
                            logData.LineNumber,
                            logData.LinePosition);
                    }
                }

                return(ret);
            }
            catch (Exception e)
            {
                if (Fx.IsFatal(e))
                {
                    throw;
                }

                XamlBuildTaskServices.LogException(this.Log, e.Message);
                return(false);
            }
            finally
            {
                if (appDomain != null)
                {
                    AppDomain.Unload(appDomain);
                }
            }
        }
Esempio n. 9
0
 private void ValidateUnknown(XamlMember member)
 {
     if (member == XamlLanguage.UnknownContent)
     {
         ValidationError(SR.MemberUnknownContect(GetXamlTypeName(_stack.TopFrame.Type)));
     }
     else if (member.IsUnknown)
     {
         bool     retryAttachable = false;
         XamlType declaringType   = member.DeclaringType;
         if (_stack.Depth == 1 && declaringType.IsUnknown &&
             !string.IsNullOrEmpty(this.rootNamespace) &&
             this.definedType != null && declaringType.Name == this.definedType.Name)
         {
             // Need to handle the case where the namespace of a member on the document root
             // is missing the project root namespace
             string clrNs;
             if (XamlBuildTaskServices.TryExtractClrNs(declaringType.PreferredXamlNamespace, out clrNs))
             {
                 clrNs = string.IsNullOrEmpty(clrNs) ? this.rootNamespace : this.rootNamespace + "." + clrNs;
                 if (clrNs == this.definedType.Namespace)
                 {
                     declaringType   = SchemaContext.GetXamlType(this.definedType);
                     retryAttachable = true;
                 }
             }
         }
         XamlMember typeMember = declaringType.GetMember(member.Name);
         if (typeMember == null && retryAttachable)
         {
             typeMember = declaringType.GetAttachableMember(member.Name);
         }
         if (typeMember == null || typeMember.IsUnknown)
         {
             if (member.IsAttachable)
             {
                 ValidationError(SR.UnresolvedAttachableMember(GetXamlTypeName(member.DeclaringType) + "." + member.Name));
             }
             else if (member.IsDirective)
             {
                 ValidationError(SR.UnresolvedDirective(member.PreferredXamlNamespace + ":" + member.Name));
             }
             else
             {
                 // Skip if declaring type is unknown as the member unknown error messages become redundant.
                 if (declaringType != null && !declaringType.IsUnknown)
                 {
                     ValidationError(SR.UnresolvedMember(member.Name, GetXamlTypeName(declaringType)));
                 }
             }
         }
     }
 }
Esempio n. 10
0
        private void ThrowTypeValidationError(XamlType type)
        {
            string typeName, assemblyName, ns;

            if (XamlBuildTaskServices.GetTypeNameInAssemblyOrNamespace(type, this.localAssemblyName, this.realAssemblyName, out typeName, out assemblyName, out ns))
            {
                ValidationError(SR.UnresolvedTypeWithAssemblyName(ns + "." + typeName, assemblyName));
            }
            else
            {
                ValidationError(SR.UnresolvedTypeWithNamespace(typeName, ns));
            }
        }
Esempio n. 11
0
        public override IList <string> GetXamlNamespaces()
        {
            if (namespaces == null)
            {
                namespaces = new List <string>();
                IList <string> originalNamespaces = base.GetXamlNamespaces();

                foreach (var ns in originalNamespaces)
                {
                    namespaces.Add(XamlBuildTaskServices.UpdateClrNamespaceUriWithLocalAssembly(ns, this.localAssemblyName, this.realAssemblyName));
                }
            }
            return(namespaces);
        }
        bool ExecuteExtensions()
        {
            ResolveAssemblyHelper resolveAssemblyHelper = new ResolveAssemblyHelper(XamlBuildTaskServices.GetReferences(this.References));

            AppDomain.CurrentDomain.AssemblyResolve += resolveAssemblyHelper.ResolveLocalProjectReferences;

            bool extensionExecutedSuccessfully = true;

            try
            {
                IEnumerable <IXamlBuildTypeInspectionExtension> extensions =
                    XamlBuildTaskServices.GetXamlBuildTaskExtensions <IXamlBuildTypeInspectionExtension>(
                        this.XamlBuildTaskTypeInspectionExtensionNames,
                        this.BuildLogger,
                        this.MSBuildProjectDirectory);

                foreach (IXamlBuildTypeInspectionExtension extension in extensions)
                {
                    try
                    {
                        extensionExecutedSuccessfully &= extension.Execute(this.BuildContextForExtensions);
                    }
                    catch (FileNotFoundException e)
                    {
                        throw FxTrace.Exception.AsError(new LoggableException(SR.ExceptionThrownInExtension(extension.ToString(), e.GetType().ToString(), SR.AssemblyNotFound(ResolveAssemblyHelper.FileNotFound))));
                    }
                    catch (Exception e)
                    {
                        if (Fx.IsFatal(e))
                        {
                            throw;
                        }
                        throw FxTrace.Exception.AsError(new LoggableException(SR.ExceptionThrownInExtension(extension.ToString(), e.GetType().ToString(), e.Message)));
                    }
                }
                if (!this.BuildLogger.HasLoggedErrors && extensionExecutedSuccessfully)
                {
                    foreach (string file in this.BuildContextForExtensions.GeneratedFiles)
                    {
                        this.GeneratedCodeFiles.Add(file);
                    }
                }
            }
            finally
            {
                AppDomain.CurrentDomain.AssemblyResolve -= resolveAssemblyHelper.ResolveLocalProjectReferences;
            }
            return(extensionExecutedSuccessfully);
        }
Esempio n. 13
0
 IList <XamlType> UpdateTypeArgs(IList <XamlType> typeArgs, XamlSchemaContext xsc)
 {
     if (typeArgs != null)
     {
         IList <XamlType> updatedTypeArgs = new List <XamlType>();
         foreach (var typeArg in typeArgs)
         {
             IList <XamlType> typeArgTypeArgs = UpdateTypeArgs(typeArg.TypeArguments, xsc);
             string           typeArgXmlns    = XamlBuildTaskServices.UpdateClrNamespaceUriWithLocalAssembly(typeArg.PreferredXamlNamespace, this.localAssemblyName);
             updatedTypeArgs.Add(new XamlType(typeArgXmlns, typeArg.Name, typeArgTypeArgs, xsc));
         }
         return(updatedTypeArgs);
     }
     return(typeArgs);
 }
Esempio n. 14
0
        void WritestrippedXamlNode(XamlReader reader, XamlWriter writer)
        {
            switch (reader.NodeType)
            {
            case XamlNodeType.StartObject:
                XamlType xamlType = reader.Type;
                if (xamlType.IsUnknown)
                {
                    IList <XamlType> typeArgs = UpdateTypeArgs(xamlType.TypeArguments, reader.SchemaContext);
                    string           xmlns    = XamlBuildTaskServices.UpdateClrNamespaceUriWithLocalAssembly(xamlType.PreferredXamlNamespace, this.localAssemblyName);
                    xamlType = new XamlType(xmlns, xamlType.Name, typeArgs, reader.SchemaContext);
                }
                writer.WriteStartObject(xamlType);
                break;

            case XamlNodeType.StartMember:
                XamlMember member = reader.Member;
                if (member.IsUnknown && !member.IsDirective)
                {
                    string   xmlns          = XamlBuildTaskServices.UpdateClrNamespaceUriWithLocalAssembly(member.DeclaringType.PreferredXamlNamespace, this.localAssemblyName);
                    XamlType memberXamlType = new XamlType(xmlns, member.DeclaringType.Name, member.DeclaringType.TypeArguments, reader.SchemaContext);
                    member = new XamlMember(member.Name, memberXamlType, member.IsAttachable);
                }
                writer.WriteStartMember(member);
                break;

            case XamlNodeType.NamespaceDeclaration:
                NamespaceDeclaration ns = new NamespaceDeclaration(
                    XamlBuildTaskServices.UpdateClrNamespaceUriWithLocalAssembly(reader.Namespace.Namespace, this.localAssemblyName),
                    reader.Namespace.Prefix);
                writer.WriteNamespace(ns);
                break;

            case XamlNodeType.GetObject:
            case XamlNodeType.EndObject:
            case XamlNodeType.EndMember:
            case XamlNodeType.Value:
            case XamlNodeType.None:
                writer.WriteNode(reader);
                break;

            default:
                Debug.Fail("Unrecognized XamlNodeType value" + reader.NodeType.ToString());
                break;
            }
        }
Esempio n. 15
0
        internal static bool TryExtractClrNs(string @namespace, out string clrNs)
        {
            int nsIndex, assemblyIndex;

            if (XamlBuildTaskServices.IsClrNamespaceUri(@namespace, out nsIndex, out assemblyIndex))
            {
                clrNs = (assemblyIndex == -1)
                    ? @namespace.Substring(nsIndex).TrimEnd(' ', ';')
                    : @namespace.Substring(
                    nsIndex,
                    assemblyIndex - XamlBuildTaskServices.ClrNamespaceUriAssemblyPart.Length - nsIndex - 1).TrimEnd(' ', ';');
                return(true);
            }
            else
            {
                clrNs = null;
                return(false);
            }
        }
        bool ReuseAppDomainAndExecute()
        {
            AppDomain appDomain           = null;
            bool      createdNewAppDomain = false;

            try
            {
                try
                {
                    appDomain = GetInProcessAppDomain(out createdNewAppDomain);
                    bool ret = ExecuteInternal(appDomain);
                    return(ret);
                }
                catch (Exception e)
                {
                    if (Fx.IsFatal(e))
                    {
                        throw;
                    }
                    if (createdNewAppDomain)
                    {
                        XamlBuildTaskServices.LogException(this.Log, e.Message);
                        return(false);
                    }
                    else
                    {
                        if (inProcessAppDomain != null)
                        {
                            AppDomain.Unload(inProcessAppDomain);
                            inProcessAppDomain = null;
                        }
                        return(GetAppDomainAndExecute());
                    }
                }
            }
            finally
            {
                if (Log != null)
                {
                    Log.MarkAsInactive();
                }
            }
        }
        void PopulateBuildArtifacts(PartialClassGenerationTaskInternal wrapper)
        {
            IList <ITaskItem> applicationMarkup = null;

            if (this.ApplicationMarkup != null)
            {
                applicationMarkup = this.ApplicationMarkup
                                    .Select(i => new DelegatingTaskItem(i) as ITaskItem).ToList();
            }
            wrapper.ApplicationMarkup = applicationMarkup;

            wrapper.BuildLogger = this.Log;

            wrapper.References = this.References
                                 .Select(i => new DelegatingTaskItem(i) as ITaskItem).ToList();

            IList <string> sourceCodeFiles = null;

            if (this.SourceCodeFiles != null)
            {
                sourceCodeFiles = new List <string>(this.SourceCodeFiles.Length);
                foreach (ITaskItem taskItem in this.SourceCodeFiles)
                {
                    sourceCodeFiles.Add(taskItem.ItemSpec);
                }
            }
            wrapper.SourceCodeFiles = sourceCodeFiles;

            wrapper.Language                     = this.Language;
            wrapper.AssemblyName                 = this.AssemblyName;
            wrapper.OutputPath                   = this.OutputPath;
            wrapper.RootNamespace                = this.RootNamespace;
            wrapper.GeneratedSourceExtension     = this.GeneratedSourceExtension;
            wrapper.IsInProcessXamlMarkupCompile = this.IsInProcessXamlMarkupCompile;
            wrapper.MSBuildProjectDirectory      = this.MSBuildProjectDirectory;
            wrapper.XamlBuildTaskTypeGenerationExtensionNames = XamlBuildTaskServices.GetXamlBuildTaskExtensionNames(this.XamlBuildTypeGenerationExtensionNames);
            if (this.XamlBuildTypeInspectionExtensionNames != null && this.XamlBuildTypeInspectionExtensionNames.Length > 0)
            {
                wrapper.MarkupCompilePass2ExtensionsPresent = true;
            }

            wrapper.SupportExtensions = this.supportExtensions;
        }
Esempio n. 18
0
        private void ThrowGenericTypeValidationError(XamlType type)
        {
            IList <XamlType> unresolvedLeafTypeList = new List <XamlType>();

            XamlBuildTaskServices.GetUnresolvedLeafTypeArg(type, ref unresolvedLeafTypeList);
            if (unresolvedLeafTypeList.Count > 1 || !unresolvedLeafTypeList.Contains(type))
            {
                string fullTypeName = GetXamlTypeName(type);
                ValidationError(SR.UnresolvedGenericType(fullTypeName));
                foreach (XamlType xamlType in unresolvedLeafTypeList)
                {
                    ThrowTypeValidationError(xamlType);
                }
            }
            else
            {
                ThrowTypeValidationError(type);
            }
        }
Esempio n. 19
0
        XamlNodeList ReadXamlNodes(string xamlFileName)
        {
            XamlNodeList nodeList = new XamlNodeList(this.SchemaContext);

            try
            {
                XamlXmlReaderSettings settings = new XamlXmlReaderSettings
                {
                    AllowProtectedMembersOnRoot = true,
                    ProvideLineInfo             = true
                };

                using (StreamReader streamReader = new StreamReader(xamlFileName))
                {
                    XamlReader reader = new XamlXmlReader(XmlReader.Create(streamReader, new XmlReaderSettings {
                        XmlResolver = null
                    }), this.SchemaContext, settings);
                    XamlServices.Transform(reader, nodeList.Writer);
                }
            }
            catch (XmlException e)
            {
                XamlBuildTaskServices.LogException(this.BuildLogger, e.Message, xamlFileName, e.LineNumber, e.LinePosition);
                return(null);
            }
            catch (XamlException e)
            {
                XamlBuildTaskServices.LogException(this.BuildLogger, e.Message, xamlFileName, e.LineNumber, e.LinePosition);
                return(null);
            }

            if (nodeList.Count > 0)
            {
                return(nodeList);
            }
            else
            {
                return(null);
            }
        }
Esempio n. 20
0
        bool ProcessDirective(XamlReader reader, ClassData classData,
                              NamedObject currentObject, bool isRootElement, XamlNodeList strippedXamlNodes, out bool readNextNode)
        {
            Fx.Assert(reader.NodeType == XamlNodeType.StartMember, "Current node should be a Start Member Node");

            XamlMember member = reader.Member;
            bool       directiveRecognized = false;

            readNextNode = false;

            switch (member.Name)
            {
            case "Name":
                // Unlike all the other directives that we process, x:Name should be written
                // to the stripped output.
                strippedXamlNodes.Writer.WriteStartMember(member);

                string objectName = ReadAtom(reader, XamlLanguage.Name.Name);
                if (!objectName.StartsWith(XamlBuildTaskServices.SerializerReferenceNamePrefix,
                                           StringComparison.Ordinal))
                {
                    currentObject.Name = objectName;
                    classData.NamedObjects.Add(currentObject);
                }

                strippedXamlNodes.Writer.WriteValue(objectName);
                strippedXamlNodes.Writer.WriteEndMember();
                directiveRecognized = true;
                break;

            case "Class":
                if (isRootElement)
                {
                    string fullClassName = ReadAtom(reader, XamlLanguage.Class.Name);
                    SetClassName(fullClassName, classData);
                    directiveRecognized = true;
                }
                break;

            case "ClassModifier":
                if (isRootElement)
                {
                    string classModifier = ReadAtom(reader, XamlLanguage.ClassModifier.Name);
                    classData.IsPublic  = XamlBuildTaskServices.IsPublic(classModifier);
                    directiveRecognized = true;
                }
                break;

            case "FieldModifier":
                string fieldModifier = ReadAtom(reader, XamlLanguage.FieldModifier.Name);
                currentObject.Visibility = XamlBuildTaskServices.GetMemberVisibility(fieldModifier);
                directiveRecognized      = true;
                break;

            case "Code":
                string codeSnippet = ReadAtom(reader, XamlLanguage.Code.Name);
                classData.CodeSnippets.Add(codeSnippet);
                directiveRecognized = true;
                break;

            case "Members":
                foreach (PropertyData property in ReadProperties(reader.ReadSubtree()))
                {
                    classData.Properties.Add(property);
                }
                if (!classData.RequiresCompilationPass2)
                {
                    foreach (PropertyData property in classData.Properties)
                    {
                        if (property.Type.IsUnknown)
                        {
                            classData.RequiresCompilationPass2 = true;
                            break;
                        }
                    }
                }
                directiveRecognized = true;
                readNextNode        = true;
                break;

            case "ClassAttributes":
                foreach (AttributeData attribute in ReadAttributesCollection(reader.ReadSubtree()))
                {
                    classData.Attributes.Add(attribute);
                }
                directiveRecognized = true;
                readNextNode        = true;
                break;
            }

            if (directiveRecognized == true && readNextNode == false)
            {
                reader.Read();
                Fx.Assert(reader.NodeType == XamlNodeType.EndMember, "Current node should be a XamlEndmember");
            }

            return(directiveRecognized);
        }
Esempio n. 21
0
        XamlNodeList RewriteRootNode(XamlNodeList strippedXamlNodes, string name, string @namespace)
        {
            // Rewrite the root node to have the name of class declared via x:Class (rather than the base class)
            // Also, for any properties on the root object that are declared in this class, need to rewrite the
            // namespace to include the root namespace, if there is one.

            string oldNamespace = null;

            if (!string.IsNullOrEmpty(this.rootNamespace))
            {
                oldNamespace = @namespace;
                if (!string.IsNullOrEmpty(@namespace))
                {
                    @namespace = this.rootNamespace + "." + @namespace;
                }
                else
                {
                    @namespace = this.rootNamespace;
                }
            }

            string namespaceName = string.Format(CultureInfo.InvariantCulture, "{0}{1};{2}{3}", XamlBuildTaskServices.ClrNamespaceUriNamespacePart, @namespace, XamlBuildTaskServices.ClrNamespaceUriAssemblyPart, this.localAssemblyName);

            XamlReader        reader = strippedXamlNodes.GetReader();
            XamlSchemaContext xsc    = reader.SchemaContext;
            XamlNodeList      newStrippedXamlNodes = new XamlNodeList(xsc);
            XamlWriter        writer = newStrippedXamlNodes.Writer;

            int      depth        = 0;
            XamlType rootXamlType = null;

            while (reader.Read())
            {
                switch (reader.NodeType)
                {
                case XamlNodeType.StartObject:
                case XamlNodeType.GetObject:
                    depth++;
                    break;

                case XamlNodeType.EndObject:
                    depth--;
                    break;
                }
                if (reader.NodeType == XamlNodeType.StartObject && depth == 1)
                {
                    rootXamlType = new XamlType(namespaceName, name, null, xsc);
                    writer.WriteStartObject(rootXamlType);
                }
                else if (reader.NodeType == XamlNodeType.StartMember && depth == 1 && reader.Member.IsUnknown &&
                         reader.Member.DeclaringType != null && reader.Member.DeclaringType.Name == rootXamlType.Name)
                {
                    string     clrNs;
                    XamlMember member = reader.Member;
                    if (XamlBuildTaskServices.TryExtractClrNs(member.PreferredXamlNamespace, out clrNs) &&
                        clrNs == oldNamespace)
                    {
                        // This is a member defined on the document root type, but missing the project root namespace. Fix it.
                        XamlMember newMember = new XamlMember(member.Name, rootXamlType, member.IsAttachable);
                        Fx.Assert(rootXamlType != null, "First StartObject should already have been processed");
                        writer.WriteStartMember(newMember);
                    }
                    else
                    {
                        writer.WriteNode(reader);
                    }
                }
                else
                {
                    writer.WriteNode(reader);
                }
            }

            writer.Close();
            return(newStrippedXamlNodes);
        }
 AppDomain CreateNewAppDomain()
 {
     return(XamlBuildTaskServices.CreateAppDomain("PartialClassAppDomain_" + Guid.NewGuid(), BuildTaskPath));
 }
Esempio n. 23
0
        bool ProcessMarkupItem(ITaskItem markupItem, CodeDomProvider codeDomProvider)
        {
            string markupItemFileName = markupItem.ItemSpec;

            XamlBuildTaskServices.PopulateModifiers(codeDomProvider);

            XamlNodeList xamlNodes = ReadXamlNodes(markupItemFileName);

            if (xamlNodes == null)
            {
                return(false);
            }

            ClassData classData = ReadClassData(xamlNodes, markupItemFileName);

            string outputFileName = GetFileName(markupItemFileName);
            string codeFileName   = Path.ChangeExtension(outputFileName, GetGeneratedSourceExtension(codeDomProvider));
            string markupFileName = Path.ChangeExtension(outputFileName, GeneratedSourceExtension + XamlBuildTaskServices.XamlExtension);

            classData.EmbeddedResourceFileName = Path.GetFileName(markupFileName);
            classData.HelperClassFullName      = this.HelperClassFullName;

            // Check if code file with partial class exists
            classData.SourceFileExists = UserProvidedFileExists(markupItemFileName, codeDomProvider);

            // Store the full type name as metadata on the markup item
            string rootNamespacePrefix = null;
            string namespacePrefix     = null;
            string typeFullName        = null;

            if (this.Language.Equals("VB") && !String.IsNullOrWhiteSpace(classData.RootNamespace))
            {
                rootNamespacePrefix = classData.RootNamespace + ".";
            }

            if (!String.IsNullOrWhiteSpace(classData.Namespace))
            {
                namespacePrefix = classData.Namespace + ".";
            }

            if (rootNamespacePrefix != null)
            {
                if (namespacePrefix != null)
                {
                    typeFullName = rootNamespacePrefix + namespacePrefix + classData.Name;
                }
                else
                {
                    typeFullName = rootNamespacePrefix + classData.Name;
                }
            }
            else
            {
                if (namespacePrefix != null)
                {
                    typeFullName = namespacePrefix + classData.Name;
                }
                else
                {
                    typeFullName = classData.Name;
                }
            }

            markupItem.SetMetadata("typeName", typeFullName);

            // Execute extensions here to give them a chance to mutate the ClassData before we generate code.
            if (this.SupportExtensions)
            {
                if (!ExecuteExtensions(classData, markupItem))
                {
                    return(false);
                }
            }

            // Generate code file
            CodeCompileUnit codeUnit = new ClassGenerator(this.BuildLogger, codeDomProvider, this.Language).Generate(classData);

            WriteCode(codeDomProvider, codeUnit, codeFileName);
            this.GeneratedCodeFiles.Add(codeFileName);

            // Generate resource file
            if (!string.IsNullOrEmpty(this.AssemblyName))
            {
                // Generate xaml "implementation" file
                XmlWriterSettings xmlSettings = new XmlWriterSettings {
                    Indent = true, IndentChars = "  ", CloseOutput = true
                };
                using (XmlWriter xmlWriter = XmlWriter.Create(File.Open(markupFileName, FileMode.Create), xmlSettings))
                {
                    XamlXmlWriterSettings xamlSettings = new XamlXmlWriterSettings()
                    {
                        CloseOutput = true
                    };

                    // Process EmbeddedResourceXaml to remove xml:space="preserve"
                    // due to a bug in XamlXmlWriter. XamlXmlWriter throws
                    // if there are duplicate xml:space attributes.
                    // It is ok to remove the xml:space attribute
                    // as the XamlXmlWriter would add it in the next step
                    // if needed.
                    RemoveXamlSpaceAttribute(classData);

                    using (XamlReader reader = classData.EmbeddedResourceXaml.GetReader())
                    {
                        using (XamlXmlWriter xamlWriter = new XamlXmlWriter(xmlWriter, reader.SchemaContext, xamlSettings))
                        {
                            XamlServices.Transform(reader, xamlWriter);
                        }
                    }
                }
                this.GeneratedResources.Add(markupFileName);
            }

            if (classData.RequiresCompilationPass2)
            {
                this.RequiresCompilationPass2 = true;
            }
            else
            {
                if (!this.SupportExtensions)
                {
                    if (!ValidateXaml(xamlNodes, markupItemFileName))
                    {
                        this.RequiresCompilationPass2 = true;
                    }
                }
                else
                {
                    // skip validation if we are doing in-proc compile
                    // OR if we have pass 2 extensions hooked up
                    // as we anyway need to run pass 2 in that case
                    if (!this.IsInProcessXamlMarkupCompile && !this.MarkupCompilePass2ExtensionsPresent)
                    {
                        if (!ValidateXaml(xamlNodes, markupItemFileName))
                        {
                            this.RequiresCompilationPass2 = true;
                        }
                    }
                }
            }
            return(true);
        }
Esempio n. 24
0
 private string GetXamlTypeName(XamlType type)
 {
     return(XamlBuildTaskServices.GetTypeName(type, this.localAssemblyName, this.realAssemblyName));
 }
Esempio n. 25
0
        void PopulateBuildArtifacts(CompilationPass2TaskInternal wrapper)
        {
            if (!this.supportExtensions)
            {
                IList <string> applicationMarkup = new List <string>(this.ApplicationMarkup.Length);
                foreach (ITaskItem taskItem in this.ApplicationMarkup)
                {
                    applicationMarkup.Add(taskItem.ItemSpec);
                }
                wrapper.ApplicationMarkup = applicationMarkup;
            }

            wrapper.SupportExtensions = this.supportExtensions;

            wrapper.BuildLogger = this.Log;

            wrapper.References = this.References
                                 .Select(i => new DelegatingTaskItem(i) as ITaskItem).ToList();

            wrapper.LocalAssemblyReference = this.LocalAssemblyReference;

            wrapper.AssemblyName = this.AssemblyName;

            wrapper.RootNamespace = this.RootNamespace;

            wrapper.Language = this.Language;

            wrapper.OutputPath = this.OutputPath;

            wrapper.IsInProcessXamlMarkupCompile = this.IsInProcessXamlMarkupCompile;

            wrapper.MSBuildProjectDirectory = this.MSBuildProjectDirectory;

            IList <string> sourceCodeFiles = null;

            if (this.SourceCodeFiles != null)
            {
                sourceCodeFiles = new List <string>(this.SourceCodeFiles.Length);
                foreach (ITaskItem taskItem in this.SourceCodeFiles)
                {
                    sourceCodeFiles.Add(taskItem.ItemSpec);
                }
            }
            wrapper.SourceCodeFiles = sourceCodeFiles;

            if (this.supportExtensions)
            {
                wrapper.XamlBuildTaskTypeInspectionExtensionNames = XamlBuildTaskServices.GetXamlBuildTaskExtensionNames(this.XamlBuildTypeInspectionExtensionNames);

                // Here we create a Dictionary of Type Full Name and corresponding TaskItem
                // This is passed to the extensions which enables them to look up
                // metadata about a type like file name.
                IDictionary <string, ITaskItem> applicationMarkupWithTypeName = null;
                if (this.ApplicationMarkupWithTypeName != null)
                {
                    applicationMarkupWithTypeName = new Dictionary <string, ITaskItem>();
                }
                foreach (ITaskItem taskItem in this.ApplicationMarkupWithTypeName)
                {
                    string typeName = taskItem.GetMetadata("typeName");
                    if (!String.IsNullOrWhiteSpace(typeName))
                    {
                        applicationMarkupWithTypeName.Add(typeName, new DelegatingTaskItem(taskItem));
                    }
                }
                wrapper.ApplicationMarkupWithTypeName = applicationMarkupWithTypeName;
            }
        }
        public override bool Execute()
        {
            bool retVal;

            try
            {
                XDocument projectDocument = XDocument.Load(this.CurrentProject);
                if (projectDocument != null)
                {
                    XElement projectElement = projectDocument.Element(XName.Get("Project", MSBuildNamespace));
                    if (projectElement != null)
                    {
                        RemoveItemsByName(projectElement, this.ApplicationMarkupTypeName);
                        RemoveItemsByName(projectElement, "Reference");
                        RemoveItemsByName(projectElement, "ProjectReference");
                        if (this.supportExtensions)
                        {
                            AddNewResourceItems(projectElement, this.GeneratedResourcesFiles);
                        }
                        AddNewItems(projectElement, "Compile", this.SourceCodeFiles);
                        AddNewItems(projectElement, "ReferencePath", this.ReferencePaths);

                        RemovePropertyByName(projectElement, "OutputType");
                        RemovePropertyByName(projectElement, "AssemblyName");
                        AddNewProperties(projectElement,
                                         new ProjectProperty[] {
                            new ProjectProperty()
                            {
                                Name = "OutputType", Value = "Library"
                            },
                            new ProjectProperty()
                            {
                                Name = "AssemblyName", Value = this.AssemblyName
                            },
                            new ProjectProperty()
                            {
                                Name = "Utf8Output", Value = "true", Condition = "'$(Utf8Output)' == ''"
                            }
                        });
                    }
                }

                string randomName = Path.GetRandomFileName();
                randomName = Path.ChangeExtension(randomName, "");
                string filename = Path.ChangeExtension(randomName, ".tmp_proj");
                projectDocument.Save(filename);
                Hashtable globalProperties = new Hashtable();
                globalProperties["IntermediateOutputPath"] = this.OutputPath;
                globalProperties["AssemblyName"]           = this.AssemblyName;
                globalProperties["OutputType"]             = "Library";
                retVal = base.BuildEngine.BuildProjectFile(filename, new string[] { this.CompileTargetName }, globalProperties, null);
                File.Delete(filename);
                return(retVal);
            }
            catch (Exception e)
            {
                if (Fx.IsFatal(e))
                {
                    throw;
                }

                // Log unknown errors that do not originate from the task.
                // Assumes that all known errors are logged when the exception is thrown.
                XamlBuildTaskServices.LogException(this.Log, e.Message);
                retVal = false;
            }
            return(retVal);
        }
Esempio n. 27
0
        public bool Execute()
        {
            try
            {
                if (this.ApplicationMarkup == null || this.ApplicationMarkup.Count == 0)
                {
                    return(true);
                }
                if (!CodeDomProvider.IsDefinedLanguage(this.Language))
                {
                    throw FxTrace.Exception.Argument("Language", SR.UnrecognizedLanguage(this.Language));
                }

                if (this.SupportExtensions)
                {
                    this.xamlBuildTypeGenerationExtensions = XamlBuildTaskServices.GetXamlBuildTaskExtensions <IXamlBuildTypeGenerationExtension>(
                        this.XamlBuildTaskTypeGenerationExtensionNames,
                        this.BuildLogger,
                        this.MSBuildProjectDirectory);
                }

                AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += new ResolveEventHandler(XamlBuildTaskServices.ReflectionOnlyAssemblyResolve);
                bool retVal = true;
                // We load the assemblies for the real builds
                // For intellisense builds, we load them the first time only
                if (!IsInProcessXamlMarkupCompile || this.LoadedAssemblyList == null)
                {
                    if (this.References != null)
                    {
                        try
                        {
                            this.LoadedAssemblyList = XamlBuildTaskServices.Load(this.References, IsInProcessXamlMarkupCompile);
                        }
                        catch (FileNotFoundException e)
                        {
                            XamlBuildTaskServices.LogException(this.BuildLogger, e.Message, e.FileName, 0, 0);
                            retVal = false;
                        }
                    }
                }

                CodeDomProvider codeDomProvider = CodeDomProvider.CreateProvider(this.Language);

                ProcessHelperClassGeneration(codeDomProvider);
                foreach (ITaskItem app in ApplicationMarkup)
                {
                    string inputMarkupFile = app.ItemSpec;
                    try
                    {
                        retVal &= ProcessMarkupItem(app, codeDomProvider);
                    }
                    catch (LoggableException e)
                    {
                        if (Fx.IsFatal(e))
                        {
                            throw;
                        }
                        XamlBuildTaskServices.LogException(this.BuildLogger, e.Message, e.Source, e.LineNumber, e.LinePosition);
                        retVal = false;
                    }
                    catch (FileLoadException e)
                    {
                        if (Fx.IsFatal(e))
                        {
                            throw;
                        }

                        XamlBuildTaskServices.LogException(this.BuildLogger, SR.AssemblyCannotBeResolved(XamlBuildTaskServices.FileNotLoaded), inputMarkupFile, 0, 0);
                        retVal = false;
                    }
                    catch (Exception e)
                    {
                        if (Fx.IsFatal(e))
                        {
                            throw;
                        }
                        XamlBuildTaskServices.LogException(this.BuildLogger, e.Message, inputMarkupFile, 0, 0);
                        retVal = false;
                    }
                }

                // Add the files generated from extensions
                if (this.SupportExtensions)
                {
                    if (retVal)
                    {
                        foreach (string fileName in this.BuildContextForExtensions.GeneratedFiles)
                        {
                            this.GeneratedCodeFiles.Add(fileName);
                        }

                        foreach (string fileName in this.BuildContextForExtensions.GeneratedResourceFiles)
                        {
                            this.GeneratedResources.Add(fileName);
                        }
                    }
                }

                return(retVal);
            }
            catch (Exception e)
            {
                if (Fx.IsFatal(e))
                {
                    throw;
                }

                // Log unknown errors that do not originate from the task.
                // Assumes that all known errors are logged when the exception is thrown.
                if (!(e is LoggableException))
                {
                    XamlBuildTaskServices.LogException(this.BuildLogger, e.Message);
                }
                return(false);
            }
        }
        public bool Execute()
        {
            try
            {
                if ((!this.SupportExtensions) && ((this.ApplicationMarkup == null) || this.ApplicationMarkup.Count == 0))
                {
                    return(true);
                }
                else if (this.ApplicationMarkupWithTypeName == null || this.ApplicationMarkupWithTypeName.Count == 0)
                {
                    return(true);
                }

                IList <Assembly> loadedAssemblyList = null;
                if (this.References != null)
                {
                    loadedAssemblyList = XamlBuildTaskServices.Load(this.References, false);
                }

                Assembly localAssembly = null;
                if (LocalAssemblyReference != null)
                {
                    try
                    {
                        localAssembly = XamlBuildTaskServices.Load(LocalAssemblyReference);
                        loadedAssemblyList.Add(localAssembly);
                    }
                    catch (FileNotFoundException e)
                    {
                        XamlBuildTaskServices.LogException(this.BuildLogger, e.Message, e.FileName, 0, 0);
                        return(false);
                    }
                }

                AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += new ResolveEventHandler(XamlBuildTaskServices.ReflectionOnlyAssemblyResolve);
                XamlNsReplacingContext wxsc = new XamlNsReplacingContext(loadedAssemblyList, localAssembly.GetName().Name, this.AssemblyName);

                bool foundValidationErrors = false;
                if (!this.SupportExtensions)
                {
                    foreach (string app in ApplicationMarkup)
                    {
                        try
                        {
                            if (!ProcessMarkupItem(app, wxsc, localAssembly))
                            {
                                foundValidationErrors = true;
                            }
                        }
                        catch (Exception e)
                        {
                            if (Fx.IsFatal(e))
                            {
                                throw;
                            }
                            XamlBuildTaskServices.LogException(this.BuildLogger, e.Message, app, 0, 0);
                            return(false);
                        }
                    }
                }
                else
                {
                    foreach (ITaskItem app in this.ApplicationMarkupWithTypeName.Values)
                    {
                        string inputMarkupFile = app.ItemSpec;
                        try
                        {
                            if (!ProcessMarkupItem(inputMarkupFile, wxsc, localAssembly))
                            {
                                foundValidationErrors = true;
                            }
                        }
                        catch (Exception e)
                        {
                            if (Fx.IsFatal(e))
                            {
                                throw;
                            }
                            XamlBuildTaskServices.LogException(this.BuildLogger, e.Message, inputMarkupFile, 0, 0);
                            return(false);
                        }
                    }
                    if (!foundValidationErrors)
                    {
                        foundValidationErrors = !ExecuteExtensions();
                        if (!foundValidationErrors)
                        {
                            foundValidationErrors = this.BuildLogger.HasLoggedErrors;
                        }
                    }
                }
                return(!foundValidationErrors);
            }
            catch (Exception e)
            {
                if (Fx.IsFatal(e))
                {
                    throw;
                }

                // Log unknown errors that do not originate from the task.
                // Assumes that all known errors are logged when the exception is thrown.
                XamlBuildTaskServices.LogException(this.BuildLogger, e.Message);
                return(false);
            }
        }