/// <summary>
/// Parse a ProjectTaskElement
/// </summary>
private ProjectTaskElement ParseProjectTaskElement(XmlElementWithLocation element, ProjectTargetElement parent)
{
foreach (XmlAttributeWithLocation attribute in element.Attributes)
{
ProjectErrorUtilities.VerifyThrowInvalidProject
(
!XMakeAttributes.IsBadlyCasedSpecialTaskAttribute(attribute.Name),
attribute.Location,
"BadlyCasedSpecialTaskAttribute",
attribute.Name,
element.Name,
element.Name
);
}
ProjectTaskElement task = new ProjectTaskElement(element, parent, _project);
foreach (XmlElementWithLocation childElement in ProjectXmlUtilities.GetVerifyThrowProjectChildElements(element))
{
ProjectErrorUtilities.VerifyThrowInvalidProject(childElement.Name == XMakeElements.output, childElement.Location, "UnrecognizedChildElement", childElement.Name, task.Name);
ProjectOutputElement output = ParseProjectOutputElement(childElement, task);
task.AppendParentedChildNoChecks(output);
}
return(task);
}
/// <summary>
/// Parse a UsingTaskParameterGroupElement from the element
/// </summary>
private UsingTaskParameterGroupElement ParseUsingTaskParameterGroupElement(XmlElementWithLocation element, ProjectElementContainer parent)
{
// There should be no attributes
ProjectXmlUtilities.VerifyThrowProjectNoAttributes(element);
UsingTaskParameterGroupElement parameterGroup = new UsingTaskParameterGroupElement(element, parent, _project);
HashSet <String> listOfChildElementNames = new HashSet <string>();
foreach (XmlElementWithLocation childElement in ProjectXmlUtilities.GetVerifyThrowProjectChildElements(element))
{
// The parameter already exists this means there is a duplicate child item. Throw an exception.
if (listOfChildElementNames.Contains(childElement.Name))
{
ProjectXmlUtilities.ThrowProjectInvalidChildElementDueToDuplicate(childElement);
}
else
{
ProjectUsingTaskParameterElement parameter = ParseUsingTaskParameterElement(childElement, parameterGroup);
parameterGroup.AppendParentedChildNoChecks(parameter);
// Add the name of the child element to the hashset so we can check for a duplicate child element
listOfChildElementNames.Add(childElement.Name);
}
}
return(parameterGroup);
}
/// <summary>
/// Parses the project into the ProjectRootElement
/// </summary>
private void Parse()
{
// XML guarantees exactly one root element
XmlElementWithLocation element = null;
foreach (XmlNode childNode in _document.ChildNodes)
{
if (childNode.NodeType == XmlNodeType.Element)
{
element = (XmlElementWithLocation)childNode;
break;
}
}
ProjectErrorUtilities.VerifyThrowInvalidProject(element != null, ElementLocation.Create(_document.FullPath), "NoRootProjectElement", XMakeElements.project);
ProjectErrorUtilities.VerifyThrowInvalidProject(element.Name != XMakeElements.visualStudioProject, element.Location, "ProjectUpgradeNeeded", _project.FullPath);
ProjectErrorUtilities.VerifyThrowInvalidProject(element.LocalName == XMakeElements.project, element.Location, "UnrecognizedElement", element.Name);
// If a namespace was specified it must be the default MSBuild namespace.
if (!ProjectXmlUtilities.VerifyValidProjectNamespace(element))
{
ProjectErrorUtilities.ThrowInvalidProject(element.Location, "ProjectMustBeInMSBuildXmlNamespace",
XMakeAttributes.defaultXmlNamespace);
}
else
{
_project.XmlNamespace = element.NamespaceURI;
}
ParseProjectElement(element);
}
/// <summary>
/// Parse a ProjectOutputElement
/// </summary>
private ProjectOutputElement ParseProjectOutputElement(XmlElementWithLocation element, ProjectTaskElement parent)
{
ProjectXmlUtilities.VerifyThrowProjectAttributes(element, s_validAttributesOnOutput);
ProjectXmlUtilities.VerifyThrowProjectRequiredAttribute(element, XMakeAttributes.taskParameter);
ProjectXmlUtilities.VerifyThrowProjectNoChildElements(element);
string taskParameter = element.GetAttribute(XMakeAttributes.taskParameter);
string itemName = element.GetAttribute(XMakeAttributes.itemName);
string propertyName = element.GetAttribute(XMakeAttributes.propertyName);
ProjectErrorUtilities.VerifyThrowInvalidProject
(
(itemName.Length > 0 || propertyName.Length > 0) && (itemName.Length == 0 || propertyName.Length == 0),
element.Location,
"InvalidTaskOutputSpecification",
parent.Name
);
ProjectXmlUtilities.VerifyThrowProjectAttributeEitherMissingOrNotEmpty(element, XMakeAttributes.itemName);
ProjectXmlUtilities.VerifyThrowProjectAttributeEitherMissingOrNotEmpty(element, XMakeAttributes.propertyName);
ProjectErrorUtilities.VerifyThrowInvalidProject(!ReservedPropertyNames.IsReservedProperty(propertyName), element.Location, "CannotModifyReservedProperty", propertyName);
return(new ProjectOutputElement(element, parent, _project));
}
/// <summary>
/// Parse the children of a When or Otherwise
/// </summary>
private void ParseWhenOtherwiseChildren(XmlElementWithLocation element, ProjectElementContainer parent, int nestingDepth)
{
foreach (XmlElementWithLocation childElement in ProjectXmlUtilities.GetVerifyThrowProjectChildElements(element))
{
ProjectElement child = null;
switch (childElement.Name)
{
case XMakeElements.propertyGroup:
child = ParseProjectPropertyGroupElement(childElement, parent);
break;
case XMakeElements.itemGroup:
child = ParseProjectItemGroupElement(childElement, parent);
break;
case XMakeElements.choose:
child = ParseProjectChooseElement(childElement, parent, nestingDepth);
break;
default:
ProjectXmlUtilities.ThrowProjectInvalidChildElement(childElement.Name, element.Name, element.Location);
break;
}
parent.AppendParentedChildNoChecks(child);
}
}
/// <summary>
/// Parse a ProjectImportElement that is contained in an ImportGroup
/// </summary>
private ProjectImportElement ParseProjectImportElement(XmlElementWithLocation element, ProjectElementContainer parent)
{
ProjectErrorUtilities.VerifyThrowInvalidProject
(
parent is ProjectRootElement || parent is ProjectImportGroupElement,
element.Location,
"UnrecognizedParentElement",
parent,
element
);
ProjectXmlUtilities.VerifyThrowProjectAttributes(element, ValidAttributesOnImport);
ProjectXmlUtilities.VerifyThrowProjectRequiredAttribute(element, XMakeAttributes.project);
ProjectXmlUtilities.VerifyThrowProjectNoChildElements(element);
SdkReference sdk = null;
if (element.HasAttribute(XMakeAttributes.sdk))
{
sdk = new SdkReference(
ProjectXmlUtilities.GetAttributeValue(element, XMakeAttributes.sdk, nullIfNotExists: true),
ProjectXmlUtilities.GetAttributeValue(element, XMakeAttributes.sdkVersion, nullIfNotExists: true),
ProjectXmlUtilities.GetAttributeValue(element, XMakeAttributes.sdkMinimumVersion, nullIfNotExists: true));
}
return(new ProjectImportElement(element, parent, _project, sdk));
}
/// <summary>
/// Parse the child of a ProjectRootElement
/// </summary>
private void ParseProjectRootElementChildren(XmlElementWithLocation element)
{
foreach (XmlElementWithLocation childElement in ProjectXmlUtilities.GetVerifyThrowProjectChildElements(element))
{
ProjectElement child = null;
switch (childElement.Name)
{
case XMakeElements.propertyGroup:
child = ParseProjectPropertyGroupElement(childElement, _project);
break;
case XMakeElements.itemGroup:
child = ParseProjectItemGroupElement(childElement, _project);
break;
case XMakeElements.importGroup:
child = ParseProjectImportGroupElement(childElement, _project);
break;
case XMakeElements.import:
child = ParseProjectImportElement(childElement, _project);
break;
case XMakeElements.usingTask:
child = ParseProjectUsingTaskElement(childElement);
break;
case XMakeElements.target:
child = ParseProjectTargetElement(childElement);
break;
case XMakeElements.itemDefinitionGroup:
child = ParseProjectItemDefinitionGroupElement(childElement);
break;
case XMakeElements.choose:
child = ParseProjectChooseElement(childElement, _project, 0 /* nesting depth */);
break;
case XMakeElements.projectExtensions:
child = ParseProjectExtensionsElement(childElement);
break;
// Obsolete
case XMakeElements.error:
case XMakeElements.warning:
case XMakeElements.message:
ProjectErrorUtilities.ThrowInvalidProject(childElement.Location, "ErrorWarningMessageNotSupported", childElement.Name);
break;
default:
ProjectXmlUtilities.ThrowProjectInvalidChildElement(childElement.Name, childElement.ParentNode.Name, childElement.Location);
break;
}
_project.AppendParentedChildNoChecks(child);
}
}
/// <summary>
/// Parse a ProjectPropertyElement from the element
/// </summary>
private ProjectPropertyElement ParseProjectPropertyElement(XmlElementWithLocation element, ProjectPropertyGroupElement parent)
{
ProjectXmlUtilities.VerifyThrowProjectAttributes(element, s_validAttributesOnlyConditionAndLabel);
XmlUtilities.VerifyThrowProjectValidElementName(element);
ProjectErrorUtilities.VerifyThrowInvalidProject(XMakeElements.IllegalItemPropertyNames[element.Name] == null && !ReservedPropertyNames.IsReservedProperty(element.Name), element.Location, "CannotModifyReservedProperty", element.Name);
// All children inside a property are ignored, since they are only part of its value
return(new ProjectPropertyElement(element, parent, _project));
}
/// <summary>
/// Parse a ProjectOnErrorElement
/// </summary>
private ProjectOnErrorElement ParseProjectOnErrorElement(XmlElementWithLocation element, ProjectTargetElement parent)
{
// Previous OM accidentally didn't verify ExecuteTargets on parse,
// but we do, as it makes no sense
ProjectXmlUtilities.VerifyThrowProjectAttributes(element, s_validAttributesOnOnError);
ProjectXmlUtilities.VerifyThrowProjectRequiredAttribute(element, XMakeAttributes.executeTargets);
ProjectXmlUtilities.VerifyThrowProjectNoChildElements(element);
return(new ProjectOnErrorElement(element, parent, _project));
}
/// <summary>
/// Parse a ProjectWhenElement
/// </summary>
private ProjectWhenElement ParseProjectWhenElement(XmlElementWithLocation element, ProjectChooseElement parent, int nestingDepth)
{
ProjectXmlUtilities.VerifyThrowProjectRequiredAttribute(element, XMakeAttributes.condition);
ProjectWhenElement when = new ProjectWhenElement(element, parent, _project);
ParseWhenOtherwiseChildren(element, when, nestingDepth);
return(when);
}
/// <summary>
/// Parse a ProjectOtherwiseElement
/// </summary>
private ProjectOtherwiseElement ParseProjectOtherwiseElement(XmlElementWithLocation element, ProjectChooseElement parent, int nestingDepth)
{
ProjectXmlUtilities.VerifyThrowProjectNoAttributes(element);
ProjectOtherwiseElement otherwise = new ProjectOtherwiseElement(element, parent, _project);
ParseWhenOtherwiseChildren(element, otherwise, nestingDepth);
return(otherwise);
}
/// <summary>
/// Constructor called by derived classes, except from ProjectRootElement.
/// Parameters may not be null, except parent.
/// </summary>
internal ProjectElement(XmlElement xmlElement, ProjectElementContainer parent, ProjectRootElement containingProject)
{
ErrorUtilities.VerifyThrowArgumentNull(xmlElement, "xmlElement");
ProjectXmlUtilities.VerifyThrowProjectValidNamespace((XmlElementWithLocation)xmlElement);
ErrorUtilities.VerifyThrowArgumentNull(containingProject, "containingProject");
this.XmlElement = (XmlElementWithLocation)xmlElement;
_parent = parent;
this.ContainingProject = containingProject;
}
/// <summary>
/// Parse a ProjectExtensionsElement
/// </summary>
private ProjectExtensionsElement ParseProjectExtensionsElement(XmlElementWithLocation element)
{
// ProjectExtensions are only found in the main project file - in fact, the code used to ignore them in imported
// files. We don't.
ProjectXmlUtilities.VerifyThrowProjectNoAttributes(element);
ProjectErrorUtilities.VerifyThrowInvalidProject(!_seenProjectExtensions, element.Location, "DuplicateProjectExtensions");
_seenProjectExtensions = true;
// All children inside ProjectExtensions are ignored, since they are only part of its value
return(new ProjectExtensionsElement(element, _project, _project));
}
/// <summary>
/// Parse a ProjectPropertyGroupElement from the element
/// </summary>
private ProjectPropertyGroupElement ParseProjectPropertyGroupElement(XmlElementWithLocation element, ProjectElementContainer parent)
{
ProjectXmlUtilities.VerifyThrowProjectAttributes(element, s_validAttributesOnlyConditionAndLabel);
ProjectPropertyGroupElement propertyGroup = new ProjectPropertyGroupElement(element, parent, _project);
foreach (XmlElementWithLocation childElement in ProjectXmlUtilities.GetVerifyThrowProjectChildElements(element))
{
ProjectPropertyElement property = ParseProjectPropertyElement(childElement, propertyGroup);
propertyGroup.AppendParentedChildNoChecks(property);
}
return(propertyGroup);
}
/// <summary>
/// Verify the parent is a usingTaskElement and that the taskFactory attribute is set
/// </summary>
private static void VerifyCorrectParent(ProjectElementContainer parent)
{
ProjectUsingTaskElement parentUsingTask = parent as ProjectUsingTaskElement;
ErrorUtilities.VerifyThrowInvalidOperation(parentUsingTask != null, "OM_CannotAcceptParent");
// Now since there is not goign to be a TaskElement on the using task we need to validate and make sure there is a TaskFactory attribute on the parent element and
// that it is not empty
if (parentUsingTask.TaskFactory.Length == 0)
{
ProjectXmlUtilities.VerifyThrowProjectRequiredAttribute(parent.XmlElement, "TaskFactory");
}
// UNDONE: Do check to make sure the parameter group is the first child
}
/// <summary>
/// Helper method to extract attribute values and update the ParsedSdkReference property if
/// necessary (update only when changed).
/// </summary>
/// <returns>True if the ParsedSdkReference was updated, otherwise false (no update necessary).</returns>
private bool CheckUpdatedSdk()
{
SdkReference sdk = new SdkReference(
ProjectXmlUtilities.GetAttributeValue(XmlElement, XMakeAttributes.sdk, true),
ProjectXmlUtilities.GetAttributeValue(XmlElement, XMakeAttributes.sdkVersion, true),
ProjectXmlUtilities.GetAttributeValue(XmlElement, XMakeAttributes.sdkMinimumVersion, true));
if (sdk.Equals(ParsedSdkReference))
{
return(false);
}
ParsedSdkReference = sdk;
return(true);
}
/// <summary>
/// Parse a ProjectItemDefinitionGroupElement
/// </summary>
private ProjectItemDefinitionGroupElement ParseProjectItemDefinitionGroupElement(XmlElementWithLocation element)
{
ProjectXmlUtilities.VerifyThrowProjectAttributes(element, s_validAttributesOnlyConditionAndLabel);
ProjectItemDefinitionGroupElement itemDefinitionGroup = new ProjectItemDefinitionGroupElement(element, _project, _project);
foreach (XmlElementWithLocation childElement in ProjectXmlUtilities.GetVerifyThrowProjectChildElements(element))
{
ProjectItemDefinitionElement itemDefinition = ParseProjectItemDefinitionXml(childElement, itemDefinitionGroup);
itemDefinitionGroup.AppendParentedChildNoChecks(itemDefinition);
}
return(itemDefinitionGroup);
}
/// <summary>
/// Parse a ProjectImportElement that is contained in an ImportGroup
/// </summary>
private ProjectImportElement ParseProjectImportElement(XmlElementWithLocation element, ProjectElementContainer parent)
{
ProjectErrorUtilities.VerifyThrowInvalidProject
(
parent is ProjectRootElement || parent is ProjectImportGroupElement,
element.Location,
"UnrecognizedParentElement",
parent,
element
);
ProjectXmlUtilities.VerifyThrowProjectAttributes(element, s_validAttributesOnImport);
ProjectXmlUtilities.VerifyThrowProjectRequiredAttribute(element, XMakeAttributes.project);
ProjectXmlUtilities.VerifyThrowProjectNoChildElements(element);
return(new ProjectImportElement(element, parent, _project));
}
/// <summary>
/// Parse a ProjectChooseElement
/// </summary>
private ProjectChooseElement ParseProjectChooseElement(XmlElementWithLocation element, ProjectElementContainer parent, int nestingDepth)
{
ProjectXmlUtilities.VerifyThrowProjectNoAttributes(element);
ProjectChooseElement choose = new ProjectChooseElement(element, parent, _project);
nestingDepth++;
ProjectErrorUtilities.VerifyThrowInvalidProject(nestingDepth <= MaximumChooseNesting, element.Location, "ChooseOverflow", MaximumChooseNesting);
bool foundWhen = false;
bool foundOtherwise = false;
foreach (XmlElementWithLocation childElement in ProjectXmlUtilities.GetVerifyThrowProjectChildElements(element))
{
ProjectElement child = null;
switch (childElement.Name)
{
case XMakeElements.when:
ProjectErrorUtilities.VerifyThrowInvalidProject(!foundOtherwise, childElement.Location, "WhenNotAllowedAfterOtherwise");
child = ParseProjectWhenElement(childElement, choose, nestingDepth);
foundWhen = true;
break;
case XMakeElements.otherwise:
ProjectErrorUtilities.VerifyThrowInvalidProject(!foundOtherwise, childElement.Location, "MultipleOtherwise");
foundOtherwise = true;
child = ParseProjectOtherwiseElement(childElement, choose, nestingDepth);
break;
default:
ProjectXmlUtilities.ThrowProjectInvalidChildElement(childElement.Name, element.Name, element.Location);
break;
}
choose.AppendParentedChildNoChecks(child);
}
nestingDepth--;
ProjectErrorUtilities.VerifyThrowInvalidProject(foundWhen, element.Location, "ChooseMustContainWhen");
return(choose);
}
/// <summary>
/// Pasre a ProjectItemDefinitionElement
/// </summary>
private ProjectItemDefinitionElement ParseProjectItemDefinitionXml(XmlElementWithLocation element, ProjectItemDefinitionGroupElement parent)
{
ProjectXmlUtilities.VerifyThrowProjectAttributes(element, s_validAttributesOnlyConditionAndLabel);
// Orcas inadvertently did not check for reserved item types (like "Choose") in item definitions,
// as we do for item types in item groups. So we do not have a check here.
// Although we could perhaps add one, as such item definitions couldn't be used
// since no items can have the reserved itemType.
ProjectItemDefinitionElement itemDefinition = new ProjectItemDefinitionElement(element, parent, _project);
foreach (XmlElementWithLocation childElement in ProjectXmlUtilities.GetVerifyThrowProjectChildElements(element))
{
ProjectMetadataElement metadatum = ParseProjectMetadataElement(childElement, itemDefinition);
itemDefinition.AppendParentedChildNoChecks(metadatum);
}
return(itemDefinition);
}
/// <summary>
/// Parse a ProjectPropertyGroupElement from the element
/// </summary>
private ProjectPropertyGroupElement ParseProjectPropertyGroupElement(XmlElementWithLocation element, ProjectElementContainer parent)
{
ProjectXmlUtilities.VerifyThrowProjectAttributes(element, ValidAttributesOnlyConditionAndLabel);
ProjectPropertyGroupElement propertyGroup = new ProjectPropertyGroupElement(element, parent, _project);
foreach (XmlElementWithLocation childElement in ProjectXmlUtilities.GetVerifyThrowProjectChildElements(element))
{
ProjectXmlUtilities.VerifyThrowProjectAttributes(childElement, ValidAttributesOnlyConditionAndLabel);
XmlUtilities.VerifyThrowProjectValidElementName(childElement);
ProjectErrorUtilities.VerifyThrowInvalidProject(!XMakeElements.ReservedItemNames.Contains(childElement.Name) && !ReservedPropertyNames.IsReservedProperty(childElement.Name), childElement.Location, "CannotModifyReservedProperty", childElement.Name);
// All children inside a property are ignored, since they are only part of its value
ProjectPropertyElement property = new ProjectPropertyElement(childElement, propertyGroup, _project);
propertyGroup.AppendParentedChildNoChecks(property);
}
return(propertyGroup);
}
/// <summary>
/// Parse a ProjectMetadataElement
/// </summary>
private ProjectMetadataElement ParseProjectMetadataElement(XmlElementWithLocation element, ProjectElementContainer parent)
{
ProjectXmlUtilities.VerifyThrowProjectAttributes(element, s_validAttributesOnlyConditionAndLabel);
XmlUtilities.VerifyThrowProjectValidElementName(element);
ProjectErrorUtilities.VerifyThrowInvalidProject(!(parent is ProjectItemElement) || ((ProjectItemElement)parent).Remove.Length == 0, element.Location, "ChildElementsBelowRemoveNotAllowed", element.Name);
ProjectErrorUtilities.VerifyThrowInvalidProject(!FileUtilities.ItemSpecModifiers.IsItemSpecModifier(element.Name), element.Location, "ItemSpecModifierCannotBeCustomMetadata", element.Name);
ProjectErrorUtilities.VerifyThrowInvalidProject(XMakeElements.IllegalItemPropertyNames[element.Name] == null, element.Location, "CannotModifyReservedItemMetadata", element.Name);
ProjectMetadataElement metadatum = new ProjectMetadataElement(element, parent, _project);
// If the parent is an item definition, we don't allow expressions like @(foo) in the value, as no items exist at that point
if (parent is ProjectItemDefinitionElement)
{
bool containsItemVector = Expander.ExpressionContainsItemVector(metadatum.Value);
ProjectErrorUtilities.VerifyThrowInvalidProject(!containsItemVector, element.Location, "MetadataDefinitionCannotContainItemVectorExpression", metadatum.Value, metadatum.Name);
}
return(metadatum);
}
/// <summary>
/// Pasre a ProjectItemDefinitionElement
/// </summary>
private ProjectItemDefinitionElement ParseProjectItemDefinitionXml(XmlElementWithLocation element, ProjectItemDefinitionGroupElement parent)
{
// Orcas inadvertently did not check for reserved item types (like "Choose") in item definitions,
// as we do for item types in item groups. So we do not have a check here.
// Although we could perhaps add one, as such item definitions couldn't be used
// since no items can have the reserved itemType.
ProjectItemDefinitionElement itemDefinition = new ProjectItemDefinitionElement(element, parent, _project);
foreach (XmlAttributeWithLocation attribute in element.Attributes)
{
CheckMetadataAsAttributeName(attribute.Name, out bool isKnownAttribute, out bool isValidMetadataNameInAttribute);
if (!isKnownAttribute && !isValidMetadataNameInAttribute)
{
ProjectXmlUtilities.ThrowProjectInvalidAttribute(attribute);
}
else if (isValidMetadataNameInAttribute)
{
ProjectMetadataElement metadatum = _project.CreateMetadataElement(attribute.Name, attribute.Value);
metadatum.ExpressedAsAttribute = true;
metadatum.Parent = itemDefinition;
itemDefinition.AppendParentedChildNoChecks(metadatum);
}
else if (!ValidAttributesOnlyConditionAndLabel.Contains(attribute.Name))
{
ProjectXmlUtilities.ThrowProjectInvalidAttribute(attribute);
}
}
foreach (XmlElementWithLocation childElement in ProjectXmlUtilities.GetVerifyThrowProjectChildElements(element))
{
ProjectMetadataElement metadatum = ParseProjectMetadataElement(childElement, itemDefinition);
itemDefinition.AppendParentedChildNoChecks(metadatum);
}
return(itemDefinition);
}
/// <summary>
/// Parse a ProjectItemElement
/// </summary>
private ProjectItemElement ParseProjectItemElement(XmlElementWithLocation element, ProjectItemGroupElement parent)
{
ProjectXmlUtilities.VerifyThrowProjectAttributes(element, s_validAttributesOnItem);
bool belowTarget = parent.Parent is ProjectTargetElement;
string itemType = element.Name;
string include = element.GetAttribute(XMakeAttributes.include);
string exclude = element.GetAttribute(XMakeAttributes.exclude);
string remove = element.GetAttribute(XMakeAttributes.remove);
// Remove must be missing, unless inside a target and Include is missing
ProjectXmlUtilities.VerifyThrowProjectInvalidAttribute((remove.Length == 0 || (belowTarget && include.Length == 0)), (XmlAttributeWithLocation)element.Attributes[XMakeAttributes.remove]);
// Include must be present, unless inside a target
ProjectErrorUtilities.VerifyThrowInvalidProject(include.Length > 0 || belowTarget, element.Location, "MissingRequiredAttribute", XMakeAttributes.include, itemType);
// Exclude must be missing, unless Include exists
ProjectXmlUtilities.VerifyThrowProjectInvalidAttribute(exclude.Length == 0 || include.Length > 0, (XmlAttributeWithLocation)element.Attributes[XMakeAttributes.exclude]);
// If we have an Include attribute at all, it must have non-zero length
ProjectErrorUtilities.VerifyThrowInvalidProject(include.Length > 0 || element.Attributes[XMakeAttributes.include] == null, element.Location, "MissingRequiredAttribute", XMakeAttributes.include, itemType);
XmlUtilities.VerifyThrowProjectValidElementName(element);
ProjectErrorUtilities.VerifyThrowInvalidProject(XMakeElements.IllegalItemPropertyNames[itemType] == null, element.Location, "CannotModifyReservedItem", itemType);
ProjectItemElement item = new ProjectItemElement(element, parent, _project);
foreach (XmlElementWithLocation childElement in ProjectXmlUtilities.GetVerifyThrowProjectChildElements(element))
{
ProjectMetadataElement metadatum = ParseProjectMetadataElement(childElement, item);
item.AppendParentedChildNoChecks(metadatum);
}
return(item);
}
/// <summary>
/// Parse a ProjectOutputElement
/// </summary>
private ProjectOutputElement ParseProjectOutputElement(XmlElementWithLocation element, ProjectTaskElement parent)
{
ProjectXmlUtilities.VerifyThrowProjectAttributes(element, ValidAttributesOnOutput);
ProjectXmlUtilities.VerifyThrowProjectRequiredAttribute(element, XMakeAttributes.taskParameter);
ProjectXmlUtilities.VerifyThrowProjectNoChildElements(element);
XmlAttributeWithLocation itemNameAttribute = element.GetAttributeWithLocation(XMakeAttributes.itemName);
XmlAttributeWithLocation propertyNameAttribute = element.GetAttributeWithLocation(XMakeAttributes.propertyName);
ProjectErrorUtilities.VerifyThrowInvalidProject
(
(String.IsNullOrWhiteSpace(itemNameAttribute?.Value) && !String.IsNullOrWhiteSpace(propertyNameAttribute?.Value)) || (!String.IsNullOrWhiteSpace(itemNameAttribute?.Value) && String.IsNullOrWhiteSpace(propertyNameAttribute?.Value)),
element.Location,
"InvalidTaskOutputSpecification",
parent.Name
);
ProjectXmlUtilities.VerifyThrowProjectAttributeEitherMissingOrNotEmpty(element, itemNameAttribute, XMakeAttributes.itemName);
ProjectXmlUtilities.VerifyThrowProjectAttributeEitherMissingOrNotEmpty(element, propertyNameAttribute, XMakeAttributes.propertyName);
ProjectErrorUtilities.VerifyThrowInvalidProject(String.IsNullOrWhiteSpace(propertyNameAttribute?.Value) || !ReservedPropertyNames.IsReservedProperty(propertyNameAttribute.Value), element.Location, "CannotModifyReservedProperty", propertyNameAttribute?.Value);
return(new ProjectOutputElement(element, parent, _project));
}
/// <summary>
/// Parse a ProjectImportGroupElement
/// </summary>
/// <param name="element">The XML element to parse</param>
/// <param name="parent">The parent <see cref="ProjectRootElement"/>.</param>
/// <returns>A ProjectImportGroupElement derived from the XML element passed in</returns>
private ProjectImportGroupElement ParseProjectImportGroupElement(XmlElementWithLocation element, ProjectRootElement parent)
{
ProjectXmlUtilities.VerifyThrowProjectAttributes(element, s_validAttributesOnlyConditionAndLabel);
ProjectImportGroupElement importGroup = new ProjectImportGroupElement(element, parent, _project);
foreach (XmlElementWithLocation childElement in ProjectXmlUtilities.GetVerifyThrowProjectChildElements(element))
{
ProjectErrorUtilities.VerifyThrowInvalidProject
(
childElement.Name == XMakeElements.import,
childElement.Location,
"UnrecognizedChildElement",
childElement.Name,
element.Name
);
ProjectImportElement item = ParseProjectImportElement(childElement, importGroup);
importGroup.AppendParentedChildNoChecks(item);
}
return(importGroup);
}
/// <summary>
/// Parse a ProjectItemElement
/// </summary>
private ProjectItemElement ParseProjectItemElement(XmlElementWithLocation element, ProjectItemGroupElement parent)
{
bool belowTarget = parent.Parent is ProjectTargetElement;
string itemType = element.Name;
string include = element.GetAttribute(XMakeAttributes.include);
string exclude = element.GetAttribute(XMakeAttributes.exclude);
string remove = element.GetAttribute(XMakeAttributes.remove);
string update = element.GetAttribute(XMakeAttributes.update);
var exclusiveItemOperation = "";
int exclusiveAttributeCount = 0;
if (element.HasAttribute(XMakeAttributes.include))
{
exclusiveAttributeCount++;
exclusiveItemOperation = XMakeAttributes.include;
}
if (element.HasAttribute(XMakeAttributes.remove))
{
exclusiveAttributeCount++;
exclusiveItemOperation = XMakeAttributes.remove;
}
if (element.HasAttribute(XMakeAttributes.update))
{
exclusiveAttributeCount++;
exclusiveItemOperation = XMakeAttributes.update;
}
// At most one of the include, remove, or update attributes may be specified
if (exclusiveAttributeCount > 1)
{
XmlAttributeWithLocation errorAttribute = remove.Length > 0 ? (XmlAttributeWithLocation)element.Attributes[XMakeAttributes.remove] : (XmlAttributeWithLocation)element.Attributes[XMakeAttributes.update];
ProjectErrorUtilities.ThrowInvalidProject(errorAttribute.Location, "InvalidAttributeExclusive");
}
// Include, remove, or update must be present unless inside a target
ProjectErrorUtilities.VerifyThrowInvalidProject(exclusiveAttributeCount == 1 || belowTarget, element.Location, "IncludeRemoveOrUpdate", exclusiveItemOperation, itemType);
// Exclude must be missing, unless Include exists
ProjectXmlUtilities.VerifyThrowProjectInvalidAttribute(exclude.Length == 0 || include.Length > 0, (XmlAttributeWithLocation)element.Attributes[XMakeAttributes.exclude]);
// If we have an Include attribute at all, it must have non-zero length
ProjectErrorUtilities.VerifyThrowInvalidProject(include.Length > 0 || element.Attributes[XMakeAttributes.include] == null, element.Location, "MissingRequiredAttribute", XMakeAttributes.include, itemType);
// If we have a Remove attribute at all, it must have non-zero length
ProjectErrorUtilities.VerifyThrowInvalidProject(remove.Length > 0 || element.Attributes[XMakeAttributes.remove] == null, element.Location, "MissingRequiredAttribute", XMakeAttributes.remove, itemType);
// If we have an Update attribute at all, it must have non-zero length
ProjectErrorUtilities.VerifyThrowInvalidProject(update.Length > 0 || element.Attributes[XMakeAttributes.update] == null, element.Location, "MissingRequiredAttribute", XMakeAttributes.update, itemType);
XmlUtilities.VerifyThrowProjectValidElementName(element);
ProjectErrorUtilities.VerifyThrowInvalidProject(XMakeElements.IllegalItemPropertyNames[itemType] == null, element.Location, "CannotModifyReservedItem", itemType);
ProjectItemElement item = new ProjectItemElement(element, parent, _project);
foreach (XmlAttributeWithLocation attribute in element.Attributes)
{
bool isKnownAttribute;
bool isValidMetadataNameInAttribute;
CheckMetadataAsAttributeName(attribute.Name, out isKnownAttribute, out isValidMetadataNameInAttribute);
if (!isKnownAttribute && !isValidMetadataNameInAttribute)
{
ProjectXmlUtilities.ThrowProjectInvalidAttribute(attribute);
}
else if (isValidMetadataNameInAttribute)
{
ProjectMetadataElement metadatum = _project.CreateMetadataElement(attribute.Name, attribute.Value);
metadatum.ExpressedAsAttribute = true;
metadatum.Parent = item;
item.AppendParentedChildNoChecks(metadatum);
}
}
foreach (XmlElementWithLocation childElement in ProjectXmlUtilities.GetVerifyThrowProjectChildElements(element))
{
ProjectMetadataElement metadatum = ParseProjectMetadataElement(childElement, item);
item.AppendParentedChildNoChecks(metadatum);
}
return(item);
}
/// <summary>
/// Parse a ProjectTargetElement
/// </summary>
private ProjectTargetElement ParseProjectTargetElement(XmlElementWithLocation element)
{
ProjectXmlUtilities.VerifyThrowProjectAttributes(element, s_validAttributesOnTarget);
ProjectXmlUtilities.VerifyThrowProjectRequiredAttribute(element, XMakeAttributes.name);
string targetName = ProjectXmlUtilities.GetAttributeValue(element, XMakeAttributes.name);
// Orcas compat: all target names are automatically unescaped
targetName = EscapingUtilities.UnescapeAll(targetName);
int indexOfSpecialCharacter = targetName.IndexOfAny(XMakeElements.illegalTargetNameCharacters);
if (indexOfSpecialCharacter >= 0)
{
ProjectErrorUtilities.ThrowInvalidProject(element.GetAttributeLocation(XMakeAttributes.name), "NameInvalid", targetName, targetName[indexOfSpecialCharacter]);
}
ProjectTargetElement target = new ProjectTargetElement(element, _project, _project);
ProjectOnErrorElement onError = null;
foreach (XmlElementWithLocation childElement in ProjectXmlUtilities.GetVerifyThrowProjectChildElements(element))
{
ProjectElement child = null;
switch (childElement.Name)
{
case XMakeElements.propertyGroup:
if (onError != null)
{
ProjectErrorUtilities.ThrowInvalidProject(onError.Location, "NodeMustBeLastUnderElement", XMakeElements.onError, XMakeElements.target, childElement.Name);
}
child = ParseProjectPropertyGroupElement(childElement, target);
break;
case XMakeElements.itemGroup:
if (onError != null)
{
ProjectErrorUtilities.ThrowInvalidProject(onError.Location, "NodeMustBeLastUnderElement", XMakeElements.onError, XMakeElements.target, childElement.Name);
}
child = ParseProjectItemGroupElement(childElement, target);
break;
case XMakeElements.onError:
onError = ParseProjectOnErrorElement(childElement, target);
child = onError;
break;
case XMakeElements.itemDefinitionGroup:
ProjectErrorUtilities.ThrowInvalidProject(childElement.Location, "ItemDefinitionGroupNotLegalInsideTarget", childElement.Name);
break;
default:
if (onError != null)
{
ProjectErrorUtilities.ThrowInvalidProject(onError.Location, "NodeMustBeLastUnderElement", XMakeElements.onError, XMakeElements.target, childElement.Name);
}
child = ParseProjectTaskElement(childElement, target);
break;
}
target.AppendParentedChildNoChecks(child);
}
return(target);
}
/// <summary>
/// Parse a ProjectUsingTaskElement
/// </summary>
private ProjectUsingTaskElement ParseProjectUsingTaskElement(XmlElementWithLocation element)
{
ProjectXmlUtilities.VerifyThrowProjectAttributes(element, s_validAttributesOnUsingTask);
ProjectErrorUtilities.VerifyThrowInvalidProject(element.GetAttribute(XMakeAttributes.taskName).Length > 0, element.Location, "ProjectTaskNameEmpty");
string assemblyName = element.GetAttribute(XMakeAttributes.assemblyName);
string assemblyFile = element.GetAttribute(XMakeAttributes.assemblyFile);
ProjectErrorUtilities.VerifyThrowInvalidProject
(
((assemblyName.Length > 0) ^ (assemblyFile.Length > 0)),
element.Location,
"UsingTaskAssemblySpecification",
XMakeElements.usingTask,
XMakeAttributes.assemblyName,
XMakeAttributes.assemblyFile
);
ProjectXmlUtilities.VerifyThrowProjectAttributeEitherMissingOrNotEmpty(element, XMakeAttributes.assemblyName);
ProjectXmlUtilities.VerifyThrowProjectAttributeEitherMissingOrNotEmpty(element, XMakeAttributes.assemblyFile);
ProjectUsingTaskElement usingTask = new ProjectUsingTaskElement(element, _project, _project);
bool foundTaskElement = false;
bool foundParameterGroup = false;
foreach (XmlElementWithLocation childElement in ProjectXmlUtilities.GetVerifyThrowProjectChildElements(element))
{
ProjectElement child = null;
string childElementName = childElement.Name;
switch (childElementName)
{
case XMakeElements.usingTaskParameterGroup:
if (foundParameterGroup)
{
ProjectXmlUtilities.ThrowProjectInvalidChildElementDueToDuplicate(childElement);
}
child = ParseUsingTaskParameterGroupElement(childElement, usingTask);
foundParameterGroup = true;
break;
case XMakeElements.usingTaskBody:
if (foundTaskElement)
{
ProjectXmlUtilities.ThrowProjectInvalidChildElementDueToDuplicate(childElement);
}
child = ParseUsingTaskBodyElement(childElement, usingTask);
foundTaskElement = true;
break;
default:
ProjectXmlUtilities.ThrowProjectInvalidChildElement(childElement.Name, element.Name, element.Location);
break;
}
usingTask.AppendParentedChildNoChecks(child);
}
return(usingTask);
}
/// <summary>
/// Parse a UsingTaskParameterElement from the element
/// </summary>
private ProjectUsingTaskParameterElement ParseUsingTaskParameterElement(XmlElementWithLocation element, UsingTaskParameterGroupElement parent)
{
ProjectXmlUtilities.VerifyThrowProjectAttributes(element, s_validAttributesOnUsingTaskParameter);
XmlUtilities.VerifyThrowProjectValidElementName(element);
return(new ProjectUsingTaskParameterElement(element, parent, _project));
}
