/// <summary> /// Sets the value of an attribute, removing the attribute if the value is null, but still setting it /// if the value is the empty string. Returns the attribute, or null if it was removed. /// UNDONE: Make this return a bool if the attribute did not change, so we can avoid dirtying. /// </summary> internal static XmlAttributeWithLocation SetOrRemoveAttribute(XmlElementWithLocation element, string name, string value, bool allowSettingEmptyAttributes) { if (value == null || (!allowSettingEmptyAttributes && value.Length == 0)) { // The caller passed in a null or an empty value. So remove the attribute. element.RemoveAttribute(name); return null; } else { // Set the new attribute value element.SetAttribute(name, value); XmlAttributeWithLocation attribute = (XmlAttributeWithLocation)element.Attributes[name]; return attribute; } }
/// <summary> /// Processes the <Folder> element, and adds an appropriate item to the /// filesItemGroup. /// </summary> /// <owner>RGoel</owner> private void ProcessFolderElement ( XmlElementWithLocation folderElement, ProjectItemGroupElement filesItemGroup ) { // Make sure this is the <Folder> element. error.VerifyThrow((folderElement != null) && (folderElement.Name == VSProjectElements.folder), "Expected <Folder> element."); // Make sure the caller has already created an ProjectItemGroupElement for us to // put the new items in. error.VerifyThrow(filesItemGroup != null, "Received null ProjectItemGroupElement"); // Get the required "RelPath" attribute. string relPath = folderElement.GetAttribute(VSProjectAttributes.relPath); ProjectErrorUtilities.VerifyThrowInvalidProject((relPath != null) && (relPath.Length > 0), folderElement.Location, "MissingAttribute", VSProjectAttributes.relPath, VSProjectElements.folder); // Remove the "RelPath" attribute, so we don't end up adding it twice. folderElement.RemoveAttribute(VSProjectAttributes.relPath); // We need to find out what type of folder this is -- a web references // folder, a web reference URL, or just an empty project folder. // See if there's a "WebReferences" attribute on the <Folder> element. If so, // and the value is set to "True", then it's a web reference folder. string webReferences = folderElement.GetAttribute(VSProjectAttributes.webReferences); // Remove the "WebReferences" attribute, so we don't end up adding it twice. folderElement.RemoveAttribute(VSProjectAttributes.webReferences); // See if there's a "WebReferenceURL" attribute. If so, it's a web reference // URL. string webReferenceUrl = folderElement.GetAttribute(VSProjectAttributes.webReferenceUrl); // Remove the "WebReferenceURL" attribute, so we don't end up adding it twice. folderElement.RemoveAttribute(VSProjectAttributes.webReferenceUrl); ProjectItemElement newFolderItem; if ((webReferences != null) && (0 == String.Compare(webReferences, "true", StringComparison.OrdinalIgnoreCase))) { // This is a web reference folder. // The <Folder> element gets converted to XMake as an item of type // "WebReferences". The "Include" will contain the relative path. // For example, // ----------------------------------------------------------------------- // Everett format: // =============== // <Folder // RelPath = "Web References\" // WebReferences = "TRUE" // /> // ----------------------------------------------------------------------- // XMake format: // ============= // <WebReferences Include = "Web References\" /> // ----------------------------------------------------------------------- newFolderItem = filesItemGroup.AddItem(XMakeProjectStrings.webReferences, ProjectCollection.Escape(relPath)); } else if ((webReferenceUrl != null) && (webReferenceUrl.Length > 0)) { // This is an actual web reference URL. // The <Folder> element gets converted to XMake as an item of type // "WebReferenceURL". The "Include" will contain the URL. // For example, // ----------------------------------------------------------------------- // Everett format: // =============== // <Folder // RelPath = "Web References\mobileakipman\" // WebReferenceUrl = "http://mobileakipman/HelloName/service1.asmx" // UrlBehavior = "Static" // /> // ----------------------------------------------------------------------- // XMake format: // ============= // <WebReferenceUrl Include="http://mobileakipman/HelloName/service1.asmx"> // <RelPath>Web References\mobileakipman\</RelPath> // <UrlBehavior>Static</UrlBehavior> // </WebReferenceUrl> // ----------------------------------------------------------------------- newFolderItem = filesItemGroup.AddItem(XMakeProjectStrings.webReferenceUrl, ProjectCollection.Escape(webReferenceUrl)); newFolderItem.AddMetadata(XMakeProjectStrings.relPath, ProjectCollection.Escape(relPath)); // Whidbey projects have some new properties to control the behavior of the // proxy generation. For projects migrated from Everett, we want to force // the proxy generation to mimic the Everett behavior, so that people's projects // still work the same as they did in Everett. (These properties did not // exist in Everett.) See spec at: // http://devdiv/SpecTool/Documents/Whidbey/VSCore/Solution%20Project%20Build/FeatureSpecs/Project-WebReferences.doc if (!this.newWebReferencePropertiesAdded) { this.globalPropertyGroup.AddProperty(XMakeProjectStrings.webRefEnableProperties, (this.language == VSProjectElements.visualJSharp) ? "false" : "true"); this.globalPropertyGroup.AddProperty(XMakeProjectStrings.webRefEnableSqlTypes, "false"); this.globalPropertyGroup.AddProperty(XMakeProjectStrings.webRefEnableLegacyEventing, "true"); this.newWebReferencePropertiesAdded = true; } } else { // This is just a project folder that happens not to have any files in it. // The <Folder> element gets converted to XMake as an item of type "Folder". // However, we do need to remove the trailing backslash, because XMake // interprets that as a recursion (bug # 58591). For example, // ----------------------------------------------------------------------- // Everett format: // =============== // <Folder // RelPath = "MyEmptyProjectFolder\" // /> // ----------------------------------------------------------------------- // XMake format: // ============= // <Folder Include="MyEmptyProjectFolder" /> // ----------------------------------------------------------------------- // Remove the trailing backslash. XMake interprets trailing backslashes // as a recursive wildcard. This will be fixed in M2 -- bug # 58591 if (relPath.EndsWith("\\", StringComparison.Ordinal)) { relPath = relPath.Remove(relPath.Length - 1, 1); } newFolderItem = filesItemGroup.AddItem(XMakeProjectStrings.folder, ProjectCollection.Escape(relPath)); } // Add all the rest of the attributes on the <Folder> element to the new // XMake item. foreach (XmlAttribute folderAttribute in folderElement.Attributes) { newFolderItem.AddMetadata(folderAttribute.Name, ProjectCollection.Escape(folderAttribute.Value)); } // There should be no children of the <Folder> element. ProjectXmlUtilities.VerifyThrowProjectNoChildElements(folderElement); }
/// <summary> /// Processes the <Service> element, and add an appropriate reference /// items to the startupServicesItemGroup. /// </summary> /// <owner>RGoel</owner> private void ProcessServiceElement ( XmlElementWithLocation serviceElement, ProjectItemGroupElement startupServicesItemGroup ) { // Make sure this is the <Service> element. error.VerifyThrow((serviceElement != null) && (serviceElement.Name == VSProjectElements.service), "Expected <Service> element."); // Make sure the caller has already created an ProjectItemGroupElement for us to // put the new items in. error.VerifyThrow(startupServicesItemGroup != null, "Received null ProjectItemGroupElement"); // Get the required "ID" attribute. string id = serviceElement.GetAttribute(VSProjectAttributes.id); ProjectErrorUtilities.VerifyThrowInvalidProject((id != null) && (id.Length > 0), serviceElement.Location, "MissingAttribute", VSProjectAttributes.id, VSProjectElements.service); // Remove the "ID" attribute, so it doesn't show up in our loop later. serviceElement.RemoveAttribute(VSProjectAttributes.id); // The <Service> element gets converted to XMake as an item of type "Service". // The "ID" attribute becomes the "Include" for the new item. For // example, // ----------------------------------------------------------------------- // Everett format: // =============== // <Service ID = "ABCD1234-78F4-4F98-AFD6-720DA6E648A2" /> // ----------------------------------------------------------------------- // XMake format: // ============= // <Service Include="ABCD1234-78F4-4F98-AFD6-720DA6E648A2" /> // ----------------------------------------------------------------------- startupServicesItemGroup.AddItem(XMakeProjectStrings.service, ProjectCollection.Escape(id)); // There should be no other attributes on the <Service> element (besides // "ID" which we already took care of). But loop through them // anyway, so we can emit a useful error message. foreach (XmlAttributeWithLocation serviceAttribute in serviceElement.Attributes) { ProjectErrorUtilities.VerifyThrowInvalidProject(false, serviceAttribute.Location, "UnrecognizedAttribute", serviceAttribute.Name, VSProjectElements.service); } // There should be no children of the <Service> element. ProjectXmlUtilities.VerifyThrowProjectNoChildElements(serviceElement); }
/// <summary> /// Processes the <Import> element, and add an appropriate reference /// items to the importsItemGroup. /// </summary> /// <owner>RGoel</owner> private void ProcessImportElement ( XmlElementWithLocation importElement, ProjectItemGroupElement importsItemGroup ) { // Make sure this is the <Import> element. error.VerifyThrow((importElement != null) && (importElement.Name == VSProjectElements.import), "Expected <Import> element."); // Make sure the caller has already created an ProjectItemGroupElement for us to // put the new items in. error.VerifyThrow(importsItemGroup != null, "Received null ProjectItemGroupElement"); // Get the required "Namespace" attribute. string importNamespace = importElement.GetAttribute(VSProjectAttributes.importNamespace); ProjectErrorUtilities.VerifyThrowInvalidProject((importNamespace != null) && (importNamespace.Length > 0), importElement.Location, "MissingAttribute", VSProjectAttributes.importNamespace, VSProjectElements.import); // Remove the "Namespace" attribute, so it doesn't show up in our loop later. importElement.RemoveAttribute(VSProjectAttributes.importNamespace); // The <Import> element gets converted to XMake as an item of type "Import". // The "Namespace" attribute becomes the "Include" for the new item. For // example, // ----------------------------------------------------------------------- // Everett format: // =============== // <Import Namespace = "System.Collections" /> // ----------------------------------------------------------------------- // XMake format: // ============= // <Import Include="System.Collections" /> // ----------------------------------------------------------------------- importsItemGroup.AddItem(XMakeProjectStrings.import, ProjectCollection.Escape(importNamespace)); // There should be no other attributes on the <Import> element (besides // "Namespace" which we already took care of). But loop through them // anyway, so we can emit a useful error message. foreach (XmlAttributeWithLocation importAttribute in importElement.Attributes) { ProjectErrorUtilities.VerifyThrowInvalidProject(false, importAttribute.Location, "UnrecognizedAttribute", importAttribute.Name, VSProjectElements.import); } // There should be no children of the <Import> element. ProjectXmlUtilities.VerifyThrowProjectNoChildElements(importElement); }
/// <summary> /// Processes the <File> element, and adds an appropriate item to the /// filesItemGroup. /// </summary> /// <owner>RGoel</owner> private void ProcessFileElement ( XmlElementWithLocation fileElement, ProjectItemGroupElement filesItemGroup ) { // Make sure this is the <File> element. error.VerifyThrow((fileElement != null) && (fileElement.Name == VSProjectElements.file), "Expected <File> element."); // Make sure the caller has already created an ProjectItemGroupElement for us to // put the new items in. error.VerifyThrow(filesItemGroup != null, "Received null ProjectItemGroupElement"); // Get the required "RelPath" attribute. string relPath = fileElement.GetAttribute(VSProjectAttributes.relPath); ProjectErrorUtilities.VerifyThrowInvalidProject((relPath != null) && (relPath.Length > 0), fileElement.Location, "MissingAttribute", VSProjectAttributes.relPath, VSProjectElements.file); // Remove the "RelPath" attribute, so we don't end up adding it twice. fileElement.RemoveAttribute(VSProjectAttributes.relPath); // Get the "Link" attribute. This is for linked items only. string linkPath = fileElement.GetAttribute(VSProjectAttributes.link); // Remove the "Link" attribute, so we don't end up adding it twice. fileElement.RemoveAttribute(VSProjectAttributes.link); // Get the "BuildAction" attribute. If it doesn't exist, figure out // what the build action is based on the file extension. This is // what the project loading code does in VS. string buildAction = fileElement.GetAttribute(VSProjectAttributes.buildAction); if ((buildAction == null) || (buildAction.Length == 0)) { buildAction = VSProjectAttributes.buildActionNone; } // Remove the "BuildAction" attribute, so we don't end up adding it twice. fileElement.RemoveAttribute(VSProjectAttributes.buildAction); ProjectItemElement newFileItem; // Bug Whidbey #248965. If a .resx file is completely empty, do not include a reference // to it in the upgraded project file. if (! (0 == String.Compare(Path.GetExtension(relPath), ".resx", StringComparison.OrdinalIgnoreCase) && IsFilePresentButEmpty(relPath, linkPath)) ) { // Add the new item to XMake. if ((linkPath == null) || (linkPath.Length == 0)) { // Normal item. // The <File> element gets converted to XMake as a new item, where // the item type is the BuildAction, and the "Include" contains // the relative path to the item. For // example, // ----------------------------------------------------------------------- // Everett format: // =============== // <File // RelPath = "Properties\PropertyGroupCollection.cs" // SubType = "Code" // BuildAction = "Compile" // /> // ----------------------------------------------------------------------- // XMake format: // ============= // <Compile Include = "Properties\PropertyGroupCollection.cs"> // <SubType>Code</SubType> // </Compile> // ----------------------------------------------------------------------- newFileItem = filesItemGroup.AddItem(buildAction, ProjectCollection.Escape(relPath)); } else { // Linked item. // The <File> element gets converted to XMake as a new item, where // the item type is the BuildAction, the "Include" contains // the physical relative path to the item, and the non-XMake "Link" // attribute contains the project-relative path for item (for display // purposes in the Solution Explorer). For example, // ----------------------------------------------------------------------- // Everett format: // =============== // <File // RelPath = "Properties\PropertyGroupCollection.cs" // Link = "c:\Rajeev\External\PropertyGroupCollection.cs" // SubType = "Code" // BuildAction = "Compile" // /> // ----------------------------------------------------------------------- // XMake format: // ============= // <Compile Include = "c:\Rajeev\External\PropertyGroupCollection.cs"> // <Link>Properties\PropertyGroupCollection.cs</Link> // <SubType>Code</SubType> // </Compile> // ----------------------------------------------------------------------- newFileItem = filesItemGroup.AddItem(buildAction, ProjectCollection.Escape(linkPath)); newFileItem.AddMetadata(XMakeProjectStrings.link, ProjectCollection.Escape(relPath)); } // Add all the rest of the attributes on the <File> element to the new // XMake item. foreach (XmlAttribute fileAttribute in fileElement.Attributes) { newFileItem.AddMetadata(fileAttribute.Name, ProjectCollection.Escape(fileAttribute.Value)); } // If this is a VSD(devices) project and we're dealing with a content file, // mark it to copy if newer. if ( ( ( ( this.language == VSProjectElements.ECSharp ) || ( this.language == VSProjectElements.EVisualBasic ) ) ) && ( 0 == String.Compare ( buildAction, XMakeProjectStrings.content, StringComparison.OrdinalIgnoreCase ) ) ) { newFileItem.AddMetadata ( XMakeProjectStrings.copytooutput, XMakeProjectStrings.preservenewest ); } } else { string warning = ResourceUtilities.FormatString( AssemblyResources.GetString("EmptyResxRemoved"), relPath); conversionWarnings.Add(warning); } // There should be no children of the <File> element. ProjectXmlUtilities.VerifyThrowProjectNoChildElements(fileElement); }
/// <summary> /// Given an element corresponding to a .NET Assembly reference, create the appropriate element in the new project /// </summary> /// <param name="referenceElement"></param> /// <param name="referencesItemGroup"></param> /// <param name="referenceName"></param> /// <returns></returns> private ProjectItemElement ConvertAssemblyReference(XmlElementWithLocation referenceElement, ProjectItemGroupElement referencesItemGroup, string referenceName) { ProjectItemElement newReferenceItem; // This is a regular .NET assembly reference. // This gets added as a new XMake item of type "Reference". The "Include" // attribute is the assembly name, and all the other attributes remain // the same. For example, // ----------------------------------------------------------------------- // Everett format: // =============== // <Reference // Name = "System.Xml" // AssemblyName = "System.Xml" // HintPath = "..\..\binaries\x86chk\bin\i386\System.Xml.dll" // /> // ----------------------------------------------------------------------- // XMake format: // ============= // <Reference Include="System.Xml"> // <Name>System.Xml</Name> // <HintPath>..\..\binaries\x86chk\bin\i386\System.Xml.dll</HintPath> // </Reference> // ----------------------------------------------------------------------- // Get the "AssemblyName" attribute. If not found, just use the value from the // "Name" attribute. This is what the project loading code does in VS. string assemblyName = referenceElement.GetAttribute(VSProjectAttributes.assemblyName); if ((assemblyName == null) || (assemblyName.Length == 0)) { assemblyName = referenceName; } else { // Remove the "AssemblyName" attribute so we don't add it again at // the end. referenceElement.RemoveAttribute(VSProjectAttributes.assemblyName); } // MyType should only be added when System.Windows.Forms is present. If this // reference is seen, then set a flag so we can later add MyType. if (0 == String.Compare("System.Windows.Forms", assemblyName, StringComparison.OrdinalIgnoreCase)) { hasWindowsFormsReference = true; } // Remove hint paths that we think are to RTM or Everett framework assemblies string hintPath = referenceElement.GetAttribute(VSProjectAttributes.hintPath); if (hintPath != null) { hintPath = hintPath.ToUpper(CultureInfo.InvariantCulture); if (hintPath.IndexOf(LegacyFrameworkPaths.RTMFrameworkPath, StringComparison.Ordinal) != -1 || hintPath.IndexOf(LegacyFrameworkPaths.EverettFrameworkPath, StringComparison.Ordinal) != -1 || hintPath.IndexOf(LegacyFrameworkPaths.JSharpRTMFrameworkPath, StringComparison.Ordinal) != -1) { referenceElement.RemoveAttribute(VSProjectAttributes.hintPath); } } newReferenceItem = referencesItemGroup.AddItem(XMakeProjectStrings.reference, ProjectCollection.Escape(assemblyName)); return newReferenceItem; }
/// <summary> /// Given an element corresponding to a COM reference, create the appropriate element in the new project /// </summary> /// <param name="referenceElement"></param> /// <param name="referencesItemGroup"></param> /// <param name="referenceName"></param> /// <returns></returns> private static ProjectItemElement ConvertClassicComReference(XmlElementWithLocation referenceElement, ProjectItemGroupElement referencesItemGroup, string referenceName) { ProjectItemElement newReferenceItem; // This is a classic COM reference. // This gets added as a new XMake item of type "COMReference". // The "Include" attribute will contain the reference name, // and all the other attributes remain the same. For example, // ----------------------------------------------------------------------- // Everett format: // =============== // <Reference // Name = "UTILITIESLib" // Guid = "{0EF79DA1-6555-11D2-A889-00AA006C2A9A}" // VersionMajor = "1" // VersionMinor = "0" // Lcid = "0" // WrapperTool = "tlbimp" // /> // ----------------------------------------------------------------------- // XMake format: // ============= // <COMReference Include = "UTILITIESLib"> // <Guid>{0EF79DA1-6555-11D2-A889-00AA006C2A9A}</Guid> // <VersionMajor>1</VersionMajor> // <VersionMinor>0</VersionMinor> // <Lcid>0</Lcid> // <WrapperTool>tlbimp</WrapperTool> // </COMReference> // ----------------------------------------------------------------------- // Remove the "Name" attribute so we don't add it again at the end. referenceElement.RemoveAttribute(VSProjectAttributes.name); // Add a new item to XMake of type "COMReference". newReferenceItem = referencesItemGroup.AddItem(XMakeProjectStrings.comReference, ProjectCollection.Escape(referenceName)); return newReferenceItem; }
/// <summary> /// Processes the <Reference> element, and add an appropriate reference /// items to the referencesItemGroup. /// </summary> /// <owner>RGoel</owner> private void ProcessReferenceElement ( XmlElementWithLocation referenceElement, ProjectItemGroupElement referencesItemGroup ) { // Make sure this is the <Reference> element. error.VerifyThrow((referenceElement != null) && (referenceElement.Name == VSProjectElements.reference), "Expected <Reference> element."); // Make sure the caller has already created an ProjectItemGroupElement for us to // put the new items in. error.VerifyThrow(referencesItemGroup != null, "Received null ProjectItemGroupElement"); // Before we do anything else, look for the "Platform" attribute. // If it's available, we need to remove it, and if it ends in // "-Designer", we need to disregard this reference entirely. string platform = referenceElement.GetAttribute(VSProjectAttributes.platform); if ((platform != null) && (platform.Length > 0)) { if (platform.IndexOf("-Designer", 0, platform.Length, StringComparison.Ordinal) != -1) { return; } referenceElement.RemoveAttribute ( VSProjectAttributes.platform ); } ProjectItemElement newReferenceItem; // Get the "Name" attribute. This is a required attribute in the VS7/ // Everett format. string referenceName = referenceElement.GetAttribute(VSProjectAttributes.name); ProjectErrorUtilities.VerifyThrowInvalidProject((referenceName != null) && (referenceName.Length > 0), referenceElement.Location, "MissingAttribute", VSProjectAttributes.name, VSProjectElements.reference); // Before we go any further, we must special-case some assemblies for VSD projects. if ( ( ( this.language == VSProjectElements.ECSharp ) || ( this.language == VSProjectElements.EVisualBasic ) ) ) { if ( ( this.frameworkVersionForVSD == XMakeProjectStrings.vTwo ) && ( 0 == String.Compare ( referenceName, VSProjectElements.SystemDataCommon, StringComparison.OrdinalIgnoreCase ) ) ) { // We need to remove all references to "System.Data.Common" for VSD projects only. // Note : We only want to do this for projects that will be updated to v2.0 // System.Data.Common is still valid for v1.0 upgraded projects. return; } else if ( 0 == String.Compare ( referenceName, VSProjectElements.SystemSR, StringComparison.OrdinalIgnoreCase ) ) { // We always want to remove all references to "System.SR" return; } } if ( ( this.language == VSProjectElements.EVisualBasic ) && ( 0 == String.Compare ( referenceName, VSProjectElements.MSCorLib, StringComparison.OrdinalIgnoreCase ) ) ) { // We also want to get rid of all 'mscorlib' references for VB projects only. return; } // We need to find out what type of reference this is -- a .NET assembly // reference, a COM reference, or a project reference. In the XMake format, // we use separate item types for each of these. // See if there's a "Guid" attribute on the <Reference> element. If so, // it's a classic COM reference. string comReferenceGuid = referenceElement.GetAttribute(VSProjectAttributes.guid); // See if there's a "Project" guid attribute. If so, it's a project // reference. string referencedProjectGuid = referenceElement.GetAttribute(VSProjectAttributes.project); if ((comReferenceGuid != null) && (comReferenceGuid.Length > 0) && (comReferenceGuid != "{00000000-0000-0000-0000-000000000000}")) { newReferenceItem = ConvertClassicComReference(referenceElement, referencesItemGroup, referenceName); } else if ((referencedProjectGuid != null) && (referencedProjectGuid.Length > 0)) { newReferenceItem = ConvertProjectToProjectReference(referenceElement, referencesItemGroup, referenceName, ref referencedProjectGuid); } else { newReferenceItem = ConvertAssemblyReference(referenceElement, referencesItemGroup, referenceName); } // Add all the rest of the attributes on the <Reference> element to the new // XMake item. foreach (XmlAttribute referenceAttribute in referenceElement.Attributes) { newReferenceItem.AddMetadata(referenceAttribute.Name, ProjectCollection.Escape(referenceAttribute.Value)); } // There should be no children of the <Reference> element. ProjectXmlUtilities.VerifyThrowProjectNoChildElements(referenceElement); }
/// <summary> /// Processes the <Config> element, and everything within it. As it is /// doing this, it will add stuff to the xmakeProject, including new /// configuration-specific property groups. /// </summary> /// <owner>RGoel</owner> private void ProcessConfigElement ( XmlElementWithLocation configElement ) { // Make sure this is the <Config> element. error.VerifyThrow((configElement != null) && (configElement.Name == VSProjectElements.config), "Expected <Config> element."); // Make sure the caller has given us a valid xmakeProject object. error.VerifyThrow(xmakeProject != null, "Expected valid XMake project object."); // All of the attributes on the <Config> tag get converted to XMake // properties, except for the "Name" attribute which becomes part of // the "Condition" on the <PropertyGroup>. For example, // ----------------------------------------------------------------------- // Everett format: // =============== // <Config // Name = "Debug" // AllowUnsafeBlocks = "false" // BaseAddress = "285212672" // CheckForOverflowUnderflow = "false" // ConfigurationOverrideFile = "" // DefineConstants = "DEBUG;TRACE" // DocumentationFile = "" // DebugSymbols = "true" // FileAlignment = "4096" // IncrementalBuild = "true" // NoStdLib = "false" // NoWarn = "" // Optimize = "false" // OutputPath = "bin\Debug\" // RegisterForComInterop = "false" // RemoveIntegerChecks = "false" // TreatWarningsAsErrors = "true" // WarningLevel = "4" // /> // ----------------------------------------------------------------------- // XMake format: // ============= // <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> // <AllowUnsafeBlocks>false</AllowUnsafeBlocks> // <BaseAddress>285212672</BaseAddress> // <CheckForOverflowUnderflow>false</CheckForOverflowUnderflow> // <ConfigurationOverrideFile></ConfigurationOverrideFile> // <DefineConstants>DEBUG;TRACE</DefineConstants> // <DocumentationFile></DocumentationFile> // <DebugSymbols>true</DebugSymbols> // <FileAlignment>4096</FileAlignment> // <NoStdLib>false</NoStdLib> // <NoWarn></NoWarn> // <Optimize>false</Optimize> // <OutputPath>bin\Debug\</OutputPath> // <RegisterForComInterop>false</RegisterForComInterop> // <RemoveIntegerChecks>false</RemoveIntegerChecks> // <TreatWarningsAsErrors>true</TreatWarningsAsErrors> // <WarningLevel>4</WarningLevel> // </PropertyGroup> // ----------------------------------------------------------------------- // Get the "Name" attribute of the <Config> element. string configName = configElement.GetAttribute(VSProjectAttributes.name); ProjectErrorUtilities.VerifyThrowInvalidProject((configName != null) && (configName.Length > 0), configElement.Location, "MissingAttribute", VSProjectElements.config, VSProjectAttributes.name); // In the case of VSD projects, the "Name" attribute will have a pipe in it, // followed by the device platform. This last part needs to be removed, // leaving just the config name. if ( ( this.language == VSProjectElements.ECSharp ) || ( this.language == VSProjectElements.EVisualBasic ) ) { int pipeLocation = configName.IndexOf ( '|' ); if ( pipeLocation != -1 ) { configName = configName.Remove ( pipeLocation, configName.Length - pipeLocation ); } } // Remove the "Name" attribute from the <Config> element, so it doesn't get // added as an XMake property. configElement.RemoveAttribute(VSProjectAttributes.name); // PPD@31111: J# Only: We need to remove the AdditionalOptions attribute // (and note it down) before we create the property group out of the configElement string additionalOptionsValue = null; if (VSProjectElements.visualJSharp == this.language) { additionalOptionsValue = configElement.GetAttribute(VSProjectAttributes.additionalOptions); // Dont bother about getting a null value for additionalOptionsValue // GetAttribute return String.Empty if the attribute is not present configElement.RemoveAttribute(VSProjectAttributes.additionalOptions); } // Create a new property group, and add all of the XML attributes as XMake // properties. ProjectPropertyGroupElement configPropertyGroup = xmakeProject.AddPropertyGroup(); // Process OutputPath attribute separately to ensure it contains trailing backslash string outputPath = configElement.GetAttribute(VSProjectAttributes.outputPath); if (outputPath != null && outputPath.Length > 0) { if (outputPath[outputPath.Length-1] != Path.DirectorySeparatorChar) outputPath += Path.DirectorySeparatorChar; configElement.RemoveAttribute(VSProjectAttributes.outputPath); configPropertyGroup.AddProperty(VSProjectAttributes.outputPath, ProjectCollection.Escape(outputPath)); } // If the "SelectedDevice" or "DeploymentPlatform" attributes exist in the per-user // project file, we should get rid of them. string selectedDevice = configElement.GetAttribute ( VSProjectAttributes.selectedDevice ); if ( isUserFile && ( selectedDevice != null ) && ( selectedDevice.Length > 0 ) ) { configElement.RemoveAttribute ( VSProjectAttributes.selectedDevice ); } string deploymentPlatform = configElement.GetAttribute ( VSProjectAttributes.deploymentPlatform ); if ( isUserFile && ( deploymentPlatform != null ) && ( deploymentPlatform.Length > 0 ) ) { configElement.RemoveAttribute ( VSProjectAttributes.deploymentPlatform ); } // Get rid of the "IncrementalBuild" attribute string incrementalBuild = configElement.GetAttribute ( VSProjectAttributes.incrementalBuild ); if (incrementalBuild != null && incrementalBuild.Length > 0) { configElement.RemoveAttribute ( VSProjectAttributes.incrementalBuild ); } // VSWhidbey bug 261464. For VB projects migrated from VS7/Everett, the VB team would // like to enable XML documentation by default (this feature was unavailable to VB users // in VS7/Everett. To enable for VB, set the DocumentationFile property to <assemblyname>.xml if ((!this.isUserFile) && (VSProjectElements.visualBasic == this.language)) { string documentationFile = this.assemblyName + XMakeProjectStrings.xmlFileExtension; configPropertyGroup.AddProperty(VSProjectAttributes.documentationFile, ProjectCollection.Escape(documentationFile)); } // process the rest of Config attributes this.AddXMakePropertiesFromXMLAttributes(configPropertyGroup, configElement); // PPD@31111: J# Only: We now need to parse the additionalOptionsValue for properties and // add the individual properties to configPropertyGroup. // This needs to be done after the AddXMakePropertiesFromXMLAttributes call above since // an property defined in the AdditionalOptions takes precedence. if (VSProjectElements.visualJSharp == this.language) { AdditionalOptionsParser addnlOptParser = new AdditionalOptionsParser(); addnlOptParser.ProcessAdditionalOptions(additionalOptionsValue, configPropertyGroup); } // VSWhidbey bug 302946. For VB projects migrated from VS7/Everett, the VB team would // like to disable the following new warnings for Whidbey: 42016,42017,42018,42019,42032 // New projects created in Whidbey already have these warnings disabled by default. if ((!this.isUserFile) && (VSProjectElements.visualBasic == this.language)) { configPropertyGroup.AddProperty(XMakeProjectStrings.noWarn, XMakeProjectStrings.disabledVBWarnings); } // VSWhidbey bug 472064. For all projects that are converted, if "DebugSymbols" is set for a // particular platform/configuration, we set a "DebugType" property if and only if "DebugType" property // is not already there. DebugType is set to "full" for DebugSymbols=true, DebugType is set to "none" // if DebugSymbols=false, and we don't do anything if DebugSymbols is not present in the source project. if (!this.isUserFile) { string debugType = configElement.GetAttribute(VSProjectAttributes.debugType); if (String.IsNullOrEmpty(debugType)) { string debugSymbols = configElement.GetAttribute(XMakeProjectStrings.debugSymbols); if ( 0 == String.Compare ( debugSymbols, "true", StringComparison.OrdinalIgnoreCase ) ) { configPropertyGroup.AddProperty(VSProjectAttributes.debugType, VSProjectAttributes.debugTypeFull); } else if ( 0 == String.Compare(debugSymbols, "false", StringComparison.OrdinalIgnoreCase) ) { configPropertyGroup.AddProperty(VSProjectAttributes.debugType, VSProjectAttributes.debugTypeNone); } } } // VSWhidbey bug 472064. For all VC# projects that are converted, we add an ErrorReport // property, always set to "prompt" if ( !this.isUserFile && this.language == VSProjectElements.cSharp ) { configPropertyGroup.AddProperty(VSProjectAttributes.errorReport, VSProjectAttributes.errorReportPrompt); } // Platform of course depends on the language we are dealing with - J# in whidbey supports only x86 string platform = (this.language != VSProjectElements.visualJSharp) ? XMakeProjectStrings.defaultPlatform : XMakeProjectStrings.x86Platform; // Add the "Condition" to the new <PropertyGroup>. configPropertyGroup.Condition = XMakeProjectStrings.configplatformPrefix + ProjectCollection.Escape(configName) + XMakeProjectStrings.configplatformSeparator + ProjectCollection.Escape(platform) + XMakeProjectStrings.configplatformSuffix; // Loop through all the direct child elements of the <Config> element. foreach(XmlNode configChildNode in configElement) { // Handle XML comments under the the <Config> node (just ignore them). if ((configChildNode.NodeType == XmlNodeType.Comment) || (configChildNode.NodeType == XmlNodeType.Whitespace)) { continue; } if (configChildNode.NodeType == XmlNodeType.Element) { XmlElementWithLocation configChildElement = (XmlElementWithLocation)configChildNode; switch (configChildElement.Name) { // The <InteropRegistration> element. case VSProjectElements.interopRegistration: this.ProcessInteropRegistrationElement((XmlElementWithLocation)configChildElement, configPropertyGroup); break; default: ProjectErrorUtilities.VerifyThrowInvalidProject(false, configChildElement.Location, "UnrecognizedChildElement", configChildElement.Name, VSProjectElements.config); break; } } else { ProjectXmlUtilities.ThrowProjectInvalidChildElement(configChildNode.Name, configElement.Name, configElement.Location); } } }
/// <summary> /// Processes the <Settings> element, and everything within it. As it is /// doing this, it will add stuff to the xmakeProject. /// </summary> /// <owner>RGoel</owner> private void ProcessSettingsElement ( XmlElementWithLocation settingsElement ) { // Make sure this is the <Settings> element. error.VerifyThrow((settingsElement != null) && (settingsElement.Name == VSProjectElements.settings), "Expected <Settings> element."); // Make sure the caller has given us a valid xmakeProject object. error.VerifyThrow(xmakeProject != null, "Expected valid XMake project object."); // Make sure the caller has given us a valid globalPropertyGroup object. error.VerifyThrow(globalPropertyGroup != null, "Expected valid global ProjectPropertyElementGroup."); // All of the attributes on the <Settings> tag get converted to XMake // properties, except for PreBuildEvent and PostBuildEvent. For example, // ----------------------------------------------------------------------- // Everett format: // =============== // <Settings // ApplicationIcon = "" // AssemblyKeyContainerName = "" // AssemblyName = "XMakeBuildEngine" // AssemblyOriginatorKeyFile = "" // DefaultClientScript = "JScript" // DefaultHTMLPageLayout = "Grid" // DefaultTargetSchema = "IE50" // DelaySign = "false" // OutputType = "Library" // PreBuildEvent = "" // PostBuildEvent = "..\..\PostBuildEvent.bat" // RootNamespace = "XMakeBuildEngine" // RunPostBuildEvent = "OnBuildSuccess" // StartupObject = "" // > // ... // ... // ... // </Settings> // ----------------------------------------------------------------------- // XMake format: // ============= // <PropertyGroup> // <ApplicationIcon></ApplicationIcon> // <AssemblyKeyContainerName></AssemblyKeyContainerName> // <AssemblyName>XMakeBuildEngine</AssemblyName> // <AssemblyOriginatorKeyFile></AssemblyOriginatorKeyFile> // <DefaultClientScript>JScript</DefaultClientScript> // <DefaultHTMLPageLayout>Grid</DefaultHTMLPageLayout> // <DefaultTargetSchema>IE50</DefaultTargetSchema> // <DelaySign>false</DelaySign> // <OutputType>Library</OutputType> // <RootNamespace>XMakeBuildEngine</RootNamespace> // <RunPostBuildEvent>OnBuildSuccess</RunPostBuildEvent> // <StartupObject></StartupObject> // </PropertyGroup> // ----------------------------------------------------------------------- // The "PreBuildEvent" and "PostBuildEvent" properties need to be handled // specially. These can contain references to predefined macros, such // as "$(ProjectDir)". But these get defined in Microsoft.CSharp.targets, so the // "PreBuildEvent" and "PostBuildEvent" properties need to get added to // the project file *after* the <Import> for Microsoft.CSharp.targets. For now, // just save the values of these two properties. this.preBuildEvent = settingsElement.GetAttribute(VSProjectAttributes.preBuildEvent); settingsElement.RemoveAttribute(VSProjectAttributes.preBuildEvent); this.postBuildEvent = settingsElement.GetAttribute(VSProjectAttributes.postBuildEvent); settingsElement.RemoveAttribute(VSProjectAttributes.postBuildEvent); // cache the assembly name in case its needed to upgrade the // documentation file property) this.assemblyName = settingsElement.GetAttribute(VSProjectAttributes.assemblyName); // cache the output type. this.outputType = settingsElement.GetAttribute(XMakeProjectStrings.outputType); // Take care of copying all the other normal properties. this.AddXMakePropertiesFromXMLAttributes(this.globalPropertyGroup, settingsElement); // Loop through all the direct child elements of the <Build> element. foreach(XmlNode settingsChildNode in settingsElement) { // Handle XML comments under the the <Settings> node (just ignore them). if ((settingsChildNode.NodeType == XmlNodeType.Comment) || (settingsChildNode.NodeType == XmlNodeType.Whitespace)) { continue; } if (settingsChildNode.NodeType == XmlNodeType.Element) { XmlElementWithLocation settingsChildElement = (XmlElementWithLocation)settingsChildNode; switch (settingsChildElement.Name) { // The <Config> element. case VSProjectElements.config: this.ProcessConfigElement(settingsChildElement); break; // In the case of a VSD project, the <Platform> element case VSProjectElements.platform: this.ProcessPlatformElement(settingsChildElement); break; default: ProjectErrorUtilities.VerifyThrowInvalidProject(false, settingsChildElement.Location, "UnrecognizedChildElement", settingsChildElement.Name, VSProjectElements.settings); break; } } else { ProjectXmlUtilities.ThrowProjectInvalidChildElement(settingsChildNode.Name, settingsElement.Name, settingsElement.Location); } } }