internal string ConstructParentPath(string parentPath, XmlElementContext context, string argumentString)
{
Debug.Assert(this.parentPath == null && this.context == null && this.argumentString == null,
"Do not call ConstructPath recursively");
string resultPath = String.Empty;
if (this.parentPath == null && this.context == null && this.argumentString == null)
{
try {
this.parentPath = parentPath;
this.context = context;
this.argumentString = argumentString;
resultPath = ParentPath;
}
finally {
this.parentPath = null;
this.context = null;
this.argumentString = null;
this.arguments = null;
ReleaseLogger();
}
}
return(resultPath);
}
private void HandleElement(XmlElementContext context)
{
string str;
Transform transform = context.ConstructTransform(out str);
if (transform != null)
{
bool supressWarnings = this.logger.SupressWarnings;
XmlAttribute namedItem = context.Element.Attributes.GetNamedItem(SupressWarnings, TransformNamespace) as XmlAttribute;
if (namedItem != null)
{
bool flag2 = Convert.ToBoolean(namedItem.Value, CultureInfo.InvariantCulture);
this.logger.SupressWarnings = flag2;
}
try
{
this.OnApplyingTransform();
transform.Execute(context, str);
this.OnAppliedTransform();
}
catch (Exception exception)
{
this.HandleException(exception, context);
}
finally
{
this.logger.SupressWarnings = supressWarnings;
}
}
this.TransformLoop(context);
}
private void HandleMissingTarget(XmlElementContext matchFailureContext, bool existedInOriginal)
{
string format = existedInOriginal ? SR.XMLTRANSFORMATION_TransformSourceMatchWasRemoved : SR.XMLTRANSFORMATION_TransformNoMatchingTargetNodes;
object[] args = new object[] { matchFailureContext.XPath };
string message = string.Format(CultureInfo.CurrentCulture, format, args);
switch (this.MissingTargetMessage)
{
case Microsoft.Web.XmlTransform.MissingTargetMessage.None:
this.Log.LogMessage(MessageType.Verbose, message, new object[0]);
return;
case Microsoft.Web.XmlTransform.MissingTargetMessage.Information:
this.Log.LogMessage(MessageType.Normal, message, new object[0]);
return;
case Microsoft.Web.XmlTransform.MissingTargetMessage.Warning:
this.Log.LogWarning(matchFailureContext.Node, message, new object[0]);
return;
case Microsoft.Web.XmlTransform.MissingTargetMessage.Error:
throw new XmlNodeException(message, matchFailureContext.Node);
}
}
private void HandleMissingTarget(XmlElementContext matchFailureContext, bool existedInOriginal)
{
string messageFormat = existedInOriginal
? SR.XMLTRANSFORMATION_TransformSourceMatchWasRemoved
: SR.XMLTRANSFORMATION_TransformNoMatchingTargetNodes;
string message = string.Format(System.Globalization.CultureInfo.CurrentCulture, messageFormat, matchFailureContext.XPath);
switch (MissingTargetMessage)
{
case MissingTargetMessage.None:
Log.LogMessage(MessageType.Verbose, message);
break;
case MissingTargetMessage.Information:
Log.LogMessage(MessageType.Normal, message);
break;
case MissingTargetMessage.Warning:
Log.LogWarning(matchFailureContext.Node, message);
break;
case MissingTargetMessage.Error:
throw new XmlNodeException(message, matchFailureContext.Node);
}
}
public XmlElementContext(XmlElementContext parent, XmlElement element, XmlDocument xmlTargetDoc, IServiceProvider serviceProvider)
: base(element)
{
this.parentContext = parent;
this.xmlTargetDoc = xmlTargetDoc;
this.serviceProvider = serviceProvider;
}
private void PreprocessTransformDocument()
{
hasTransformNamespace = false;
foreach (XmlAttribute attribute in xmlTransformation.SelectNodes("//namespace::*"))
{
if (attribute.Value.Equals(TransformNamespace, StringComparison.Ordinal))
{
hasTransformNamespace = true;
break;
}
}
if (hasTransformNamespace)
{
// This will look for all nodes from our namespace in the document,
// and do any initialization work
XmlNamespaceManager namespaceManager = new XmlNamespaceManager(new NameTable());
namespaceManager.AddNamespace("xdt", TransformNamespace);
XmlNodeList namespaceNodes = xmlTransformation.SelectNodes("//xdt:*", namespaceManager);
foreach (XmlNode node in namespaceNodes)
{
XmlElement element = node as XmlElement;
if (element == null)
{
Debug.Fail("The XPath for elements returned something that wasn't an element?");
continue;
}
XmlElementContext context = null;
try {
switch (element.LocalName)
{
case "Import":
context = CreateElementContext(null, element);
PreprocessImportElement(context);
break;
default:
logger.LogWarning(element, SR.XMLTRANSFORMATION_UnknownXdtTag, element.Name);
break;
}
}
catch (Exception ex) {
if (context != null)
{
ex = WrapException(ex, context);
}
logger.LogErrorFromException(ex);
throw new XmlTransformationException(SR.XMLTRANSFORMATION_FatalTransformSyntaxError, ex);
}
finally {
context = null;
}
}
}
}
private void PreprocessImportElement(XmlElementContext context)
{
string assemblyName = null;
string nameSpace = null;
string path = null;
foreach (XmlAttribute attribute in context.Element.Attributes)
{
if (attribute.NamespaceURI.Length == 0)
{
switch (attribute.Name)
{
case "assembly":
assemblyName = attribute.Value;
continue;
case "namespace":
nameSpace = attribute.Value;
continue;
case "path":
path = attribute.Value;
continue;
}
}
throw new XmlNodeException(string.Format(System.Globalization.CultureInfo.CurrentCulture, SR.XMLTRANSFORMATION_ImportUnknownAttribute, attribute.Name), attribute);
}
if (assemblyName != null && path != null)
{
throw new XmlNodeException(string.Format(System.Globalization.CultureInfo.CurrentCulture, SR.XMLTRANSFORMATION_ImportAttributeConflict), context.Element);
}
else if (assemblyName == null && path == null)
{
throw new XmlNodeException(string.Format(System.Globalization.CultureInfo.CurrentCulture, SR.XMLTRANSFORMATION_ImportMissingAssembly), context.Element);
}
else if (nameSpace == null)
{
throw new XmlNodeException(string.Format(System.Globalization.CultureInfo.CurrentCulture, SR.XMLTRANSFORMATION_ImportMissingNamespace), context.Element);
}
else
{
if (assemblyName != null)
{
namedTypeFactory.AddAssemblyRegistration(assemblyName, nameSpace);
}
else
{
namedTypeFactory.AddPathRegistration(path, nameSpace);
}
}
}
private void PreprocessTransformDocument()
{
this.hasTransformNamespace = false;
foreach (XmlAttribute attribute in this.xmlTransformation.SelectNodes("//namespace::*"))
{
if (attribute.Value.Equals(TransformNamespace, StringComparison.Ordinal))
{
this.hasTransformNamespace = true;
break;
}
}
if (this.hasTransformNamespace)
{
XmlNamespaceManager nsmgr = new XmlNamespaceManager(new NameTable());
nsmgr.AddNamespace("xdt", TransformNamespace);
foreach (XmlNode node in this.xmlTransformation.SelectNodes("//xdt:*", nsmgr))
{
XmlElement element = node as XmlElement;
if (element != null)
{
XmlElementContext context = null;
try
{
string str;
if (((str = element.LocalName) != null) && (str == "Import"))
{
context = this.CreateElementContext(null, element);
this.PreprocessImportElement(context);
}
else
{
object[] messageArgs = new object[] { element.Name };
this.logger.LogWarning(element, SR.XMLTRANSFORMATION_UnknownXdtTag, messageArgs);
}
}
catch (Exception exception)
{
if (context != null)
{
exception = this.WrapException(exception, context);
}
this.logger.LogErrorFromException(exception);
throw new XmlTransformationException(SR.XMLTRANSFORMATION_FatalTransformSyntaxError, exception);
}
finally
{
context = null;
}
}
}
}
}
private void PreprocessImportElement(XmlElementContext context)
{
string assemblyName = null;
string nameSpace = null;
string path = null;
foreach (XmlAttribute attribute in context.Element.Attributes)
{
string str4;
if ((attribute.NamespaceURI.Length == 0) && ((str4 = attribute.Name) != null))
{
if (str4 == "assembly")
{
assemblyName = attribute.Value;
continue;
}
if (str4 == "namespace")
{
nameSpace = attribute.Value;
continue;
}
if (str4 == "path")
{
path = attribute.Value;
continue;
}
}
object[] args = new object[] { attribute.Name };
throw new XmlNodeException(string.Format(CultureInfo.CurrentCulture, SR.XMLTRANSFORMATION_ImportUnknownAttribute, args), attribute);
}
if ((assemblyName != null) && (path != null))
{
throw new XmlNodeException(string.Format(CultureInfo.CurrentCulture, SR.XMLTRANSFORMATION_ImportAttributeConflict, new object[0]), context.Element);
}
if ((assemblyName == null) && (path == null))
{
throw new XmlNodeException(string.Format(CultureInfo.CurrentCulture, SR.XMLTRANSFORMATION_ImportMissingAssembly, new object[0]), context.Element);
}
if (nameSpace == null)
{
throw new XmlNodeException(string.Format(CultureInfo.CurrentCulture, SR.XMLTRANSFORMATION_ImportMissingNamespace, new object[0]), context.Element);
}
if (assemblyName != null)
{
this.namedTypeFactory.AddAssemblyRegistration(assemblyName, nameSpace);
}
else
{
this.namedTypeFactory.AddPathRegistration(path, nameSpace);
}
}
internal bool HasTargetParent(out XmlElementContext failedContext, out bool existedInOriginal)
{
failedContext = null;
existedInOriginal = false;
if (this.TargetParents.Count != 0)
{
return(true);
}
failedContext = this;
while ((failedContext.parentContext != null) && (!string.IsNullOrEmpty(failedContext.parentContext.ParentXPath) && (failedContext.parentContext.TargetParents.Count == 0)))
{
failedContext = failedContext.parentContext;
}
existedInOriginal = this.ExistedInOriginal(failedContext.XPath);
return(false);
}
private void TransformLoop(XmlNodeContext parentContext)
{
foreach (XmlNode node in parentContext.Node.ChildNodes)
{
XmlElement element = node as XmlElement;
if (element == null)
{
continue;
}
XmlElementContext context = CreateElementContext(parentContext as XmlElementContext, element);
try {
HandleElement(context);
}
catch (Exception ex) {
HandleException(ex, context);
}
}
}
private void TransformLoop(XmlNodeContext parentContext)
{
foreach (XmlNode node in parentContext.Node.ChildNodes)
{
XmlElement element = node as XmlElement;
if (element != null)
{
XmlElementContext context = this.CreateElementContext(parentContext as XmlElementContext, element);
try
{
this.HandleElement(context);
}
catch (Exception exception)
{
this.HandleException(exception, context);
}
}
}
}
internal bool HasTargetNode(out XmlElementContext failedContext, out bool existedInOriginal)
{
failedContext = null;
existedInOriginal = false;
if (TargetNodes.Count == 0)
{
failedContext = this;
while (failedContext.parentContext != null &&
failedContext.parentContext.TargetNodes.Count == 0)
{
failedContext = failedContext.parentContext;
}
existedInOriginal = ExistedInOriginal(failedContext.XPath);
return(false);
}
return(true);
}
private void HandleElement(XmlElementContext context)
{
string argumentString;
Transform transform = context.ConstructTransform(out argumentString);
if (transform != null)
{
bool fOriginalSupressWarning = logger.SupressWarnings;
XmlAttribute SupressWarningsAttribute = context.Element.Attributes.GetNamedItem(XmlTransformation.SupressWarnings, XmlTransformation.TransformNamespace) as XmlAttribute;
if (SupressWarningsAttribute != null)
{
bool fSupressWarning = System.Convert.ToBoolean(SupressWarningsAttribute.Value, System.Globalization.CultureInfo.InvariantCulture);
logger.SupressWarnings = fSupressWarning;
}
try
{
OnApplyingTransform();
transform.Execute(context, argumentString);
OnAppliedTransform();
}
catch (Exception ex)
{
HandleException(ex, context);
}
finally
{
// reset back the SupressWarnings back per node
logger.SupressWarnings = fOriginalSupressWarning;
}
}
// process children
TransformLoop(context);
}
internal string ConstructPath(string parentPath, XmlElementContext context, string argumentString)
{
string str = string.Empty;
if ((this.parentPath == null) && ((this.context == null) && (this.argumentString == null)))
{
try
{
this.parentPath = parentPath;
this.context = context;
this.argumentString = argumentString;
str = this.ConstructPath();
}
finally
{
this.parentPath = null;
this.context = null;
this.argumentString = null;
this.arguments = null;
this.ReleaseLogger();
}
}
return(str);
}
private XmlElementContext CreateElementContext(XmlElementContext parentContext, XmlElement element) => new XmlElementContext(parentContext, element, this.xmlTarget, this);
internal void Execute(XmlElementContext context, string argumentString)
{
if ((this.context == null) && (this.argumentString == null))
{
bool flag = false;
bool flag2 = false;
try
{
this.context = context;
this.argumentString = argumentString;
this.arguments = null;
if (this.ShouldExecuteTransform())
{
flag2 = true;
object[] messageArgs = new object[] { this.TransformNameLong };
this.Log.StartSection(MessageType.Verbose, SR.XMLTRANSFORMATION_TransformBeginExecutingMessage, messageArgs);
object[] objArray2 = new object[] { context.XPath };
this.Log.LogMessage(MessageType.Verbose, SR.XMLTRANSFORMATION_TransformStatusXPath, objArray2);
if (this.ApplyTransformToAllTargetNodes)
{
this.ApplyOnAllTargetNodes();
}
else
{
this.ApplyOnce();
}
}
}
catch (Exception exception)
{
flag = true;
if (context.TransformAttribute != null)
{
this.Log.LogErrorFromException(XmlNodeException.Wrap(exception, context.TransformAttribute));
}
else
{
this.Log.LogErrorFromException(exception);
}
}
finally
{
if (!flag2)
{
object[] messageArgs = new object[] { this.TransformNameLong };
this.Log.LogMessage(MessageType.Normal, SR.XMLTRANSFORMATION_TransformNotExecutingMessage, messageArgs);
}
else if (flag)
{
object[] messageArgs = new object[] { this.TransformNameShort };
this.Log.EndSection(MessageType.Verbose, SR.XMLTRANSFORMATION_TransformErrorExecutingMessage, messageArgs);
}
else
{
object[] messageArgs = new object[] { this.TransformNameShort };
this.Log.EndSection(MessageType.Verbose, SR.XMLTRANSFORMATION_TransformEndExecutingMessage, messageArgs);
}
this.context = null;
this.argumentString = null;
this.arguments = null;
this.ReleaseLogger();
}
}
}
internal void Execute(XmlElementContext context, string argumentString)
{
Debug.Assert(this.context == null && this.argumentString == null, "Don't call Execute recursively");
Debug.Assert(this.logger == null, "Logger wasn't released from previous execution");
if (this.context == null && this.argumentString == null)
{
bool error = false;
bool startedSection = false;
try {
this.context = context;
this.argumentString = argumentString;
this.arguments = null;
if (ShouldExecuteTransform())
{
startedSection = true;
Log.StartSection(MessageType.Verbose, SR.XMLTRANSFORMATION_TransformBeginExecutingMessage, TransformNameLong);
Log.LogMessage(MessageType.Verbose, SR.XMLTRANSFORMATION_TransformStatusXPath, context.XPath);
if (ApplyTransformToAllTargetNodes)
{
ApplyOnAllTargetNodes();
}
else
{
ApplyOnce();
}
}
}
catch (Exception ex) {
error = true;
if (context.TransformAttribute != null)
{
Log.LogErrorFromException(XmlNodeException.Wrap(ex, context.TransformAttribute));
}
else
{
Log.LogErrorFromException(ex);
}
}
finally {
if (startedSection)
{
if (error)
{
Log.EndSection(MessageType.Verbose, SR.XMLTRANSFORMATION_TransformErrorExecutingMessage, TransformNameShort);
}
else
{
Log.EndSection(MessageType.Verbose, SR.XMLTRANSFORMATION_TransformEndExecutingMessage, TransformNameShort);
}
}
else
{
Log.LogMessage(MessageType.Normal, SR.XMLTRANSFORMATION_TransformNotExecutingMessage, TransformNameLong);
}
this.context = null;
this.argumentString = null;
this.arguments = null;
ReleaseLogger();
}
}
}
private XmlElementContext CreateElementContext(XmlElementContext parentContext, XmlElement element)
{
return(new XmlElementContext(parentContext, element, xmlTarget, this));
}
