/// <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);
}
}
}