internal void TrimSpacesInValue()
{
if (ValueBuffered)
{
XmlTextReaderImpl.StripSpaces(_chars, _valueStartPos, ref _valueLength);
}
else
{
_value = XmlTextReaderImpl.StripSpaces(_value);
}
}
internal void TrimSpacesInValue()
{
if (ValueBuffered)
{
Debug.Assert(_chars != null);
XmlTextReaderImpl.StripSpaces(_chars, _valueStartPos, ref _valueLength);
}
else
{
Debug.Assert(_value != null);
_value = XmlTextReaderImpl.StripSpaces(_value);
}
}
#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);
}
private XmlReader CreateInnerXmlReader(string xmlFragment, XmlNodeType nt, XmlParserContext context, XmlDocument doc)
{
XmlNodeType fragType = nt;
switch (fragType)
{
case XmlNodeType.Entity:
case XmlNodeType.EntityReference:
fragType = XmlNodeType.Element;
break;
}
XmlTextReaderImpl reader = new XmlTextReaderImpl(xmlFragment, fragType, context)
{
XmlValidatingReaderCompatibilityMode = true
};
if (doc.HasSetResolver)
{
reader.XmlResolver = doc.GetResolver();
}
if (!doc.ActualLoadingStatus)
{
reader.DisableUndeclaredEntityCheck = true;
}
XmlDocumentType documentType = doc.DocumentType;
if (documentType != null)
{
reader.Namespaces = documentType.ParseWithNamespaces;
if (documentType.DtdSchemaInfo != null)
{
reader.SetDtdInfo(documentType.DtdSchemaInfo);
}
else
{
IDtdParser parser = DtdParser.Create();
XmlTextReaderImpl.DtdParserProxy adapter = new XmlTextReaderImpl.DtdParserProxy(reader);
IDtdInfo newDtdInfo = parser.ParseFreeFloatingDtd(context.BaseURI, context.DocTypeName, context.PublicId, context.SystemId, context.InternalSubset, adapter);
documentType.DtdSchemaInfo = newDtdInfo as SchemaInfo;
reader.SetDtdInfo(newDtdInfo);
}
}
if ((nt == XmlNodeType.Entity) || (nt == XmlNodeType.EntityReference))
{
reader.Read();
reader.ResolveEntity();
}
return(reader);
}
// 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(SR.Arg_ExpectingXmlTextReader, nameof(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);
}
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);
}
}
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
{
char[] chars = value.ToCharArray(0, valueOffset);
XmlTextReaderImpl.AdjustLineInfo(chars, 0, chars.Length, isNormalized, ref lineInfo);
}
}
// 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(Res.GetString(Res.Arg_ExpectingXmlTextReader), "reader");
}
coreReaderImpl.XmlValidatingReaderCompatibilityMode = true;
coreReaderNSResolver = reader as IXmlNamespaceResolver;
this.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);
}
private XmlReader CreateInnerXmlReader(string xmlFragment, XmlNodeType nt, XmlParserContext context, XmlDocument doc)
{
XmlNodeType fragType = nt;
switch (fragType)
{
case XmlNodeType.Entity:
case XmlNodeType.EntityReference:
fragType = XmlNodeType.Element;
break;
}
XmlTextReaderImpl reader = new XmlTextReaderImpl(xmlFragment, fragType, context) {
XmlValidatingReaderCompatibilityMode = true
};
if (doc.HasSetResolver)
{
reader.XmlResolver = doc.GetResolver();
}
if (!doc.ActualLoadingStatus)
{
reader.DisableUndeclaredEntityCheck = true;
}
XmlDocumentType documentType = doc.DocumentType;
if (documentType != null)
{
reader.Namespaces = documentType.ParseWithNamespaces;
if (documentType.DtdSchemaInfo != null)
{
reader.SetDtdInfo(documentType.DtdSchemaInfo);
}
else
{
IDtdParser parser = DtdParser.Create();
XmlTextReaderImpl.DtdParserProxy adapter = new XmlTextReaderImpl.DtdParserProxy(reader);
IDtdInfo newDtdInfo = parser.ParseFreeFloatingDtd(context.BaseURI, context.DocTypeName, context.PublicId, context.SystemId, context.InternalSubset, adapter);
documentType.DtdSchemaInfo = newDtdInfo as SchemaInfo;
reader.SetDtdInfo(newDtdInfo);
}
}
if ((nt == XmlNodeType.Entity) || (nt == XmlNodeType.EntityReference))
{
reader.Read();
reader.ResolveEntity();
}
return reader;
}
internal XmlReader CreateReader(TextReader input, string baseUriString, XmlParserContext inputContext)
{
if (input == null)
{
throw new ArgumentNullException("input");
}
if (baseUriString == null)
{
baseUriString = string.Empty;
}
XmlReader reader = new XmlTextReaderImpl(input, this, baseUriString, inputContext);
if (this.ValidationType != System.Xml.ValidationType.None)
{
reader = this.AddValidation(reader);
}
return(reader);
}
// 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)
{
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(Res.GetString(Res.Arg_ExpectingXmlTextReader), "reader");
}
coreReaderImpl.XmlValidatingReaderCompatibilityMode = true;
coreReaderNSResolver = reader as IXmlNamespaceResolver;
this.processIdentityConstraints = processIdentityConstraints;
#pragma warning disable 618
schemaCollection = new XmlSchemaCollection(coreReader.NameTable);
#pragma warning restore 618
schemaCollection.XmlResolver = GetResolver();
if (settingsEventHandler == null)
{
internalEventHandler = new ValidationEventHandler(InternalValidationCallback);
eventHandler = internalEventHandler;
coreReaderImpl.ValidationEventHandler = internalEventHandler;
}
else
{
eventHandler = settingsEventHandler;
coreReaderImpl.ValidationEventHandler = settingsEventHandler;
}
validationType = ValidationType.DTD;
SetupValidation(ValidationType.DTD);
}
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);
}
private void ParseDocumentType(XmlDocumentType dtNode, bool bUseResolver, XmlResolver resolver)
{
this.doc = dtNode.OwnerDocument;
XmlParserContext context = new XmlParserContext(null, new XmlNamespaceManager(this.doc.NameTable), null, null, null, null, this.doc.BaseURI, string.Empty, XmlSpace.None);
XmlTextReaderImpl reader = new XmlTextReaderImpl("", XmlNodeType.Element, context)
{
Namespaces = dtNode.ParseWithNamespaces
};
if (bUseResolver)
{
reader.XmlResolver = resolver;
}
IDtdParser parser = DtdParser.Create();
XmlTextReaderImpl.DtdParserProxy adapter = new XmlTextReaderImpl.DtdParserProxy(reader);
IDtdInfo dtdInfo = parser.ParseFreeFloatingDtd(this.doc.BaseURI, dtNode.Name, dtNode.PublicId, dtNode.SystemId, dtNode.InternalSubset, adapter);
this.LoadDocumentType(dtdInfo, dtNode);
}
public XmlReader CreateReader(Stream stream, string baseUri) {
XmlReader reader;
if (xmlReaderSettings != null) {
reader = XmlTextReader.Create(stream, xmlReaderSettings, baseUri);
} else {
XmlTextReaderImpl readerImpl = new XmlTextReaderImpl(baseUri, stream, xmlNameTable);
readerImpl.EntityHandling = entityHandling;
readerImpl.Namespaces = namespaces;
readerImpl.Normalization = normalization;
readerImpl.DtdProcessing = prohibitDtd ? DtdProcessing.Prohibit : DtdProcessing.Parse;
readerImpl.WhitespaceHandling = whitespaceHandling;
readerImpl.XmlResolver = xmlResolver;
reader = readerImpl;
}
if (validatingReader) {
#pragma warning disable 618
reader = new XmlValidatingReader(reader);
#pragma warning restore 618
}
return reader;
}
//
// Constructors
//
// Initializes a new instance of XmlValidatingReaderImpl class with the specified XmlReader.
// This constructor is used when creating XmlValidatingReaderImpl for V1 XmlValidatingReader
internal XmlValidatingReaderImpl(XmlReader reader)
{
XmlAsyncCheckReader asyncCheckReader = reader as XmlAsyncCheckReader;
if (asyncCheckReader != null)
{
reader = asyncCheckReader.CoreReader;
}
_outerReader = this;
_coreReader = reader;
_coreReaderNSResolver = reader as IXmlNamespaceResolver;
_coreReaderImpl = reader as XmlTextReaderImpl;
if (_coreReaderImpl == null)
{
XmlTextReader tr = reader as XmlTextReader;
if (tr != null)
{
_coreReaderImpl = tr.Impl;
}
}
if (_coreReaderImpl == null)
{
throw new ArgumentException(SR.Arg_ExpectingXmlTextReader, "reader");
}
_coreReaderImpl.EntityHandling = EntityHandling.ExpandEntities;
_coreReaderImpl.XmlValidatingReaderCompatibilityMode = true;
_processIdentityConstraints = true;
#pragma warning disable 618
_schemaCollection = new XmlSchemaCollection(_coreReader.NameTable);
_schemaCollection.XmlResolver = GetResolver();
_eventHandling = new ValidationEventHandling(this);
_coreReaderImpl.ValidationEventHandling = _eventHandling;
_coreReaderImpl.OnDefaultAttributeUse = new XmlTextReaderImpl.OnDefaultAttributeUseDelegate(ValidateDefaultAttributeOnUse);
_validationType = ValidationType.Auto;
SetupValidation(ValidationType.Auto);
#pragma warning restore 618
}
internal XmlReader CreateReader(TextReader input, string baseUriString, XmlParserContext inputContext)
{
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
if (baseUriString == null)
{
baseUriString = string.Empty;
}
// create xml text reader
XmlReader reader = new XmlTextReaderImpl(input, this, baseUriString, inputContext);
if (_useAsync)
{
reader = XmlAsyncCheckReader.CreateAsyncCheckWrapper(reader);
}
return(reader);
}
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);
#if !SILVERLIGHT
// wrap with validating reader
if (this.ValidationType != ValidationType.None)
{
reader = AddValidation(reader);
}
#endif
#if ASYNC
if (useAsync)
{
reader = XmlAsyncCheckReader.CreateAsyncCheckWrapper(reader);
}
#endif
return(reader);
}
internal XmlReader CreateReader(String inputUri, XmlParserContext inputContext)
{
if (inputUri == null)
{
throw new ArgumentNullException("inputUri");
}
if (inputUri.Length == 0)
{
throw new ArgumentException(Res.GetString(Res.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);
#if !SILVERLIGHT
// wrap with validating reader
if (this.ValidationType != ValidationType.None)
{
reader = AddValidation(reader);
}
#endif
#if ASYNC
if (useAsync)
{
reader = XmlAsyncCheckReader.CreateAsyncCheckWrapper(reader);
}
#endif
return(reader);
}
public XmlTextReader(string url)
{
_impl = new XmlTextReaderImpl(url, new NameTable());
_impl.OuterReader = this;
}
public XmlTextReader(string url, TextReader input, XmlNameTable nt)
{
_impl = new XmlTextReaderImpl(url, input, nt);
_impl.OuterReader = this;
}
public XmlTextReader(TextReader input)
{
_impl = new XmlTextReaderImpl(input);
_impl.OuterReader = this;
}
private XmlTextReaderImpl SetupReader(XmlTextReaderImpl reader)
{
reader.EntityHandling = EntityHandling.ExpandEntities;
reader.XmlValidatingReaderCompatibilityMode = true;
return reader;
}
private static XmlReader CreateReaderImpl(Stream input, XmlReaderSettings settings, Uri baseUri, string baseUriStr,
XmlParserContext inputContext, bool closeInput) {
if (input == null) {
throw new ArgumentNullException("input");
}
if (baseUriStr == null) {
Debug.Assert(baseUri == null);
baseUriStr = string.Empty;
}
// create text XML reader
XmlReader reader = new XmlTextReaderImpl(input, null, 0, settings, baseUri, baseUriStr, inputContext, closeInput);
// wrap with validating reader
if ( settings.ValidationType != ValidationType.None ) {
reader = AddValidation(reader, settings);
}
return reader;
}
public XmlTextReader(Stream input, XmlNameTable nt)
{
_impl = new XmlTextReaderImpl(input, nt);
_impl.OuterReader = this;
}
internal void ValidateDefaultAttributeOnUse(IDtdDefaultAttributeInfo defaultAttribute, XmlTextReaderImpl coreReader)
{
SchemaAttDef attdef = defaultAttribute as SchemaAttDef;
if (attdef == null)
{
return;
}
if (!attdef.DefaultValueChecked)
{
SchemaInfo schemaInfo = coreReader.DtdInfo as SchemaInfo;
if (schemaInfo == null)
{
return;
}
DtdValidator.CheckDefaultValue(attdef, schemaInfo, eventHandling, coreReader.BaseURI);
}
}
public XmlTextReader(Stream input)
{
_impl = new XmlTextReaderImpl(input);
_impl.OuterReader = this;
}
public XmlTextReader(string url, Stream input)
{
_impl = new XmlTextReaderImpl(url, input);
_impl.OuterReader = this;
}
public XmlTextReader(Stream xmlFragment, XmlNodeType fragType, XmlParserContext context)
{
impl = new XmlTextReaderImpl(xmlFragment, fragType, context);
impl.OuterReader = this;
}
//
// Internal static Parse method
//
static internal SchemaInfo Parse( XmlNameTable nt, XmlNamespaceManager nsManager, bool namespaces, string baseUri, string docTypeName,
string publicId, string systemId, string internalSubset, bool useResolver, XmlResolver resolver ) {
XmlParserContext pc = new XmlParserContext( nt, nsManager, null, null, null, null, baseUri, string.Empty, XmlSpace.None );
XmlTextReaderImpl tr = new XmlTextReaderImpl( "", XmlNodeType.Element, pc );
tr.Namespaces = namespaces;
if ( useResolver ) {
tr.XmlResolver = resolver;
}
return DtdParser.Parse( tr, baseUri, docTypeName, publicId, systemId, internalSubset );
}
//
// Constructors
//
// Initializes a new instance of XmlValidatingReaderImpl class with the specified XmlReader.
// This constructor is used when creating XmlValidatingReaderImpl for V1 XmlValidatingReader
internal XmlValidatingReaderImpl(XmlReader reader)
{
XmlAsyncCheckReader asyncCheckReader = reader as XmlAsyncCheckReader;
if (asyncCheckReader != null)
{
reader = asyncCheckReader.CoreReader;
}
_outerReader = this;
_coreReader = reader;
_coreReaderNSResolver = reader as IXmlNamespaceResolver;
_coreReaderImpl = reader as XmlTextReaderImpl;
if (_coreReaderImpl == null)
{
XmlTextReader tr = reader as XmlTextReader;
if (tr != null)
{
_coreReaderImpl = tr.Impl;
}
}
if (_coreReaderImpl == null)
{
throw new ArgumentException(SR.Arg_ExpectingXmlTextReader, nameof(reader));
}
_coreReaderImpl.EntityHandling = EntityHandling.ExpandEntities;
_coreReaderImpl.XmlValidatingReaderCompatibilityMode = true;
_processIdentityConstraints = true;
#pragma warning disable 618
_schemaCollection = new XmlSchemaCollection(_coreReader.NameTable);
_schemaCollection.XmlResolver = GetResolver();
_eventHandling = new ValidationEventHandling(this);
_coreReaderImpl.ValidationEventHandling = _eventHandling;
_coreReaderImpl.OnDefaultAttributeUse = new XmlTextReaderImpl.OnDefaultAttributeUseDelegate(ValidateDefaultAttributeOnUse);
_validationType = ValidationType.Auto;
SetupValidation(ValidationType.Auto);
#pragma warning restore 618
}
internal XmlReader CreateReader(TextReader input, string baseUriString, XmlParserContext inputContext)
{
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
if (baseUriString == null)
{
baseUriString = string.Empty;
}
// create xml text reader
XmlReader reader = new XmlTextReaderImpl(input, this, baseUriString, inputContext);
// wrap with validating reader
if (this.ValidationType != ValidationType.None)
{
reader = AddValidation(reader);
}
if (_useAsync)
{
reader = XmlAsyncCheckReader.CreateAsyncCheckWrapper(reader);
}
return reader;
}
public XmlTextReader(Stream xmlFragment, XmlNodeType fragType, XmlParserContext context)
{
_impl = new XmlTextReaderImpl(xmlFragment, fragType, context);
_impl.OuterReader = this;
}
internal NavigatorInput ResolveDocument(Uri absoluteUri)
{
Debug.Assert(_xmlResolver != null);
object input = _xmlResolver.GetEntity(absoluteUri, null, null);
string resolved = absoluteUri.ToString();
if (input is Stream)
{
XmlTextReaderImpl tr = new XmlTextReaderImpl(resolved, (Stream)input);
{
tr.XmlResolver = _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(SR.Xslt_CantResolve, resolved);
}
}
// 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( Res.GetString( Res.Arg_ExpectingXmlTextReader ), "reader" );
}
coreReaderImpl.XmlValidatingReaderCompatibilityMode = true;
coreReaderNSResolver = reader as IXmlNamespaceResolver;
this.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 );
}
// !!!!!!
// NOTE: This method is called via reflection from System.Data.dll and from Analysis Services in Yukon.
// Do not change its signature without notifying the appropriate teams!
// !!!!!!
internal static XmlReader CreateSqlReader(Stream input, XmlReaderSettings settings, XmlParserContext inputContext) {
if (input == null) {
throw new ArgumentNullException("input");
}
if (settings == null) {
settings = new XmlReaderSettings();
}
XmlReader reader;
// allocate byte buffer
byte[] bytes = new byte[CalcBufferSize(input)];
#if false
{
// catch the binary XML input and dump it into a local file (for debugging and testing purposes)
// create dump file name
string dumpFileNameBase = "~CreateSqlReaderInputDump";
string dumpFileName;
int i = 0;
do {
i++;
dumpFileName = Path.GetFullPath(string.Concat(dumpFileNameBase, i.ToString(), ".bmx"));
} while (File.Exists(dumpFileName));
// dump the input into the file
FileStream fs = new FileStream(dumpFileName, FileMode.Create, FileAccess.ReadWrite);
byte[] buffer = new byte[4096];
int bytesRead;
while ((bytesRead = input.Read(buffer, 0, buffer.Length)) > 0) {
fs.Write(buffer, 0, bytesRead);
}
fs.Seek(0, SeekOrigin.Begin);
// make sure it will get closed
if (settings.CloseInput) {
input.Close();
}
input = fs;
settings = settings.Clone();
settings.CloseInput = true;
}
#endif
int byteCount = 0;
int read;
do {
read = input.Read(bytes, byteCount, bytes.Length - byteCount);
byteCount += read;
} while (read > 0 && byteCount < 2);
// create text or binary XML reader depenting on the stream first 2 bytes
if (byteCount >= 2 && (bytes[0] == 0xdf && bytes[1] == 0xff)) {
if ( inputContext != null )
throw new ArgumentException(Res.GetString(Res.XmlBinary_NoParserContext), "inputContext");
reader = new XmlSqlBinaryReader(input, bytes, byteCount, string.Empty, settings.CloseInput, settings);
}
else {
reader = new XmlTextReaderImpl(input, bytes, byteCount, settings, null, string.Empty, inputContext, settings.CloseInput);
}
// wrap with validating reader
if ( settings.ValidationType != ValidationType.None ) {
reader = settings.AddValidation( reader );
}
if (settings.Async) {
reader = XmlAsyncCheckReader.CreateAsyncCheckWrapper(reader);
}
return reader;
}
public XmlTextReader(Stream input)
{
impl = new XmlTextReaderImpl(input);
impl.OuterReader = this;
}
public XmlTextReader( string url ) {
impl = new XmlTextReaderImpl( url, new NameTable() );
impl.OuterReader = this;
}
protected XmlTextReader(XmlNameTable nt)
{
_impl = new XmlTextReaderImpl(nt);
_impl.OuterReader = this;
}
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);
#if !SILVERLIGHT
// wrap with validating reader
if (this.ValidationType != ValidationType.None) {
reader = AddValidation(reader);
}
#endif
#if ASYNC
if (useAsync) {
reader = XmlAsyncCheckReader.CreateAsyncCheckWrapper(reader);
}
#endif
return reader;
}
static internal SchemaInfo Parse( XmlTextReaderImpl tr, string baseUri, string docTypeName, string publicId, string systemId, string internalSubset ) {
XmlTextReaderImpl.DtdParserProxy dtdParserProxy = new XmlTextReaderImpl.DtdParserProxy( baseUri, docTypeName, publicId, systemId, internalSubset, tr );
dtdParserProxy.Parse( false );
return dtdParserProxy.DtdSchemaInfo;
}
internal void ValidateDefaultAttributeOnUse(IDtdDefaultAttributeInfo defaultAttribute, XmlTextReaderImpl coreReader) {
SchemaAttDef attdef = defaultAttribute as SchemaAttDef;
if (attdef == null) {
return;
}
if (!attdef.DefaultValueChecked) {
SchemaInfo schemaInfo = coreReader.DtdInfo as SchemaInfo;
if (schemaInfo == null) {
return;
}
DtdValidator.CheckDefaultValue(attdef, schemaInfo, eventHandling, coreReader.BaseURI);
}
}
internal DtdParserProxy(XmlTextReaderImpl reader)
{
_reader = reader;
}
protected XmlTextReader()
{
_impl = new XmlTextReaderImpl();
_impl.OuterReader = this;
}
public XmlTextReader(string url, TextReader input)
{
impl = new XmlTextReaderImpl(url, input);
impl.OuterReader = this;
}
public XmlTextReader(string url, Stream input)
{
_impl = new XmlTextReaderImpl(url, input);
_impl.OuterReader = this;
}
public XmlTextReader( String url, XmlNameTable nt ) {
impl = new XmlTextReaderImpl( url, nt );
impl.OuterReader = this;
}
public XmlTextReader(TextReader input, XmlNameTable nt)
{
_impl = new XmlTextReaderImpl(input, nt);
_impl.OuterReader = this;
}
public XmlTextReader(Stream input, XmlNameTable nt)
{
impl = new XmlTextReaderImpl(input, nt);
impl.OuterReader = this;
}
public XmlTextReader(string xmlFragment, XmlNodeType fragType, XmlParserContext context)
{
_impl = new XmlTextReaderImpl(xmlFragment, fragType, context);
_impl.OuterReader = this;
}
protected XmlTextReader( XmlNameTable nt ) {
impl = new XmlTextReaderImpl( nt );
impl.OuterReader = this;
}
internal XmlReader CreateReader(String inputUri, XmlParserContext inputContext)
{
if (inputUri == null)
{
throw new ArgumentNullException(nameof(inputUri));
}
if (inputUri.Length == 0)
{
throw new ArgumentException(SR.XmlConvert_BadUri, nameof(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 (_useAsync)
{
reader = XmlAsyncCheckReader.CreateAsyncCheckWrapper(reader);
}
return reader;
}
public XmlTextReader( TextReader input ) {
impl = new XmlTextReaderImpl( input );
impl.OuterReader = this;
}
//
// 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();
}
}
public XmlTextReader( string url, TextReader input ) {
impl = new XmlTextReaderImpl( url, input );
impl.OuterReader = this;
}
internal static XmlReader CreateSqlReader(Stream input, XmlReaderSettings settings, XmlParserContext inputContext)
{
XmlReader reader;
int num2;
if (input == null)
{
throw new ArgumentNullException("input");
}
if (settings == null)
{
settings = new XmlReaderSettings();
}
byte[] buffer = new byte[CalcBufferSize(input)];
int offset = 0;
do
{
num2 = input.Read(buffer, offset, buffer.Length - offset);
offset += num2;
}
while ((num2 > 0) && (offset < 2));
if (((offset >= 2) && (buffer[0] == 0xdf)) && (buffer[1] == 0xff))
{
if (inputContext != null)
{
throw new ArgumentException(Res.GetString("XmlBinary_NoParserContext"), "inputContext");
}
reader = new XmlSqlBinaryReader(input, buffer, offset, string.Empty, settings.CloseInput, settings);
}
else
{
reader = new XmlTextReaderImpl(input, buffer, offset, settings, null, string.Empty, inputContext, settings.CloseInput);
}
if (settings.ValidationType != ValidationType.None)
{
reader = settings.AddValidation(reader);
}
return reader;
}
public XmlTextReader( TextReader input, XmlNameTable nt ) {
impl = new XmlTextReaderImpl( input, nt );
impl.OuterReader = this;
}
public XmlTextReader( string url, TextReader input, XmlNameTable nt ) {
impl = new XmlTextReaderImpl( url, input, nt );
impl.OuterReader = this;
}
public XmlTextReader( string xmlFragment, XmlNodeType fragType, XmlParserContext context ) {
impl = new XmlTextReaderImpl( xmlFragment, fragType, context );
impl.OuterReader = this;
}
//
//
// Constructors
//
protected XmlTextReader() {
impl = new XmlTextReaderImpl();
impl.OuterReader = this;
}
private static XmlReader CreateReaderImpl(TextReader input, XmlReaderSettings settings, string baseUriStr,
XmlParserContext context) {
if (input == null) {
throw new ArgumentNullException("input");
}
if (settings == null) {
settings = new XmlReaderSettings();
}
if (baseUriStr == null) {
baseUriStr = string.Empty;
}
// create xml text reader
XmlReader reader = new XmlTextReaderImpl(input, settings, baseUriStr, context);
// wrap with validating reader
if (settings.ValidationType == ValidationType.Schema) {
reader = new XsdValidatingReader(reader, settings.GetXmlResolver(), settings);
}
else if (settings.ValidationType == ValidationType.DTD) {
reader = CreateDtdValidatingReader(reader, settings);
}
return reader;
}