public void Load([StringSyntax(StringSyntaxAttribute.Uri)] string url, XmlResolver?resolver)
{
XmlTextReaderImpl tr = new XmlTextReaderImpl(url);
{
tr.XmlResolver = resolver;
}
Compile(Compiler.LoadDocument(tr).CreateNavigator(), resolver);
}
public void Load(string url, XmlResolver resolver)
{
XmlTextReaderImpl tr = new XmlTextReaderImpl(url);
{
tr.XmlResolver = resolver;
}
Compile(Compiler.LoadDocument(tr).CreateNavigator(), resolver);
}
public void Load(string url, XmlResolver resolver)
{
XmlTextReaderImpl tr = new XmlTextReaderImpl(url); {
tr.XmlResolver = resolver;
}
Evidence evidence = XmlSecureResolver.CreateEvidenceForUrl(tr.BaseURI); // We should ask BaseURI before we start reading because it's changing with each node
Compile(Compiler.LoadDocument(tr).CreateNavigator(), resolver, evidence);
}
public void Load(string url, System.Xml.XmlResolver resolver)
{
XmlTextReaderImpl reader = new XmlTextReaderImpl(url)
{
XmlResolver = resolver
};
Evidence evidence = XmlSecureResolver.CreateEvidenceForUrl(reader.BaseURI);
this.Compile(Compiler.LoadDocument(reader).CreateNavigator(), resolver, evidence);
}
private static XmlTextReaderImpl GetXmlTextReaderImpl(XmlReader reader)
{
XmlTextReaderImpl tri = reader as XmlTextReaderImpl;
if (tri != null)
{
return(tri);
}
return(null);
}
public void Load(string url, XmlResolver resolver) {
XmlTextReaderImpl tr = new XmlTextReaderImpl(url); {
tr.XmlResolver = resolver;
}
Evidence evidence = XmlSecureResolver.CreateEvidenceForUrl(tr.BaseURI); // We should ask BaseURI before we start reading because it's changing with each node
if (resolver == null) {
resolver = new XmlNullResolver();
}
Compile(Compiler.LoadDocument(tr).CreateNavigator(), resolver, evidence);
}
/// <summary>
/// Create a new document and load the content from the Uri, with whitespace handling controlled according to "space".
/// </summary>
public XPathDocument(string uri, XmlSpace space)
{
XmlTextReaderImpl reader = SetupReader(new XmlTextReaderImpl(uri));
try {
LoadFromReader(reader, space);
}
finally {
reader.Close();
}
}
/// <summary>
/// Create a new document and load the content from the text reader.
/// </summary>
public XPathDocument(TextReader textReader)
{
XmlTextReaderImpl reader = SetupReader(new XmlTextReaderImpl(string.Empty, textReader));
try {
LoadFromReader(reader, XmlSpace.Default);
}
finally {
reader.Close();
}
}
//
// Input documents management
//
internal static XPathDocument LoadDocument(XmlTextReaderImpl reader)
{
reader.EntityHandling = EntityHandling.ExpandEntities;
reader.XmlValidatingReaderCompatibilityMode = true;
try {
return(new XPathDocument(reader, XmlSpace.Preserve));
}
finally {
reader.Close();
}
}
internal void TrimSpacesInValue()
{
if (ValueBuffered)
{
XmlTextReaderImpl.StripSpaces(_chars, _valueStartPos, ref _valueLength);
}
else
{
_value = XmlTextReaderImpl.StripSpaces(_value);
}
}
/// <summary>
/// Create a new document and load the content from the Uri, with whitespace handling controlled according to "space".
/// </summary>
public XPathDocument([StringSyntax(StringSyntaxAttribute.Uri)] string uri, XmlSpace space)
{
XmlTextReaderImpl reader = SetupReader(new XmlTextReaderImpl(uri));
try
{
LoadFromReader(reader, space);
}
finally
{
reader.Close();
}
}
public XPathDocument(Stream stream)
{
XmlTextReaderImpl reader = this.SetupReader(new XmlTextReaderImpl(string.Empty, stream));
try
{
this.LoadFromReader(reader, XmlSpace.Default);
}
finally
{
reader.Close();
}
}
public QueryReaderSettings(XmlReader reader)
{
#pragma warning disable 618
XmlValidatingReader?valReader = reader as XmlValidatingReader;
#pragma warning restore 618
if (valReader != null)
{
// Unwrap validation reader
_validatingReader = true;
reader = valReader.Impl.Reader;
}
_xmlReaderSettings = reader.Settings;
if (_xmlReaderSettings != null)
{
_xmlReaderSettings = _xmlReaderSettings.Clone();
_xmlReaderSettings.NameTable = reader.NameTable;
_xmlReaderSettings.CloseInput = true;
_xmlReaderSettings.LineNumberOffset = 0;
_xmlReaderSettings.LinePositionOffset = 0;
XmlTextReaderImpl?impl = reader as XmlTextReaderImpl;
if (impl != null)
{
_xmlReaderSettings.XmlResolver = impl.GetResolver();
}
}
else
{
_xmlNameTable = reader.NameTable;
XmlTextReader?xmlTextReader = reader as XmlTextReader;
if (xmlTextReader != null)
{
XmlTextReaderImpl impl = xmlTextReader.Impl;
_entityHandling = impl.EntityHandling;
_namespaces = impl.Namespaces;
_normalization = impl.Normalization;
_prohibitDtd = (impl.DtdProcessing == DtdProcessing.Prohibit);
_whitespaceHandling = impl.WhitespaceHandling;
_xmlResolver = impl.GetResolver();
}
else
{
_entityHandling = EntityHandling.ExpandEntities;
_namespaces = true;
_normalization = true;
_prohibitDtd = true;
_whitespaceHandling = WhitespaceHandling.All;
_xmlResolver = null;
}
}
}
#pragma warning disable 618
// Creates a XmlValidatingReader suitable for parsing InnerXml strings
private XmlReader CreateInnerXmlReader(String xmlFragment, XmlNodeType nt, XmlParserContext context, XmlDocument doc)
{
XmlNodeType contentNT = nt;
if (contentNT == XmlNodeType.Entity || contentNT == XmlNodeType.EntityReference)
{
contentNT = XmlNodeType.Element;
}
XmlTextReaderImpl tr = new XmlTextReaderImpl(xmlFragment, contentNT, context);
tr.XmlValidatingReaderCompatibilityMode = true;
if (doc.HasSetResolver)
{
tr.XmlResolver = doc.GetResolver();
}
if (!(doc.ActualLoadingStatus))
{
tr.DisableUndeclaredEntityCheck = true;
}
Debug.Assert(tr.EntityHandling == EntityHandling.ExpandCharEntities);
XmlDocumentType dtdNode = doc.DocumentType;
if (dtdNode != null)
{
tr.Namespaces = dtdNode.ParseWithNamespaces;
if (dtdNode.DtdSchemaInfo != null)
{
tr.SetDtdInfo(dtdNode.DtdSchemaInfo);
}
else
{
IDtdParser dtdParser = DtdParser.Create();
XmlTextReaderImpl.DtdParserProxy proxy = new XmlTextReaderImpl.DtdParserProxy(tr);
IDtdInfo dtdInfo = dtdParser.ParseFreeFloatingDtd(context.BaseURI, context.DocTypeName, context.PublicId, context.SystemId, context.InternalSubset, proxy);
// TODO: Change all of XmlDocument to IDtdInfo interfaces
dtdNode.DtdSchemaInfo = dtdInfo as SchemaInfo;
tr.SetDtdInfo(dtdInfo);
}
}
if (nt == XmlNodeType.Entity || nt == XmlNodeType.EntityReference)
{
tr.Read(); //this will skip the first element "wrapper"
tr.ResolveEntity();
}
return(tr);
}
public QueryReaderSettings(XmlReader reader)
{
#pragma warning disable 618
XmlValidatingReader valReader = reader as XmlValidatingReader;
#pragma warning restore 618
if (valReader != null)
{
// Unwrap validation reader
validatingReader = true;
reader = valReader.Impl.Reader;
}
xmlReaderSettings = reader.Settings;
if (xmlReaderSettings != null)
{
xmlReaderSettings = xmlReaderSettings.Clone();
xmlReaderSettings.NameTable = reader.NameTable;
xmlReaderSettings.CloseInput = true;
xmlReaderSettings.LineNumberOffset = 0;
xmlReaderSettings.LinePositionOffset = 0;
XmlTextReaderImpl impl = reader as XmlTextReaderImpl;
if (impl != null)
{
xmlReaderSettings.XmlResolver = impl.GetResolver();
}
}
else
{
xmlNameTable = reader.NameTable;
XmlTextReader xmlTextReader = reader as XmlTextReader;
if (xmlTextReader != null)
{
XmlTextReaderImpl impl = xmlTextReader.Impl;
entityHandling = impl.EntityHandling;
namespaces = impl.Namespaces;
normalization = impl.Normalization;
prohibitDtd = impl.ProhibitDtd;
whitespaceHandling = impl.WhitespaceHandling;
xmlResolver = impl.GetResolver();
}
else
{
entityHandling = EntityHandling.ExpandEntities;
namespaces = true;
normalization = true;
prohibitDtd = true;
whitespaceHandling = WhitespaceHandling.All;
xmlResolver = null;
}
}
}
protected virtual void Dispose(bool disposing)
{
if (_reader != null)
{
_reader.Dispose();
_reader = null;
}
if (_preservationProvider != null)
{
_preservationProvider.Close();
_preservationProvider = null;
}
}
internal void AdjustLineInfo(int valueOffset, bool isNormalized, ref LineInfo lineInfo)
{
if (valueOffset == 0)
{
return;
}
if (_valueStartPos != -1)
{
XmlTextReaderImpl.AdjustLineInfo(_chars, _valueStartPos, _valueStartPos + valueOffset, isNormalized, ref lineInfo);
}
else
{
XmlTextReaderImpl.AdjustLineInfo(_value, 0, valueOffset, isNormalized, ref lineInfo);
}
}
/// <summary>
/// Create a new document and load the content from the stream.
/// </summary>
public XPathDocument(Stream stream)
{
ArgumentNullException.ThrowIfNull(stream);
XmlTextReaderImpl reader = SetupReader(new XmlTextReaderImpl(string.Empty, stream));
try
{
LoadFromReader(reader, XmlSpace.Default);
}
finally
{
reader.Close();
}
}
public QueryReaderSettings(XmlReader reader)
{
XmlValidatingReader reader2 = reader as XmlValidatingReader;
if (reader2 != null)
{
this.validatingReader = true;
reader = reader2.Impl.Reader;
}
this.xmlReaderSettings = reader.Settings;
if (this.xmlReaderSettings != null)
{
this.xmlReaderSettings = this.xmlReaderSettings.Clone();
this.xmlReaderSettings.NameTable = reader.NameTable;
this.xmlReaderSettings.CloseInput = true;
this.xmlReaderSettings.LineNumberOffset = 0;
this.xmlReaderSettings.LinePositionOffset = 0;
XmlTextReaderImpl impl = reader as XmlTextReaderImpl;
if (impl != null)
{
this.xmlReaderSettings.XmlResolver = impl.GetResolver();
}
}
else
{
this.xmlNameTable = reader.NameTable;
XmlTextReader reader3 = reader as XmlTextReader;
if (reader3 != null)
{
XmlTextReaderImpl impl2 = reader3.Impl;
this.entityHandling = impl2.EntityHandling;
this.namespaces = impl2.Namespaces;
this.normalization = impl2.Normalization;
this.prohibitDtd = impl2.DtdProcessing == DtdProcessing.Prohibit;
this.whitespaceHandling = impl2.WhitespaceHandling;
this.xmlResolver = impl2.GetResolver();
}
else
{
this.entityHandling = EntityHandling.ExpandEntities;
this.namespaces = true;
this.normalization = true;
this.prohibitDtd = true;
this.whitespaceHandling = WhitespaceHandling.All;
this.xmlResolver = null;
}
}
}
// Initializes a new instance of XmlValidatingReaderImpl class with the specified arguments.
// This constructor is used when creating XmlValidatingReaderImpl reader via "XmlReader.Create(..)"
internal XmlValidatingReaderImpl(XmlReader reader, ValidationEventHandler settingsEventHandler, bool processIdentityConstraints)
{
XmlAsyncCheckReader asyncCheckReader = reader as XmlAsyncCheckReader;
if (asyncCheckReader != null)
{
reader = asyncCheckReader.CoreReader;
}
_outerReader = this;
_coreReader = reader;
_coreReaderImpl = reader as XmlTextReaderImpl;
if (_coreReaderImpl == null)
{
XmlTextReader tr = reader as XmlTextReader;
if (tr != null)
{
_coreReaderImpl = tr.Impl;
}
}
if (_coreReaderImpl == null)
{
throw new ArgumentException(ResXml.Arg_ExpectingXmlTextReader, "reader");
}
_coreReaderImpl.XmlValidatingReaderCompatibilityMode = true;
_coreReaderNSResolver = reader as IXmlNamespaceResolver;
_processIdentityConstraints = processIdentityConstraints;
#pragma warning disable 618
_schemaCollection = new XmlSchemaCollection(_coreReader.NameTable);
#pragma warning restore 618
_schemaCollection.XmlResolver = GetResolver();
_eventHandling = new ValidationEventHandling(this);
if (settingsEventHandler != null)
{
_eventHandling.AddHandler(settingsEventHandler);
}
_coreReaderImpl.ValidationEventHandling = _eventHandling;
_coreReaderImpl.OnDefaultAttributeUse = new XmlTextReaderImpl.OnDefaultAttributeUseDelegate(ValidateDefaultAttributeOnUse);
_validationType = ValidationType.DTD;
SetupValidation(ValidationType.DTD);
}
public override void Load(XmlReader reader)
{
_reader = reader as XmlTextReaderImpl;
if (_reader != null)
{
_fileName = _reader.BaseURI;
}
base.Load(reader);
//if (_reader != null)
//{
// _textEncoding = _reader.Encoding;
//}
_firstLoad = false;
}
private void ParseDocumentType(XmlDocumentType dtNode, bool bUseResolver, XmlResolver resolver)
{
_doc = dtNode.OwnerDocument;
XmlParserContext pc = new XmlParserContext(null, new XmlNamespaceManager(_doc.NameTable), null, null, null, null, _doc.BaseURI, string.Empty, XmlSpace.None);
XmlTextReaderImpl tr = new XmlTextReaderImpl("", XmlNodeType.Element, pc);
tr.Namespaces = dtNode.ParseWithNamespaces;
if (bUseResolver)
{
tr.XmlResolver = resolver;
}
IDtdParser dtdParser = DtdParser.Create();
XmlTextReaderImpl.DtdParserProxy proxy = new XmlTextReaderImpl.DtdParserProxy(tr);
IDtdInfo dtdInfo = dtdParser.ParseFreeFloatingDtd(_doc.BaseURI, dtNode.Name, dtNode.PublicId, dtNode.SystemId, dtNode.InternalSubset, proxy);
LoadDocumentType(dtdInfo, dtNode);
}
internal XPathNavigator GetNavigator(Uri ruri)
{
XPathNavigator?result = null;
if (_documentCache != null)
{
result = _documentCache[ruri] as XPathNavigator;
if (result != null)
{
return(result.Clone());
}
}
else
{
_documentCache = new Hashtable();
}
object?input = _resolver.GetEntity(ruri, null, null);
if (input is Stream)
{
XmlTextReaderImpl tr = new XmlTextReaderImpl(ruri.ToString(), (Stream)input);
{
tr.XmlResolver = _resolver;
}
// reader is closed by Compiler.LoadDocument()
result = ((IXPathNavigable)Compiler.LoadDocument(tr)).CreateNavigator();
}
else if (input is XPathNavigator)
{
result = (XPathNavigator)input;
}
else
{
throw XsltException.Create(SR.Xslt_CantResolve, ruri.ToString());
}
_documentCache[ruri] = result !.Clone();
return(result);
}
private void LoadFromTextReader(TextReader textReader)
{
StreamReader streamReader = textReader as StreamReader;
if (streamReader != null)
{
FileStream fileStream = streamReader.BaseStream as FileStream;
if (fileStream != null)
{
_fileName = fileStream.Name;
}
_textEncoding = GetEncodingFromStream(streamReader.BaseStream);
}
_reader = new XmlTextReaderImpl(_fileName, textReader, normalizeLineEndings: false);
base.Load(_reader);
//if (_textEncoding == null) {
// _textEncoding = _reader.Encoding;
//}
}
internal NavigatorInput ResolveDocument(Uri absoluteUri)
{
Debug.Assert(this.xmlResolver != null);
object input = this.xmlResolver.GetEntity(absoluteUri, null, null);
string resolved = absoluteUri.ToString();
if (input is Stream)
{
XmlTextReaderImpl tr = new XmlTextReaderImpl(resolved, (Stream)input); {
tr.XmlResolver = this.xmlResolver;
}
// reader is closed by Compiler.LoadDocument()
return(new NavigatorInput(Compiler.LoadDocument(tr).CreateNavigator(), resolved, rootScope));
}
else if (input is XPathNavigator)
{
return(new NavigatorInput((XPathNavigator)input, resolved, rootScope));
}
else
{
throw XsltException.Create(Res.Xslt_CantResolve, resolved);
}
}
internal XmlNode CloneNodeFromOtherDocument(XmlNode element)
{
XmlTextReaderImpl oldReader = _reader;
string oldFileName = _fileName;
XmlNode clone = null;
try {
IXmlLineInfo lineInfo = element as IXmlLineInfo;
if (lineInfo != null)
{
_reader = new XmlTextReaderImpl(new StringReader(element.OuterXml), normalizeLineEndings: false);
_lineNumberOffset = lineInfo.LineNumber - 1;
_linePositionOffset = lineInfo.LinePosition - 2;
_fileName = element.OwnerDocument.BaseURI;
clone = ReadNode(_reader);
}
else
{
_fileName = null;
_reader = null;
clone = ReadNode(new XmlTextReaderImpl(new StringReader(element.OuterXml), normalizeLineEndings: false));
}
}
finally {
_lineNumberOffset = 0;
_linePositionOffset = 0;
_fileName = oldFileName;
_reader = oldReader;
}
return(clone);
}
internal XmlReader CreateReader(Stream input, Uri baseUri, string baseUriString, XmlParserContext inputContext)
{
if (input == null)
{
throw new ArgumentNullException("input");
}
if (baseUriString == null)
{
if (baseUri == null)
{
baseUriString = string.Empty;
}
else
{
baseUriString = baseUri.ToString();
}
}
// create text XML reader
XmlReader reader = new XmlTextReaderImpl(input, null, 0, this, baseUri, baseUriString, inputContext, _closeInput);
// wrap with validating reader
if (this.ValidationType != ValidationType.None)
{
reader = AddValidation(reader);
}
#if ASYNC
if (useAsync)
{
reader = XmlAsyncCheckReader.CreateAsyncCheckWrapper(reader);
}
#endif
return(reader);
}
// [ResourceConsumption(ResourceScope.Machine)]
// [ResourceExposure(ResourceScope.Machine)]
internal XmlReader CreateReader(String inputUri, XmlParserContext inputContext)
{
if (inputUri == null)
{
throw new ArgumentNullException("inputUri");
}
if (inputUri.Length == 0)
{
throw new ArgumentException(ResXml.XmlConvert_BadUri, "inputUri");
}
// resolve and open the url
XmlResolver tmpResolver = this.GetXmlResolver();
if (tmpResolver == null)
{
tmpResolver = CreateDefaultResolver();
}
// create text XML reader
XmlReader reader = new XmlTextReaderImpl(inputUri, this, inputContext, tmpResolver);
// wrap with validating reader
if (this.ValidationType != ValidationType.None)
{
reader = AddValidation(reader);
}
#if ASYNC
if (useAsync)
{
reader = XmlAsyncCheckReader.CreateAsyncCheckWrapper(reader);
}
#endif
return(reader);
}
public void Load(string url)
{
XmlTextReaderImpl tr = new XmlTextReaderImpl(url);
Compile(Compiler.LoadDocument(tr).CreateNavigator(), CreateDefaultResolver());
}
public void Load(string url)
{
XmlTextReaderImpl tr = new XmlTextReaderImpl(url);
Compile(Compiler.LoadDocument(tr).CreateNavigator(), CreateDefaultResolver());
}
public void Load(string url) {
XmlTextReaderImpl tr = new XmlTextReaderImpl(url);
Evidence evidence = XmlSecureResolver.CreateEvidenceForUrl(tr.BaseURI); // We should ask BaseURI before we start reading because it's changing with each node
Compile(Compiler.LoadDocument(tr).CreateNavigator(), XsltConfigSection.CreateDefaultResolver(), evidence);
}
internal XPathNavigator GetNavigator(Uri ruri) {
XPathNavigator result = null;
if (documentCache != null) {
result = documentCache[ruri] as XPathNavigator;
if (result != null) {
return result.Clone();
}
}
else {
documentCache = new Hashtable();
}
Object input = resolver.GetEntity(ruri, null, null);
if (input is Stream) {
XmlTextReaderImpl tr = new XmlTextReaderImpl(ruri.ToString(), (Stream) input); {
tr.XmlResolver = this.resolver;
}
// reader is closed by Compiler.LoadDocument()
result = ((IXPathNavigable)Compiler.LoadDocument(tr)).CreateNavigator();
}
else if (input is XPathNavigator){
result = (XPathNavigator) input;
}
else {
throw XsltException.Create(Res.Xslt_CantResolve, ruri.ToString());
}
documentCache[ruri] = result.Clone();
return result;
}
public void Load(string url, XmlResolver resolver)
{
XmlTextReaderImpl tr = new XmlTextReaderImpl(url);
{
tr.XmlResolver = resolver;
}
Compile(Compiler.LoadDocument(tr).CreateNavigator(), resolver);
}
// Constructors
internal DtdParserProxy(XmlTextReaderImpl reader)
{
_reader = reader;
}
//-----------------------------------------------
// Helper Methods
//-----------------------------------------------
/// <summary>
/// Set properties on the reader so that it is backwards-compatible with V1.
/// </summary>
private static XmlTextReaderImpl SetupReader(XmlTextReaderImpl reader)
{
reader.EntityHandling = EntityHandling.ExpandEntities;
reader.XmlValidatingReaderCompatibilityMode = true;
return(reader);
}
public void Load(string url)
{
XmlTextReaderImpl tr = new XmlTextReaderImpl(url);
Compile(Compiler.LoadDocument(tr).CreateNavigator(), XmlNullResolver.Singleton);
}
//-----------------------------------------------
// Helper Methods
//-----------------------------------------------
/// <summary>
/// Set properties on the reader so that it is backwards-compatible with V1.
/// </summary>
private XmlTextReaderImpl SetupReader(XmlTextReaderImpl reader)
{
reader.EntityHandling = EntityHandling.ExpandEntities;
reader.XmlValidatingReaderCompatibilityMode = true;
return reader;
}
