internal XDeclaration(XmlReader r)
{
_version = r.GetAttribute("version");
_encoding = r.GetAttribute("encoding");
_standalone = r.GetAttribute("standalone");
r.Read();
}
public void StartParsing(XmlReader reader, string targetNamespace) {
this.reader = reader;
positionInfo = PositionInfo.GetPositionInfo(reader);
namespaceManager = reader.NamespaceManager;
if (namespaceManager == null) {
namespaceManager = new XmlNamespaceManager(nameTable);
isProcessNamespaces = true;
}
else {
isProcessNamespaces = false;
}
while (reader.NodeType != XmlNodeType.Element && reader.Read()) {}
markupDepth = int.MaxValue;
schemaXmlDepth = reader.Depth;
SchemaType rootType = schemaNames.SchemaTypeFromRoot(reader.LocalName, reader.NamespaceURI);
string code;
if (!CheckSchemaRoot(rootType, out code)) {
throw new XmlSchemaException(code, reader.BaseURI, positionInfo.LineNumber, positionInfo.LinePosition);
}
if (schemaType == SchemaType.XSD) {
schema = new XmlSchema();
schema.BaseUri = new Uri(reader.BaseURI, UriKind.RelativeOrAbsolute);
builder = new XsdBuilder(reader, namespaceManager, schema, nameTable, schemaNames, eventHandler);
}
else {
Debug.Assert(schemaType == SchemaType.XDR);
xdrSchema = new SchemaInfo();
xdrSchema.SchemaType = SchemaType.XDR;
builder = new XdrBuilder(reader, namespaceManager, xdrSchema, targetNamespace, nameTable, schemaNames, eventHandler);
((XdrBuilder)builder).XmlResolver = xmlResolver;
}
}
internal XmlCountingReader(XmlReader xmlReader)
{
if (xmlReader == null)
throw new ArgumentNullException("xmlReader");
this.innerReader = xmlReader;
this.advanceCount = 0;
}
internal XmlCountingReader(XmlReader xmlReader)
{
if (xmlReader == null)
throw new ArgumentNullException(nameof(xmlReader));
_innerReader = xmlReader;
_advanceCount = 0;
}
internal void StartParsing(XmlReader reader, string targetNamespace, SchemaInfo schemaInfo) {
this.reader = reader;
positionInfo = PositionInfo.GetPositionInfo(reader);
this.namespaceManager = reader.NamespaceManager;
if (this.namespaceManager == null) {
this.namespaceManager = new XmlNamespaceManager(this.nameTable);
this.isProcessNamespaces = true;
}
else {
this.isProcessNamespaces = false;
}
while (this.reader.NodeType != XmlNodeType.Element && this.reader.Read()) {}
this.markupDepth = int.MaxValue;
this.schemaXmlDepth = reader.Depth;
XmlQualifiedName qname = new XmlQualifiedName(this.reader.LocalName, XmlSchemaDatatype.XdrCanonizeUri(this.reader.NamespaceURI, this.nameTable, this.schemaNames));
if (this.schemaNames.IsXDRRoot(qname)) {
Debug.Assert(schemaInfo != null);
schemaInfo.SchemaType = SchemaType.XDR;
this.schema = null;
this.builder = new XdrBuilder(reader, this.namespaceManager, schemaInfo, targetNamespace, this.nameTable, this.schemaNames, this.validationEventHandler);
}
else if (this.schemaNames.IsXSDRoot(qname)) {
if (schemaInfo != null) {
schemaInfo.SchemaType = SchemaType.XSD;
}
this.schema = new XmlSchema();
this.schema.BaseUri = reader.BaseURI;
this.builder = new XsdBuilder(reader, this.namespaceManager, this.schema, this.nameTable, this.schemaNames, this.validationEventHandler);
}
else {
throw new XmlSchemaException(Res.Sch_SchemaRootExpected, reader.BaseURI, positionInfo.LineNumber, positionInfo.LinePosition);
}
}
/// <summary>
/// Create a new document from "reader", with whitespace handling controlled according to "space".
/// </summary>
public XPathDocument(XmlReader reader, XmlSpace space)
{
if (reader == null)
throw new ArgumentNullException(nameof(reader));
LoadFromReader(reader, space);
}
public void Load(XmlReader stylesheet, XmlResolver resolver)
{
if (stylesheet == null)
{
throw new ArgumentNullException(nameof(stylesheet));
}
Load(new XPathDocument(stylesheet, XmlSpace.Preserve), resolver);
}
public XmlCustomReader(TextReader textReader, XmlReaderSettings settings, string baseUri)
{
XmlReader w = ReaderHelper.Create(textReader, settings, baseUri);
XmlReaderSettings wsettings = new XmlReaderSettings();
wsettings.CheckCharacters = true;
wsettings.DtdProcessing = DtdProcessing.Ignore;
wsettings.ConformanceLevel = ConformanceLevel.Auto;
_wrappedreader = ReaderHelper.Create(w, wsettings);
}
public XmlCustomReader(string filename, XmlReaderSettings settings)
{
XmlReader w = ReaderHelper.Create(filename, settings);
XmlReaderSettings wsettings = new XmlReaderSettings();
wsettings.CheckCharacters = true;
wsettings.DtdProcessing = DtdProcessing.Ignore;
wsettings.ConformanceLevel = ConformanceLevel.Auto;
_wrappedreader = ReaderHelper.Create(w, wsettings);
}
private void Init( XmlReader reader ) {
XmlValidatingReader vr = null;
try {
vr = new XmlValidatingReader( reader );
vr.EntityHandling = EntityHandling.ExpandEntities;
vr.ValidationType = ValidationType.None;
vr.ValidationEventHandler += new ValidationEventHandler(ValidationCallback);
Load( vr );
}
finally {
vr.Close();
reader.Close();
}
}
public bool CheckIgnores(XmlReader reader, bool pi, bool comm, bool ws)
{
if (reader == null)
return false;
_commentCount = 0;
_piCount = 0;
_wsCount = 0;
while (reader.Read())
{
if (XmlNodeType.ProcessingInstruction == reader.NodeType)
{
++_piCount;
}
if (XmlNodeType.SignificantWhitespace == reader.NodeType)
{
++_wsCount;
}
if (XmlNodeType.Comment == reader.NodeType)
{
++_commentCount;
}
}
if (pi && _piCount > 0)
{
CError.WriteLineIgnore("ProcessingInstruction Found");
CError.WriteLineIgnore(reader.Name);
CError.WriteLineIgnore(">" + reader.Value + "<");
return false;
}
if (comm && _commentCount > 0)
{
CError.WriteLineIgnore("Comment Found");
CError.WriteLineIgnore(reader.Name);
CError.WriteLineIgnore(">" + reader.Value + "<");
return false;
}
if (ws && _wsCount > 0)
{
CError.WriteLineIgnore("Significant Whitespace Found");
CError.WriteLineIgnore(reader.Name);
CError.WriteLineIgnore(">" + reader.Value + "<");
return false;
}
return true;
}
public async Task StartParsingAsync(XmlReader reader, string targetNamespace)
{
_reader = reader;
_positionInfo = PositionInfo.GetPositionInfo(reader);
_namespaceManager = reader.NamespaceManager;
if (_namespaceManager == null)
{
_namespaceManager = new XmlNamespaceManager(_nameTable);
_isProcessNamespaces = true;
}
else
{
_isProcessNamespaces = false;
}
while (reader.NodeType != XmlNodeType.Element && await reader.ReadAsync().ConfigureAwait(false)) { }
_markupDepth = int.MaxValue;
_schemaXmlDepth = reader.Depth;
SchemaType rootType = _schemaNames.SchemaTypeFromRoot(reader.LocalName, reader.NamespaceURI);
string code;
if (!CheckSchemaRoot(rootType, out code))
{
throw new XmlSchemaException(code, reader.BaseURI, _positionInfo.LineNumber, _positionInfo.LinePosition);
}
if (_schemaType == SchemaType.XSD)
{
_schema = new XmlSchema();
_schema.BaseUri = new Uri(reader.BaseURI, UriKind.RelativeOrAbsolute);
_builder = new XsdBuilder(reader, _namespaceManager, _schema, _nameTable, _schemaNames, _eventHandler);
}
else
{
Debug.Assert(_schemaType == SchemaType.XDR);
_xdrSchema = new SchemaInfo();
_xdrSchema.SchemaType = SchemaType.XDR;
_builder = new XdrBuilder(reader, _namespaceManager, _xdrSchema, targetNamespace, _nameTable, _schemaNames, _eventHandler);
((XdrBuilder)_builder).XmlResolver = _xmlResolver;
}
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public virtual bool CanDeserialize(XmlReader xmlReader)
{
if (_primitiveType != null)
{
TypeDesc typeDesc = (TypeDesc)TypeScope.PrimtiveTypes[_primitiveType];
return xmlReader.IsStartElement(typeDesc.DataType.Name, string.Empty);
}
#if !NET_NATIVE
else if (_tempAssembly != null)
{
return _tempAssembly.CanRead(_mapping, xmlReader);
}
else
{
return false;
}
#else
if (this.innerSerializer != null)
{
return this.innerSerializer.CanDeserialize(xmlReader);
}
else
{
return ReflectionMethodEnabled;
}
#endif
}
internal object Deserialize(XmlReader xmlReader, string encodingStyle, XmlDeserializationEvents events)
{
try
{
if (_primitiveType != null)
{
return DeserializePrimitive(xmlReader, events);
}
#if !NET_NATIVE
else if (Mode == SerializationMode.ReflectionOnly)
{
XmlMapping mapping;
if (_mapping.GenerateSerializer)
{
mapping = _mapping;
}
else
{
XmlReflectionImporter importer = new XmlReflectionImporter(DefaultNamespace);
mapping = importer.ImportTypeMapping(rootType, null, DefaultNamespace);
}
var reader = new ReflectionXmlSerializationReader(mapping, xmlReader, events, encodingStyle);
return reader.ReadObject();
}
else if (_tempAssembly == null || _typedSerializer)
{
XmlSerializationReader reader = CreateReader();
reader.Init(xmlReader, events, encodingStyle, _tempAssembly);
try
{
return Deserialize(reader);
}
finally
{
reader.Dispose();
}
}
else
{
return _tempAssembly.InvokeReader(_mapping, xmlReader, events, encodingStyle);
}
#else
else
{
if (this.innerSerializer != null)
{
if (!string.IsNullOrEmpty(this.DefaultNamespace))
{
this.innerSerializer.DefaultNamespace = this.DefaultNamespace;
}
XmlSerializationReader reader = this.innerSerializer.CreateReader();
reader.Init(xmlReader, encodingStyle);
try
{
return this.innerSerializer.Deserialize(reader);
}
finally
{
reader.Dispose();
}
}
else if (ReflectionMethodEnabled)
{
XmlMapping mapping;
if (_mapping != null && _mapping.GenerateSerializer)
{
mapping = _mapping;
}
else
{
XmlReflectionImporter importer = new XmlReflectionImporter(DefaultNamespace);
mapping = importer.ImportTypeMapping(rootType, null, DefaultNamespace);
}
var reader = new ReflectionXmlSerializationReader(mapping, xmlReader, events, encodingStyle);
return reader.ReadObject();
}
else
{
throw new InvalidOperationException(SR.Format(SR.Xml_MissingSerializationCodeException, this.rootType, typeof(XmlSerializer).Name));
}
}
#endif
}
catch (Exception e)
{
if (e is TargetInvocationException)
e = e.InnerException;
if (xmlReader is IXmlLineInfo)
{
IXmlLineInfo lineInfo = (IXmlLineInfo)xmlReader;
throw new InvalidOperationException(SR.Format(SR.XmlSerializeErrorDetails, lineInfo.LineNumber.ToString(CultureInfo.InvariantCulture), lineInfo.LinePosition.ToString(CultureInfo.InvariantCulture)), e);
}
else
{
throw new InvalidOperationException(SR.XmlSerializeError, e);
}
}
}
internal object Deserialize(XmlReader xmlReader, string encodingStyle)
{
return Deserialize(xmlReader, encodingStyle, _events);
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public object Deserialize(XmlReader xmlReader)
{
return Deserialize(xmlReader, null);
}
/// <summary>
/// Executes the query by accessing datasources via the XmlResolver and using run-time parameters
/// as provided by the XsltArgumentList. The default document is mapped into the XmlResolver with the
/// provided name. The results are output to the provided Stream.
/// </summary>
public override void Execute(XmlReader contextDocument, XmlResolver dataSources, XsltArgumentList argumentList, Stream results) {
if (results == null)
throw new ArgumentNullException(nameof(results));
Execute(contextDocument, dataSources, argumentList, XmlWriter.Create(results, this.staticData.DefaultWriterSettings), true);
}
/// <summary>
/// Executes the query by accessing datasources via the XmlResolver and using run-time parameters
/// as provided by the XsltArgumentList. The default document is mapped into the XmlResolver with the
/// provided name. The results are output to the provided XmlWriter.
/// </summary>
public override void Execute(XmlReader contextDocument, XmlResolver dataSources, XsltArgumentList argumentList, XmlWriter results) {
if (results == null)
throw new ArgumentNullException(nameof(results));
Execute(contextDocument, dataSources, argumentList, results, false);
}
private XmlReader NestRead(XmlReader r)
{
r.Read();
r.Read();
if (!(r.Name == "elem0" && r.NodeType == XmlNodeType.Element))
{
CError.WriteLine(r.Name);
NestRead(r.ReadSubtree());
}
r.Dispose();
return r;
}
private object DeserializePrimitive(XmlReader xmlReader, XmlDeserializationEvents events)
{
XmlSerializationPrimitiveReader reader = new XmlSerializationPrimitiveReader();
reader.Init(xmlReader, events, null, null);
object o;
switch (_primitiveType.GetTypeCode())
{
case TypeCode.String:
o = reader.Read_string();
break;
case TypeCode.Int32:
o = reader.Read_int();
break;
case TypeCode.Boolean:
o = reader.Read_boolean();
break;
case TypeCode.Int16:
o = reader.Read_short();
break;
case TypeCode.Int64:
o = reader.Read_long();
break;
case TypeCode.Single:
o = reader.Read_float();
break;
case TypeCode.Double:
o = reader.Read_double();
break;
case TypeCode.Decimal:
o = reader.Read_decimal();
break;
case TypeCode.DateTime:
o = reader.Read_dateTime();
break;
case TypeCode.Char:
o = reader.Read_char();
break;
case TypeCode.Byte:
o = reader.Read_unsignedByte();
break;
case TypeCode.SByte:
o = reader.Read_byte();
break;
case TypeCode.UInt16:
o = reader.Read_unsignedShort();
break;
case TypeCode.UInt32:
o = reader.Read_unsignedInt();
break;
case TypeCode.UInt64:
o = reader.Read_unsignedLong();
break;
default:
if (_primitiveType == typeof(XmlQualifiedName))
{
o = reader.Read_QName();
}
else if (_primitiveType == typeof(byte[]))
{
o = reader.Read_base64Binary();
}
else if (_primitiveType == typeof(Guid))
{
o = reader.Read_guid();
}
else if (_primitiveType == typeof(TimeSpan))
{
o = reader.Read_TimeSpan();
}
else
{
throw new InvalidOperationException(SR.Format(SR.XmlUnxpectedType, _primitiveType.FullName));
}
break;
}
return o;
}
/// <summary>
/// This method will test the read based on different settings.
/// It will call the correct overload and set the state properly.
/// </summary>
protected override void Test()
{
CError.WriteLine("Testing : " + TestFileName);
string tempStr = null;
switch (_overload)
{
case ReaderOverload.StreamReader:
_textReader = new StreamReader(FilePathUtil.getStream(GetFile(TestFileName)));
CreateReader(ReadThru.TextReader);
break;
case ReaderOverload.StringReader:
StreamReader sr = new StreamReader(FilePathUtil.getStream(GetFile(TestFileName)));
tempStr = sr.ReadToEnd();
sr.Dispose();
_textReader = new StringReader(tempStr);
CreateReader(ReadThru.TextReader);
break;
case ReaderOverload.FileStream:
_stream = FilePathUtil.getStream(TestFileName);
CreateReader(ReadThru.Stream);
break;
case ReaderOverload.MemoryStream:
StreamReader sr1 = new StreamReader(FilePathUtil.getStream(GetFile(TestFileName)));
tempStr = sr1.ReadToEnd();
sr1.Dispose();
byte[] bits = _enc.GetBytes(tempStr);
_stream = new MemoryStream(bits);
CreateReader(ReadThru.Stream);
break;
case ReaderOverload.CoreReader:
_underlyingSettings.DtdProcessing = DtdProcessing.Ignore;
_underlyingSettings.ConformanceLevel = _settings.ConformanceLevel;
StringReader strr = new StringReader(new StreamReader(FilePathUtil.getStream(GetFile(TestFileName))).ReadToEnd());
_underlyingReader = ReaderHelper.CreateReader(_overload.ToString(),
strr,
false,
null,
_underlyingSettings,
(_settings.ConformanceLevel == ConformanceLevel.Fragment)); //should this be settings or underlyingSettings?
CError.Compare(_underlyingReader != null, "ReaderHelper returned null Reader");
CreateReader(ReadThru.XmlReader);
break;
case ReaderOverload.CustomReader:
if (AsyncUtil.IsAsyncEnabled)
{
pstate = TestState.Skip;
return;
}
if (_settings.ConformanceLevel != ConformanceLevel.Fragment)
_underlyingReader = new CustomReader(FilePathUtil.getStream(GetFile(TestFileName)), false);
else
_underlyingReader = new CustomReader(FilePathUtil.getStream(GetFile(TestFileName)), true);
CError.Compare(_underlyingReader != null, "ReaderHelper returned null Reader");
CreateReader(ReadThru.XmlReader);
break;
default:
throw new CTestFailedException("Unknown ReaderOverload: " + _overload);
}
if (_underlyingReader != null)
CError.WriteLineIgnore("Type of Reader : " + _underlyingReader.GetType());
if (pstate == TestState.Pass) return;
CError.Compare(pstate, TestState.CreateSuccess, "Invalid State after Create: " + pstate);
//By this time the factory Reader is already set up correctly. So we must go Consume it now.
CError.Compare(pstate != TestState.Pass && pstate == TestState.CreateSuccess, "Invalid state before Consuming Reader: " + pstate);
//Call TestReader to Consume Reader;
TestReader();
if (pstate == TestState.Pass) return;
CError.Compare(pstate != TestState.Pass && pstate == TestState.Consume, "Invalid state after Consuming Reader: " + pstate);
}
/// <summary>
/// This method calls the Create Method on the XmlReader and puts the state in CreateSuccess or TestPass.
/// It goes in PASS also if the reader threw an expected error. In all other cases it should throw
/// TestFailedException.
/// </summary>
/// <param name="readThru">This param determines which overload to call.
/// In future on multiple overloads we can make this param
/// an enum which can be set using the spec file data</param>
protected void CreateReader(ReadThru readThru)
{
//Assumption is that the Create method doesnt throw NullReferenceException and
//it is not the goal of this framework to test if they are thrown anywhere.
//but if they are thrown thats a problem and they shouldnt be caught but exposed.
try
{
switch (readThru)
{
case ReadThru.TextReader:
_factoryReader = ReaderHelper.Create(_textReader, _settings, _baseUri);
break;
case ReadThru.XmlReader:
_factoryReader = ReaderHelper.Create(_underlyingReader, _settings);
break;
case ReadThru.Stream:
_factoryReader = ReaderHelper.Create(_stream, _settings);
break;
default:
throw new CTestFailedException("Unknown ReadThru type: " + readThru);
}
pstate = TestState.CreateSuccess;
}
catch (ArgumentNullException ane)
{
Log(ane.Message);
Log(ane.StackTrace);
if (!IsVariationValid)
{
if (!CheckException(ane))
{
pstate = TestState.Error;
DumpVariationInfo();
throw new CTestFailedException(
"Argument Null Exception Thrown in CreateMethod, is your variation data correct?");
}
else
{
//This means that the Exception was checked and everything is fine.
pstate = TestState.Pass;
}
}
else
{
pstate = TestState.Error;
DumpVariationInfo();
throw new CTestFailedException(
"Argument Null Exception Thrown in CreateMethod, is your variation data correct?");
}
}
}
/// <summary>
/// Executes the query by accessing datasources via the XmlResolver and using
/// run-time parameters as provided by the XsltArgumentList. The default document
/// is mapped into the XmlResolver with the provided name. The results are returned
/// as an IList.
/// </summary>
public override IList Evaluate(XmlReader contextDocument, XmlResolver dataSources, XsltArgumentList argumentList) {
XmlCachedSequenceWriter seqwrt = new XmlCachedSequenceWriter();
Execute(contextDocument, dataSources, argumentList, seqwrt);
return seqwrt.ResultSequence;
}
/// <devdoc> /// <para> /// Executes the query by accessing datasources via the XmlResolver and using /// run-time parameters as provided by the XsltArgumentList. The default document /// is mapped into the XmlResolver with the provided name. The results are returned /// as an IList. /// </para> /// </devdoc> public abstract IList Evaluate(XmlReader contextDocument, XmlResolver dataSources, XsltArgumentList argumentList);
protected void ConsumeReader(XmlReader reader)
{
while (reader.Read())
{
string x = reader.Name + reader.NodeType + reader.Value;
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.HasAttributes)
{
reader.MoveToFirstAttribute();
int index = 0;
reader.MoveToAttribute(index);
index++;
while (reader.MoveToNextAttribute())
{
string name = reader.Name;
string value;
value = reader.GetAttribute(index);
value = reader.GetAttribute(name);
value = reader.GetAttribute(name, null);
reader.ReadAttributeValue();
reader.MoveToAttribute(index);
reader.MoveToAttribute(name, null);
index++;
}
}
}
if (reader.NodeType == XmlNodeType.EndElement)
{
reader.Skip();
}
}
}
internal XsdBuilder(
XmlReader reader,
XmlNamespaceManager curmgr,
XmlSchema schema,
XmlNameTable nameTable,
SchemaNames schemaNames,
ValidationEventHandler eventhandler
) {
this.reader = reader;
this.xso = this.schema = schema;
this.namespaceManager = new BuilderNamespaceManager(curmgr, reader);
this.validationEventHandler = eventhandler;
this.nameTable = nameTable;
this.schemaNames = schemaNames;
this.stateHistory = new HWStack(STACK_INCREMENT);
this.currentEntry = SchemaEntries[0];
positionInfo = PositionInfo.GetPositionInfo(reader);
}
public BuilderNamespaceManager(XmlNamespaceManager nsMgr, XmlReader reader) {
this.nsMgr = nsMgr;
this.reader = reader;
}
public SchemaType Parse(XmlReader reader, string targetNamespace)
{
StartParsing(reader, targetNamespace);
while (ParseReaderNode() && reader.Read()) { }
return FinishParsing();
}
/// <devdoc> /// <para> /// Executes the query by accessing datasources via the XmlResolver and using /// run-time parameters as provided by the XsltArgumentList. The default document /// is mapped into the XmlResolver with the provided name. The results are output /// to the provided Stream. /// </para> /// </devdoc> public abstract void Execute(XmlReader contextDocument, XmlResolver dataSources, XsltArgumentList argumentList, Stream results);
internal XdrBuilder(
XmlReader reader,
XmlNamespaceManager curmgr,
SchemaInfo sinfo,
string targetNamspace,
XmlNameTable nameTable,
SchemaNames schemaNames,
ValidationEventHandler eventhandler
)
{
_SchemaInfo = sinfo;
_TargetNamespace = targetNamspace;
_reader = reader;
_CurNsMgr = curmgr;
_validationEventHandler = eventhandler;
_StateHistory = new HWStack(StackIncrement);
_ElementDef = new ElementContent();
_AttributeDef = new AttributeContent();
_GroupStack = new HWStack(StackIncrement);
_GroupDef = new GroupContent();
_NameTable = nameTable;
_SchemaNames = schemaNames;
_CurState = s_schemaEntries[0];
_positionInfo = PositionInfo.GetPositionInfo(_reader);
_xmlResolver = null;
}
