static XmlType Parse(string match, ref string remaining, IXmlNamespaceResolver resolver, IXmlLineInfo lineinfo)
{
remaining = null;
int parensCount = 0;
int pos = 0;
bool isGeneric = false;
for (pos = 0; pos < match.Length; pos++)
{
if (match[pos] == '(')
{
parensCount++;
isGeneric = true;
}
else if (match[pos] == ')')
{
parensCount--;
}
else if (match[pos] == ',' && parensCount == 0)
{
remaining = match.Substring(pos + 1);
break;
}
}
var type = match.Substring(0, pos).Trim();
IList <XmlType> typeArguments = null;
if (isGeneric)
{
typeArguments = ParseExpression(
type.Substring(type.IndexOf('(') + 1, type.LastIndexOf(')') - type.IndexOf('(') - 1), resolver, lineinfo);
type = type.Substring(0, type.IndexOf('('));
}
var split = type.Split(':');
if (split.Length > 2)
{
return(null);
}
string prefix, name;
if (split.Length == 2)
{
prefix = split [0];
name = split [1];
}
else
{
prefix = "";
name = split [0];
}
var namespaceuri = resolver.LookupNamespace(prefix);
if (namespaceuri == null)
{
throw new XamlParseException($"No xmlns declaration for prefix '{prefix}'.", lineinfo, null);
}
return(new XmlType(namespaceuri, name, typeArguments));
}
internal XmlAtomicValue(XmlSchemaType xmlType, string value, IXmlNamespaceResolver nsResolver)
{
if (value == null) throw new ArgumentNullException(nameof(value));
if (xmlType == null) throw new ArgumentNullException(nameof(xmlType));
_xmlType = xmlType;
_objVal = value;
if (nsResolver != null && (_xmlType.TypeCode == XmlTypeCode.QName || _xmlType.TypeCode == XmlTypeCode.Notation))
{
string prefix = GetPrefixFromQName(value);
_nsPrefix = new NamespacePrefixForQName(prefix, nsResolver.LookupNamespace(prefix));
}
}
public IIdentity Get(string name, string identifier) => _store.Get(name, _manager.LookupNamespace(identifier));
public string?LookupNamespace(string prefix) => _other.LookupNamespace(prefix);
internal static XmlQualifiedName Parse (string name, IXmlNamespaceResolver resolver, bool considerDefaultNamespace)
{
int index = name.IndexOf (':');
if (index < 0 && !considerDefaultNamespace)
return new XmlQualifiedName (name);
string prefix = index < 0 ? String.Empty : name.Substring (0, index);
string localName = index < 0 ? name : name.Substring (index + 1);
string ns = resolver.LookupNamespace (prefix);
if (ns == null) {
if (prefix.Length > 0)
throw new ArgumentException ("Invalid qualified name.");
else
ns = String.Empty;
}
return new XmlQualifiedName (localName, ns);
}
private static XmlQualifiedName StringToQName(string value, IXmlNamespaceResolver nsResolver)
{
string prefix, localName, ns;
value = value.Trim();
// Parse prefix:localName
try
{
ValidateNames.ParseQNameThrow(value, out prefix, out localName);
}
catch (XmlException e)
{
throw new FormatException(e.Message);
}
// Throw error if no namespaces are in scope
if (nsResolver == null)
throw new InvalidCastException(SR.Format(SR.XmlConvert_TypeNoNamespace, value, prefix));
// Lookup namespace
ns = nsResolver.LookupNamespace(prefix);
if (ns == null)
throw new InvalidCastException(SR.Format(SR.XmlConvert_TypeNoNamespace, value, prefix));
// Create XmlQualfiedName
return new XmlQualifiedName(localName, ns);
}
public static void Clean(XElement proj, IXmlNamespaceResolver ns, string relativeSigningKeyPath = null)
{
var frameworkVersion = "v4.5.2";
var frameworkProfile = "";
var configurations = new[] { "Debug", "Test", "Release" };
var platforms = new[] { "AnyCPU", "x86", "x64", "ARM" };
if (proj.Name.LocalName == "VisualStudioProject")
return;
#region Remove Cruft
proj.XPathSelectElements("//build:AutorunEnabled", ns).Remove();
proj.XPathSelectElements("//build:PublishWizardCompleted", ns).Remove();
proj.XPathSelectElements("//build:TargetZone", ns).Remove();
proj.XPathSelectElements("//build:ApplicationManifest", ns).Remove();
proj.XPathSelectElements("//build:DefaultClientScript", ns).Remove();
proj.XPathSelectElements("//build:DefaultHTMLPageLayout", ns).Remove();
proj.XPathSelectElements("//build:DefaultTargetSchema", ns).Remove();
proj.XPathSelectElements("//build:FileUpgradeFlags", ns).Remove();
proj.XPathSelectElements("//build:OldToolsVersion", ns).Remove();
proj.XPathSelectElements("//build:UpgradeBackupLocation", ns).Remove();
proj.XPathSelectElements("//build:IsWebBootstrapper", ns).Remove();
proj.XPathSelectElements("//build:PublishUrl", ns).Remove();
proj.XPathSelectElements("//build:Install", ns).Remove();
proj.XPathSelectElements("//build:InstallFrom", ns).Remove();
proj.XPathSelectElements("//build:UpdateEnabled", ns).Remove();
proj.XPathSelectElements("//build:UpdateMode", ns).Remove();
proj.XPathSelectElements("//build:UpdateInterval", ns).Remove();
proj.XPathSelectElements("//build:UpdateIntervalUnits", ns).Remove();
proj.XPathSelectElements("//build:UpdatePeriodically", ns).Remove();
proj.XPathSelectElements("//build:UpdateRequired", ns).Remove();
proj.XPathSelectElements("//build:MapFileExtensions", ns).Remove();
proj.XPathSelectElements("//build:ApplicationRevision", ns).Remove();
proj.XPathSelectElements("//build:ApplicationVersion", ns).Remove();
proj.XPathSelectElements("//build:UseApplicationTrust", ns).Remove();
proj.XPathSelectElements("//build:BootstrapperEnabled", ns).Remove();
proj.XPathSelectElements("//build:BootstrapperPackage", ns).Remove();
proj.XPathSelectElements("//build:SccProjectName", ns).Remove();
proj.XPathSelectElements("//build:SccLocalPath", ns).Remove();
proj.XPathSelectElements("//build:SccAuxPath", ns).Remove();
proj.XPathSelectElements("//build:SccProvider", ns).Remove();
proj.XPathSelectElements("//build:NuGetPackageImportStamp", ns).Remove();
proj.XPathSelectElements("//build:NoWin32Manifest", ns).Remove();
proj.XPathSelectElements("//build:EnableSecurityDebugging", ns).Remove();
proj.XPathSelectElements("//build:StartAction", ns).Remove();
proj.XPathSelectElements("//build:HostInBrowser", ns).Remove();
proj.XPathSelectElements("//build:CreateWebPageOnPublish", ns).Remove();
proj.XPathSelectElements("//build:WebPage", ns).Remove();
proj.XPathSelectElements("//build:OpenBrowserOnPublish", ns).Remove();
proj.XPathSelectElements("//build:TrustUrlParameters", ns).Remove();
proj.XPathSelectElements("//build:UseIISExpress", ns).Remove();
proj.XPathSelectElements("//build:IISExpressSSLPort", ns).Remove();
proj.XPathSelectElements("//build:IISExpressAnonymousAuthentication", ns).Remove();
proj.XPathSelectElements("//build:IISExpressWindowsAuthentication", ns).Remove();
proj.XPathSelectElements("//build:IISExpressUseClassicPipelineMode", ns).Remove();
#endregion
proj.DescendantNodes().OfType<XComment>().Where(c => c.Value.Contains("<Target Name=\"BeforeBuild\">")).Remove();
#region Remove Folders
proj.XPathSelectElements(@"//build:Folder", ns).Remove();
#endregion
#region Clean up main PropertyGroup
proj.SetAttributeValue("ToolsVersion", "14.0");
var mainPG = proj.XPathSelectElement("//build:PropertyGroup[build:ProjectGuid]", ns);
proj.XPathSelectElements("//build:ProjectType", ns).Remove();
proj.XPathSelectElements("//build:ProductVersion", ns).Remove();
proj.XPathSelectElements("//build:SchemaVersion", ns).Remove();
proj.XPathSelectElements("//build:StartupObject", ns).Where(e => String.IsNullOrWhiteSpace(e.Value)).Remove();
proj.XPathSelectElements("//build:ApplicationIcon", ns).Where(e => String.IsNullOrWhiteSpace(e.Value)).Remove();
proj.XPathSelectElements("//build:PropertyGroup[build:ProjectGuid]/build:FileAlignment", ns).Remove();
proj.XPathSelectElements("//build:PropertyGroup[build:ProjectGuid]/build:WarningLevel", ns).Remove();
proj.XPathSelectElements("//build:ApplicationIcon", ns).Reparent(mainPG);
proj.XPathSelectElements("//build:ResolveAssemblyWarnOrErrorOnTargetArchitectureMismatch", ns).Reparent(mainPG);
if (frameworkVersion != null)
{
proj.XPathSelectElements("//build:TargetFrameworkVersion", ns).SetValue(frameworkVersion);
if (!string.IsNullOrEmpty(frameworkProfile))
proj.XPathSelectElements("//build:TargetFrameworkProfile", ns).SetValue(frameworkProfile);
else
proj.XPathSelectElements("//build:TargetFrameworkProfile", ns).Nodes().Remove();
}
proj.XPathSelectElements("//build:ProjectTypeGuids", ns).SetValue(e => e.ToLower());
var mainOrder = new[] { "Configuration", "Platform", "ProjectGuid", "ProjectTypeGuids", "OutputType", "AppDesignerFolder", "RootNamespace", "AssemblyName", "TargetFrameworkVersion", "TargetFrameworkProfile", "AutoGenerateBindingRedirects", "ApplicationIcon", };
mainPG.Elements().OrderBy(x => IndexOf(mainOrder, x.Name.LocalName) ?? Int32.MaxValue).Reparent(mainPG);
#endregion
#region Sort Configuration items
var pcOrder = platforms.SelectMany(p => configurations.Select(c => String.Format("'{0}|{1}'", c, p))).ToArray();
var cpgOrder = new[] { "PlatformTarget", "DebugSymbols", "DebugType", "Optimize", "OutputPath", "DefineConstants", "ErrorReport", "WarningLevel", "AllowUnsafeBlocks", "BaseAddress", "CheckForOverflowUnderflow", "ConfigurationOverrideFile", "DocumentationFile", "FileAlignment", "NoStdLib", "NoWarn", "RegisterForComInterop", "RemoveIntegerChecks", "TreatWarningsAsErrors", "UseVSHostingProcess", "CodeAnalysisIgnoreBuiltInRuleSets", "CodeAnalysisIgnoreBuiltInRules", "RunCodeAnalysis", };
proj.XPathSelectElements("//*[contains(@Condition, '$(Configuration)|$(Platform)')]", ns).Where(e => !pcOrder.Any(o => e.Attribute("Condition").Value.Contains(o))).Remove();
foreach (var grouping in proj.XPathSelectElements("//*[contains(@Condition, '$(Configuration)|$(Platform)')]", ns).GroupBy(e => new { p = e.Parent, en = e.Name.LocalName }))
{
var previous = grouping.First().PreviousNode;
var children = grouping.OrderBy(e => IndexOf(pcOrder, o => e.Attribute("Condition").Value.Contains(o)) ?? Int32.MaxValue).ThenBy(e => e.Attribute("Condition").Value.Trim()).ToArray();
children.Remove();
previous.AddAfterSelf(children);
foreach (var cgp in children.Where(e => e.Name.LocalName == "PropertyGroup"))
{
cgp.Elements().OrderBy(e => IndexOf(cpgOrder, e.Name.LocalName) ?? Int32.MaxValue).Reparent(cgp);
}
continue;
}
proj.XPathSelectElements("//build:DefineConstants", ns).SetValue(e => String.Join(";", e.Value.Split(';').OrderBy(v => v.TrimStart('_')).ThenBy(v => v)));
#endregion
#region Clean up Items
proj.XPathSelectElements("//build:SubType", ns).Where(s => String.IsNullOrWhiteSpace(s.Value)).Remove();
proj.XPathSelectElements("//*[@Include='app.config']/build:SubType", ns).Remove();
proj.XPathSelectElements("//build:Compile/build:SubType[text()='Code']", ns).Remove();
var noDesigner = new[] { ".config", ".xml", ".xsd", ".xslt", ".ejs" };
proj.XPathSelectElements("//build:*[@Include]/build:SubType[text()='Designer']", ns).Where(s => noDesigner.Contains(Path.GetExtension(s.Parent.Attribute("Include").Value), StringComparer.InvariantCultureIgnoreCase)).Remove();
foreach (var item in proj.XPathSelectElements("//build:*[@Include]", ns).Where(e => e.Attribute("Include").Value.EndsWith(".xaml", StringComparison.InvariantCultureIgnoreCase) && e.Name.LocalName != "Reference"))
{
item.XPathSelectElements(".//build:Generator", ns).Remove();
item.XPathSelectElements(".//build:SubType", ns).Remove();
item.AddElement("Generator", content: "MSBuild:Compile", first: true);
item.AddElement("SubType", content: "Designer", first: true);
}
var itemTypes = new[] { "Compile", "Content", "Resource", "EmbeddedResource", "None", "ApplicationDefinition", "Page", "SplashScreen" };
var items = proj.XPathSelectElements("//build:*[@Include]", ns).Where(e => itemTypes.Contains(e.Name.LocalName)).OrderBy(e => e.Attribute("Include").Value).ToArray();
foreach (var item in items.Where(e => !e.IsEmpty && !e.HasElements))
{
item.RemoveNodes();
}
#endregion
#region Clean up References
proj.XPathSelectElements("//build:Reference[@Include='System.configuration']", ns).Attributes("Include").SetValue("System.Configuration");
proj.XPathSelectElements("//build:Reference[@Include='System.XML']", ns).Attributes("Include").SetValue("System.Xml");
proj.XPathSelectElements("//build:AssemblyFolderKey", ns).Remove();
proj.XPathSelectElements("//build:SpecificVersion", ns).Remove();
proj.XPathSelectElements("//build:ReferencePath", ns).Remove();
proj.XPathSelectElements("//build:CurrentPlatform", ns).Remove();
proj.XPathSelectElements("//build:Reference/build:Name", ns).Remove();
proj.XPathSelectElements("//build:Reference/build:RequiredTargetFramework", ns).Remove();
var referenceParent = proj.XPathSelectElements("//build:ItemGroup[build:Reference]", ns).FirstOrDefault();
if (referenceParent != null)
{
proj.XPathSelectElements("//build:Reference", ns).OrderBy(c => c.Attribute("Include").Value.SubstringTill(',').Replace("System", "aaaaaaa")).Reparent(referenceParent);
}
#endregion
#region Clean up ProjectReferences
proj.XPathSelectElements("//build:ProjectReference/build:Package", ns).Remove();
proj.XPathSelectElements("//build:ProjectReference[@Include]/build:Name", ns).SetValue(n => Path.GetFileNameWithoutExtension(n.Parent.Attribute("Include").Value));
foreach (var name in proj.XPathSelectElements("//build:ProjectReference[@Include]/build:Name", ns))
{
var parent = name.Parent;
name.Remove();
parent.AddFirst(name);
}
var projectReferenceParent = proj.XPathSelectElements("//build:ItemGroup[build:ProjectReference]", ns).FirstOrDefault();
if (projectReferenceParent != null)
{
proj.XPathSelectElements("//build:ProjectReference", ns).OrderBy(c => c.Element(XName.Get("Name", ns.LookupNamespace("build"))).Value).Reparent(projectReferenceParent);
}
var imports = proj.XPathSelectElements("//build:Import[starts-with(@Project, '..')]", ns).ToArray();
foreach (var import in imports)
{
var path = import.Attribute("Project").Value;
import.SetAttributeValue("Condition", String.Format("Exists('{0}')", path));
continue;
}
#endregion
#region Clean up Web Projects
proj.XPathSelectElements("//build:SaveServerSettingsInUserFile", ns).SetValue(true);
proj.XPathSelectElements("//build:WebProjectProperties/build:UseIIS", ns).Remove();
proj.XPathSelectElements("//build:WebProjectProperties/build:AutoAssignPort", ns).Remove();
proj.XPathSelectElements("//build:WebProjectProperties/build:DevelopmentServerPort", ns).Remove();
proj.XPathSelectElements("//build:WebProjectProperties/build:DevelopmentServerVPath", ns).Remove();
proj.XPathSelectElements("//build:WebProjectProperties/build:IISUrl", ns).Remove();
proj.XPathSelectElements("//build:WebProjectProperties/build:NTLMAuthentication", ns).Remove();
proj.XPathSelectElements("//build:WebProjectProperties/build:UseCustomServer", ns).Remove();
proj.XPathSelectElements("//build:WebProjectProperties/build:CustomServerUrl", ns).Remove();
#endregion
#region Clean up PreBuildEvent/PostBuildEvent
proj.XPathSelectElements("//build:PostBuildEvent", ns).Where(e => e.Value.IndexOf("sn.exe", StringComparison.CurrentCultureIgnoreCase) >= 0).SetValue("");
proj.XPathSelectElements("//build:PreBuildEvent", ns).Where(e => String.IsNullOrWhiteSpace(e.Value)).Remove();
proj.XPathSelectElements("//build:PostBuildEvent", ns).Where(e => String.IsNullOrWhiteSpace(e.Value)).Remove();
if (!proj.XPathSelectElements("//build:PreBuildEvent", ns).Any(e => String.IsNullOrWhiteSpace(e.Value)))
proj.XPathSelectElements("//build:RunPreBuildEvent", ns).Remove();
if (!proj.XPathSelectElements("//build:PostBuildEvent", ns).Any(e => String.IsNullOrWhiteSpace(e.Value)))
proj.XPathSelectElements("//build:RunPostBuildEvent", ns).Remove();
#endregion
#region Configure signing
var canSign = !String.IsNullOrEmpty(relativeSigningKeyPath);
proj.XPathSelectElements("//build:SignAssembly", ns).Remove();
proj.XPathSelectElements("//build:DelaySign", ns).Remove();
proj.XPathSelectElements("//build:AssemblyOriginatorKeyFile", ns).Remove();
proj.XPathSelectElements("//build:AssemblyKeyContainerName", ns).Remove();
if (mainPG != null)
{
mainPG.AddElement("SignAssembly", content: canSign);
if (canSign)
{
mainPG.AddElement("DelaySign", content: false);
mainPG.AddElement("AssemblyOriginatorKeyFile", content: relativeSigningKeyPath);
}
}
#endregion
proj.XPathSelectElements("//build:PropertyGroup", ns).Where(e => !e.Nodes().Any()).Remove();
proj.XPathSelectElements("//build:ItemGroup", ns).Where(e => !e.Nodes().Any()).Remove();
}
string IXmlNamespaceResolver.LookupNamespace(string prefix)
{
return(readerAsNSResolver.LookupNamespace(prefix));
}
string?IXmlNamespaceResolver.LookupNamespace(string prefix)
{
return(_readerAsIXmlNamespaceResolver.LookupNamespace(prefix));
}
//
// Constructor & finalizer
//
internal XmlWellFormedWriter(XmlWriter writer, XmlWriterSettings settings) {
Debug.Assert(writer != null);
Debug.Assert(settings != null);
Debug.Assert(MaxNamespacesWalkCount <= 3);
this.writer = writer;
rawWriter = writer as XmlRawWriter;
predefinedNamespaces = writer as IXmlNamespaceResolver;
if (rawWriter != null) {
rawWriter.NamespaceResolver = new NamespaceResolverProxy(this);
}
checkCharacters = settings.CheckCharacters;
conformanceLevel = settings.ConformanceLevel;
stateTable = (conformanceLevel == ConformanceLevel.Document) ? StateTableDocument : StateTableAuto;
currentState = State.Start;
nsStack = new Namespace[NamespaceStackInitialSize];
nsStack[0].Set("xmlns", XmlReservedNs.NsXmlNs, NamespaceKind.Special);
nsStack[1].Set("xml", XmlReservedNs.NsXml, NamespaceKind.Special);
if (predefinedNamespaces == null) {
nsStack[2].Set(string.Empty, string.Empty, NamespaceKind.Implied);
}
else {
string defaultNs = predefinedNamespaces.LookupNamespace(string.Empty);
nsStack[2].Set(string.Empty, (defaultNs == null ? string.Empty : defaultNs), NamespaceKind.Implied);
}
nsTop = 2;
elemScopeStack = new ElementScope[ElementStackInitialSize];
elemScopeStack[0].Set(string.Empty, string.Empty, string.Empty, nsTop);
elemScopeStack[0].xmlSpace = XmlSpace.None;
elemScopeStack[0].xmlLang = null;
elemTop = 0;
attrStack = new AttrName[AttributeArrayInitialSize];
attrValue = new StringBuilder();
hasher = new SecureStringHasher();
}
protected void WriteXPath(XmlWriter writer, IXmlNamespaceResolver resolver)
{
// Lex the xpath to find all prefixes used
int startChar = 0;
int tmp = 0;
string newXPath = "";
XPathLexer lexer = new XPathLexer(xpath, false);
Dictionary <string, string> prefixMap = new Dictionary <string, string>();
List <string> prefixes = new List <string>();
while (lexer.MoveNext())
{
string nsPrefix = lexer.Token.Prefix;
string nsNS = resolver.LookupNamespace(nsPrefix);
// Check if we need to write the namespace
if (nsPrefix.Length > 0 && (nsNS == null || (nsNS != null && nsNS != this.namespaces.LookupNamespace(nsPrefix))))
{
// Write the previous xpath segment
if (this.xpath[tmp] == '$')
{
newXPath += this.xpath.Substring(startChar, tmp - startChar + 1);
startChar = tmp + 1;
}
else
{
newXPath += this.xpath.Substring(startChar, tmp - startChar);
startChar = tmp;
}
// Check if we need a new prefix
if (!prefixMap.ContainsKey(nsPrefix))
{
prefixes.Add(nsPrefix);
if (nsNS != null)
{
string newPrefix = nsPrefix;
int i = 0;
while (resolver.LookupNamespace(newPrefix) != null || this.namespaces.LookupNamespace(newPrefix) != null)
{
newPrefix = newPrefix + i.ToString(NumberFormatInfo.InvariantInfo);
++i;
}
prefixMap.Add(nsPrefix, newPrefix);
}
else
{
prefixMap.Add(nsPrefix, nsPrefix);
}
}
// Write the new prefix
newXPath += prefixMap[nsPrefix];
// Update the xpath marker
startChar += nsPrefix.Length;
}
tmp = lexer.FirstTokenChar;
}
newXPath += this.xpath.Substring(startChar); // Consume the remainder of the xpath
// Write the namespaces
for (int i = 0; i < prefixes.Count; ++i)
{
string prefix = prefixes[i];
writer.WriteAttributeString("xmlns", prefixMap[prefix], null, this.namespaces.LookupNamespace(prefix));
}
// Write the XPath
writer.WriteString(newXPath);
}
protected static XmlQualifiedName StringToQName(string value, IXmlNamespaceResolver nsResolver)
{
string str;
string str2;
value = value.Trim();
try
{
ValidateNames.ParseQNameThrow(value, out str, out str2);
}
catch (XmlException exception)
{
throw new FormatException(exception.Message);
}
if (nsResolver == null)
{
throw new InvalidCastException(Res.GetString("XmlConvert_TypeNoNamespace", new object[] { value, str }));
}
string ns = nsResolver.LookupNamespace(str);
if (ns == null)
{
throw new InvalidCastException(Res.GetString("XmlConvert_TypeNoNamespace", new object[] { value, str }));
}
return new XmlQualifiedName(str2, ns);
}
private IEnumerable<XObject> SelectInternal(string path, IXmlNamespaceResolver manager)
{
if (path.StartsWith("/"))
{
path = path.Substring(1);
}
var nodes = (IEnumerable<XObject>) new[] {_obj};
foreach (var part in path.Split('/'))
{
if (part == "*")
{
nodes = nodes.Cast<XContainer>().Elements();
}
else if (part == "")
{
nodes = nodes.Cast<XContainer>().Descendants();
}
else
{
var isAttribute = part.StartsWith("@");
var str = isAttribute ? part.Substring(1) : part;
var pos = str.IndexOf(":", StringComparison.Ordinal);
var name = pos >= 0
? XName.Get(str.Substring(pos + 1), manager.LookupNamespace(str.Substring(0, pos)))
: XName.Get(str);
if (isAttribute)
{
nodes = nodes.Cast<XElement>().Attributes(name);
}
else
{
nodes = nodes.Cast<XContainer>().Elements(name);
}
}
}
return nodes;
}
public string GetNamespace(string prefix)
{
return(source.LookupNamespace(prefix));
}
// Parse a QName from the string, and resolve prefix
XmlQualifiedName ParseQName(string xpath, ref int pos, IXmlNamespaceResolver xnr) {
string nm = ParseName(xpath, ref pos);
if (pos < xpath.Length && ':' == xpath[pos]) {
pos++;
string ns = (null==xnr) ? null : xnr.LookupNamespace(nm);
if (null == ns || 0 == ns.Length)
throw new XmlException(Res.Sch_UnresolvedPrefix, nm);
return new XmlQualifiedName(ParseName(xpath, ref pos), ns);
}
else {
return new XmlQualifiedName(nm);
}
}
private static XElement GenerateNewElement(string name, IXmlNamespaceResolver resolver)
{
XName newElementName = null;
if (name.Contains(XPathExtensions.namespaceSeparator))
{
if (resolver == null) throw new ArgumentNullException("resolver", "Es wurde keine NamespaceResolver angegeben.");
var splittedName = name.Split(new [] { XPathExtensions.namespaceSeparator }, StringSplitOptions.None);
var namespacePraefix = splittedName.Length > 1 ? splittedName[0] : string.Empty;
var elementName = splittedName.Length > 1 ? splittedName[1] : splittedName[0];
XNamespace nameSpace = resolver.LookupNamespace(namespacePraefix);
if (string.IsNullOrEmpty(nameSpace.NamespaceName))
{
throw new InvalidOperationException(string.Format("Es wurde kein Nampespace mit dem Präfix \"{0}\" gefunden.", namespacePraefix));
}
newElementName = nameSpace + elementName;
}
else
{
if(resolver != null)
{
throw new XPathException("Das Element konnte nicht erstellt werden. Es fehlt ein entsprechender Namespace im Pfad.");
}
newElementName = name;
}
// Neues Element wird erstellt
return new XElement(newElementName);
}
internal XmlAtomicValue(XmlSchemaType xmlType, string value, IXmlNamespaceResolver nsResolver)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
if (xmlType == null)
{
throw new ArgumentNullException("xmlType");
}
this.xmlType = xmlType;
this.objVal = value;
if ((nsResolver != null) && ((this.xmlType.TypeCode == XmlTypeCode.QName) || (this.xmlType.TypeCode == XmlTypeCode.Notation)))
{
string prefixFromQName = this.GetPrefixFromQName(value);
this.nsPrefix = new NamespacePrefixForQName(prefixFromQName, nsResolver.LookupNamespace(prefixFromQName));
}
}
// Methods
public static XmlQualifiedName ParseQName (string name, IXmlNamespaceResolver resolver)
{
int index = name.IndexOf (':');
if (index < 0)
return new XmlQualifiedName (name);
string ns = resolver.LookupNamespace (name.Substring (0, index));
if (ns == null)
throw new ArgumentException ("Invalid qualified name.");
return new XmlQualifiedName (name.Substring (index + 1), ns);
}
public override bool Matches(XmlReader reader, IXmlNamespaceResolver resolver)
{
bool nsMatches = IsAnyNamespace;
bool nameMatches = IsAnyName;
if (!nsMatches)
{
string ns = String.Empty;
if (prefix.Length > 0)
{
if (resolver == null)
{
throw new ArgumentException(Properties.Resources.NamespaceResolverRequired, "resolver");
}
ns = resolver.LookupNamespace(prefix);
if (ns == null)
{
throw new ArgumentException(String.Format(
CultureInfo.CurrentCulture,
Properties.Resources.CannotResolvePrefix,
prefix));
}
}
nsMatches = (ns == reader.NamespaceURI);
}
if (!nameMatches)
{
nameMatches = (name == reader.LocalName);
}
return nsMatches && nameMatches;
}
//
// Constructor & finalizer
//
internal XmlWellFormedWriter(XmlWriter writer, XmlWriterSettings settings)
{
Debug.Assert(writer != null);
Debug.Assert(settings != null);
Debug.Assert(MaxNamespacesWalkCount <= 3);
_writer = writer;
_rawWriter = writer as XmlRawWriter;
_predefinedNamespaces = writer as IXmlNamespaceResolver;
if (_rawWriter != null)
{
_rawWriter.NamespaceResolver = new NamespaceResolverProxy(this);
}
_checkCharacters = settings.CheckCharacters;
_omitDuplNamespaces = (settings.NamespaceHandling & NamespaceHandling.OmitDuplicates) != 0;
_writeEndDocumentOnClose = settings.WriteEndDocumentOnClose;
_conformanceLevel = settings.ConformanceLevel;
_stateTable = (_conformanceLevel == ConformanceLevel.Document) ? s_stateTableDocument : s_stateTableAuto;
_currentState = State.Start;
_nsStack = new Namespace[NamespaceStackInitialSize];
_nsStack[0].Set("xmlns", XmlReservedNs.NsXmlNs, NamespaceKind.Special);
_nsStack[1].Set("xml", XmlReservedNs.NsXml, NamespaceKind.Special);
if (_predefinedNamespaces == null)
{
_nsStack[2].Set(string.Empty, string.Empty, NamespaceKind.Implied);
}
else
{
string defaultNs = _predefinedNamespaces.LookupNamespace(string.Empty);
_nsStack[2].Set(string.Empty, (defaultNs == null ? string.Empty : defaultNs), NamespaceKind.Implied);
}
_nsTop = 2;
_elemScopeStack = new ElementScope[ElementStackInitialSize];
_elemScopeStack[0].Set(string.Empty, string.Empty, string.Empty, _nsTop);
_elemScopeStack[0].xmlSpace = XmlSpace.None;
_elemScopeStack[0].xmlLang = null;
_elemTop = 0;
_attrStack = new AttrName[AttributeArrayInitialSize];
_hasher = new SecureStringHasher();
}
internal static XmlQualifiedName Parse(string s, IXmlNamespaceResolver nsmgr, out string prefix)
{
string str;
ValidateNames.ParseQNameThrow(s, out prefix, out str);
string ns = nsmgr.LookupNamespace(prefix);
if (ns == null)
{
if (prefix.Length != 0)
{
throw new XmlException("Xml_UnknownNs", prefix);
}
ns = string.Empty;
}
return new XmlQualifiedName(str, ns);
}
internal static XmlQualifiedName Parse(string s, IXmlNamespaceResolver nsmgr, out string prefix)
{
string localName;
ValidateNames.ParseQNameThrow(s, out prefix, out localName);
string uri = nsmgr.LookupNamespace(prefix);
if (uri == null)
{
if (prefix.Length != 0)
{
throw new XmlException(SR.Xml_UnknownNs, prefix);
}
else
{ //Re-map namespace of empty prefix to string.Empty when there is no default namespace declared
uri = string.Empty;
}
}
return new XmlQualifiedName(localName, uri);
}
/// <summary>
/// Parse an xsi:type name
/// </summary>
private Type ParseXSITypeName(string xsiTypeName, IXmlNamespaceResolver namespaceResolver)
{
// Is there an XSITypeName map that already exists for this type?
Type retVal = null;
if (this.s_typeNameMaps.TryGetValue(xsiTypeName, out retVal))
return retVal;
// NS Prefix?
String[] nsTokens = xsiTypeName.Split(':');
string namespaceUri = "urn:hl7-org:v3";
if (nsTokens.Length == 2)
{
xsiTypeName = nsTokens[1];
namespaceUri = namespaceResolver.LookupNamespace(nsTokens[0]);
}
// Step one, tokenize the parts based on . separator
String[] tokens = null;
if(xsiTypeName.Contains("."))
tokens = new String[] {
xsiTypeName.Substring(0, xsiTypeName.LastIndexOf(".") ),
xsiTypeName.Substring(xsiTypeName.LastIndexOf(".") + 1)
};
else
tokens = new string[] {
null,
xsiTypeName
};
// Is the first part an interaction?
if (tokens.Length == 3)
{
// TODO: Predicate will find the mapped type for us
// TODO: This happens for generics
throw new NotImplementedException();
}
else if (tokens.Length == 2)
{
// Find the type that has the specified name and model
String modelName = tokens[0], structureName = tokens[1];
Predicate<Type> typeComparator = delegate(Type t)
{
object[] structureAttribute = t.GetCustomAttributes(typeof(StructureAttribute), true);
if (structureAttribute.Length > 0 && ((StructureAttribute)structureAttribute[0]).Name == structureName &&
(((StructureAttribute)structureAttribute[0]).Model) == modelName &&
(((StructureAttribute)structureAttribute[0]).NamespaceUri == namespaceUri))
return true;
return false;
};
// Search for a type that matches
#if WINDOWS_PHONE
Assembly candidateAssembly = AppDomain.CurrentDomain.GetAssemblies().Find(a => { try { return a.GetTypes().Exists(typeComparator); } catch { return false; } });
retVal = candidateAssembly.GetTypes().Find(typeComparator);
#else
Assembly candidateAssembly = Array.Find(AppDomain.CurrentDomain.GetAssemblies(), a => { try { return Array.Exists(a.GetTypes(), typeComparator); } catch { return false; } });
retVal = Array.Find(candidateAssembly.GetTypes(), typeComparator);
#endif
lock (this.m_syncRoot)
if (!this.s_typeNameMaps.ContainsKey(xsiTypeName))
this.RegisterXSITypeName(xsiTypeName, retVal);
}
else
throw new ArgumentException("xsi:type cannot be auto-parsed. Please register it using RegisterXSITypeName");
return retVal;
}
