File: FrameworkFork\Microsoft.Xml\Xml\Core\XmlTextReaderImplHelpers.cs
Web Access
Project: src\src\dotnet-svcutil\lib\src\dotnet-svcutil-lib.csproj (dotnet-svcutil-lib)
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
 
 
using System;
using System.IO;
using System.Text;
using System.Security;
using Microsoft.Xml.Schema;
using System.Collections;
using System.Diagnostics;
using System.Globalization;
using System.Collections.Generic;
using System.Runtime.Versioning;
 
using BufferBuilder = System.Text.StringBuilder;
 
namespace Microsoft.Xml
{
    using System;
 
 
    internal partial class XmlTextReaderImpl
    {
        //
        // ParsingState
        //
        // Parsing state (aka. scanner data) - holds parsing buffer and entity input data information
        private struct ParsingState
        {
            // character buffer
            internal char[] chars;
            internal int charPos;
            internal int charsUsed;
            internal Encoding encoding;
            internal bool appendMode;
 
            // input stream & byte buffer
            internal Stream stream;
            internal Decoder decoder;
            internal byte[] bytes;
            internal int bytePos;
            internal int bytesUsed;
 
            // input text reader
            internal TextReader textReader;
 
            // current line number & position
            internal int lineNo;
            internal int lineStartPos;
 
            // base uri of the current entity
            internal string baseUriStr;
            internal Uri baseUri;
 
            // eof flag of the entity
            internal bool isEof;
            internal bool isStreamEof;
 
            // entity type & id
            internal IDtdEntityInfo entity;
            internal int entityId;
 
            // normalization
            internal bool eolNormalized;
 
            // EndEntity reporting
            internal bool entityResolvedManually;
 
            internal void Clear()
            {
                chars = null;
                charPos = 0;
                charsUsed = 0;
                encoding = null;
                stream = null;
                decoder = null;
                bytes = null;
                bytePos = 0;
                bytesUsed = 0;
                textReader = null;
                lineNo = 1;
                lineStartPos = -1;
                baseUriStr = string.Empty;
                baseUri = null;
                isEof = false;
                isStreamEof = false;
                eolNormalized = true;
                entityResolvedManually = false;
            }
 
            internal void Close(bool closeInput)
            {
                if (closeInput)
                {
                    if (stream != null)
                    {
                        stream.Close();
                    }
                    else if (textReader != null)
                    {
                        textReader.Dispose();
                    }
                }
            }
 
            internal int LineNo
            {
                get
                {
                    return lineNo;
                }
            }
 
            internal int LinePos
            {
                get
                {
                    return charPos - lineStartPos;
                }
            }
        }
 
        //
        // XmlContext
        //
        private class XmlContext
        {
            internal XmlSpace xmlSpace;
            internal string xmlLang;
            internal string defaultNamespace;
            internal XmlContext previousContext;
 
            internal XmlContext()
            {
                xmlSpace = XmlSpace.None;
                xmlLang = string.Empty;
                defaultNamespace = string.Empty;
                previousContext = null;
            }
 
            internal XmlContext(XmlContext previousContext)
            {
                this.xmlSpace = previousContext.xmlSpace;
                this.xmlLang = previousContext.xmlLang;
                this.defaultNamespace = previousContext.defaultNamespace;
                this.previousContext = previousContext;
            }
        }
 
        //
        // NoNamespaceManager
        //
        private class NoNamespaceManager : XmlNamespaceManager
        {
            public NoNamespaceManager() : base() { }
            public override string DefaultNamespace { get { return string.Empty; } }
            public override void PushScope() { }
            public override bool PopScope() { return false; }
            public override void AddNamespace(string prefix, string uri) { }
            public override void RemoveNamespace(string prefix, string uri) { }
            public override IEnumerator GetEnumerator() { return null; }
            public override IDictionary<string, string> GetNamespacesInScope(XmlNamespaceScope scope) { return null; }
            public override string LookupNamespace(string prefix) { return string.Empty; }
            public override string LookupPrefix(string uri) { return null; }
            public override bool HasNamespace(string prefix) { return false; }
        }
 
        //
        // DtdParserProxy: IDtdParserAdapter proxy for XmlTextReaderImpl
        //
        internal partial class DtdParserProxy : IDtdParserAdapterV1
        {
 
            // Fields
            private XmlTextReaderImpl _reader;
 
            // Constructors
            internal DtdParserProxy(XmlTextReaderImpl reader)
            {
                _reader = reader;
            }
 
            // IDtdParserAdapter proxies
            XmlNameTable IDtdParserAdapter.NameTable
            {
                get { return _reader.DtdParserProxy_NameTable; }
            }
 
            IXmlNamespaceResolver IDtdParserAdapter.NamespaceResolver
            {
                get { return _reader.DtdParserProxy_NamespaceResolver; }
            }
 
            Uri IDtdParserAdapter.BaseUri
            {
                // SxS: DtdParserProxy_BaseUri property on the reader may expose machine scope resources. This property
                // is just returning the value of the other property, so it may expose machine scope resource as well.
                // [ResourceConsumption(ResourceScope.Machine)]
                // [ResourceExposure(ResourceScope.Machine)]
                get { return _reader.DtdParserProxy_BaseUri; }
            }
 
            bool IDtdParserAdapter.IsEof
            {
                get { return _reader.DtdParserProxy_IsEof; }
            }
 
            char[] IDtdParserAdapter.ParsingBuffer
            {
                get { return _reader.DtdParserProxy_ParsingBuffer; }
            }
 
            int IDtdParserAdapter.ParsingBufferLength
            {
                get { return _reader.DtdParserProxy_ParsingBufferLength; }
            }
 
            int IDtdParserAdapter.CurrentPosition
            {
                get { return _reader.DtdParserProxy_CurrentPosition; }
                set { _reader.DtdParserProxy_CurrentPosition = value; }
            }
 
            int IDtdParserAdapter.EntityStackLength
            {
                get { return _reader.DtdParserProxy_EntityStackLength; }
            }
 
            bool IDtdParserAdapter.IsEntityEolNormalized
            {
                get { return _reader.DtdParserProxy_IsEntityEolNormalized; }
            }
 
            void IDtdParserAdapter.OnNewLine(int pos)
            {
                _reader.DtdParserProxy_OnNewLine(pos);
            }
 
            int IDtdParserAdapter.LineNo
            {
                get { return _reader.DtdParserProxy_LineNo; }
            }
 
            int IDtdParserAdapter.LineStartPosition
            {
                get { return _reader.DtdParserProxy_LineStartPosition; }
            }
 
            int IDtdParserAdapter.ReadData()
            {
                return _reader.DtdParserProxy_ReadData();
            }
 
            int IDtdParserAdapter.ParseNumericCharRef(BufferBuilder internalSubsetBuilder)
            {
                return _reader.DtdParserProxy_ParseNumericCharRef(internalSubsetBuilder);
            }
 
            int IDtdParserAdapter.ParseNamedCharRef(bool expand, BufferBuilder internalSubsetBuilder)
            {
                return _reader.DtdParserProxy_ParseNamedCharRef(expand, internalSubsetBuilder);
            }
 
            void IDtdParserAdapter.ParsePI(BufferBuilder sb)
            {
                _reader.DtdParserProxy_ParsePI(sb);
            }
 
            void IDtdParserAdapter.ParseComment(BufferBuilder sb)
            {
                _reader.DtdParserProxy_ParseComment(sb);
            }
 
            bool IDtdParserAdapter.PushEntity(IDtdEntityInfo entity, out int entityId)
            {
                return _reader.DtdParserProxy_PushEntity(entity, out entityId);
            }
 
            bool IDtdParserAdapter.PopEntity(out IDtdEntityInfo oldEntity, out int newEntityId)
            {
                return _reader.DtdParserProxy_PopEntity(out oldEntity, out newEntityId);
            }
 
            bool IDtdParserAdapter.PushExternalSubset(string systemId, string publicId)
            {
                return _reader.DtdParserProxy_PushExternalSubset(systemId, publicId);
            }
 
            void IDtdParserAdapter.PushInternalDtd(string baseUri, string internalDtd)
            {
                Debug.Assert(internalDtd != null);
                _reader.DtdParserProxy_PushInternalDtd(baseUri, internalDtd);
            }
 
            void IDtdParserAdapter.Throw(Exception e)
            {
                _reader.DtdParserProxy_Throw(e);
            }
 
            void IDtdParserAdapter.OnSystemId(string systemId, LineInfo keywordLineInfo, LineInfo systemLiteralLineInfo)
            {
                _reader.DtdParserProxy_OnSystemId(systemId, keywordLineInfo, systemLiteralLineInfo);
            }
 
            void IDtdParserAdapter.OnPublicId(string publicId, LineInfo keywordLineInfo, LineInfo publicLiteralLineInfo)
            {
                _reader.DtdParserProxy_OnPublicId(publicId, keywordLineInfo, publicLiteralLineInfo);
            }
 
            bool IDtdParserAdapterWithValidation.DtdValidation
            {
                get { return _reader.DtdParserProxy_DtdValidation; }
            }
 
            IValidationEventHandling IDtdParserAdapterWithValidation.ValidationEventHandling
            {
                get { return _reader.DtdParserProxy_ValidationEventHandling; }
            }
 
            bool IDtdParserAdapterV1.Normalization
            {
                get { return _reader.DtdParserProxy_Normalization; }
            }
 
            bool IDtdParserAdapterV1.Namespaces
            {
                get { return _reader.DtdParserProxy_Namespaces; }
            }
 
            bool IDtdParserAdapterV1.V1CompatibilityMode
            {
                get { return _reader.DtdParserProxy_V1CompatibilityMode; }
            }
 
        }
 
        //
        // NodeData
        //
        private class NodeData : IComparable
        {
            // static instance with no data - is used when XmlTextReader is closed
            private static volatile NodeData s_None;
 
            // NOTE: Do not use this property for reference comparison. It may not be unique.
            internal static NodeData None
            {
                get
                {
                    if (s_None == null)
                    {
                        // no locking; s_None is immutable so it's not a problem that it may get initialized more than once
                        s_None = new NodeData();
                    }
                    return s_None;
                }
            }
 
            // type
            internal XmlNodeType type;
 
            // name
            internal string localName;
            internal string prefix;
            internal string ns;
            internal string nameWPrefix;
 
            // value:
            // value == null -> the value is kept in the 'chars' buffer starting at valueStartPos and valueLength long
            private string _value;
            private char[] _chars;
            private int _valueStartPos;
            private int _valueLength;
 
            // main line info
            internal LineInfo lineInfo;
 
            // second line info
            internal LineInfo lineInfo2;
 
            // quote char for attributes
            internal char quoteChar;
 
            // depth
            internal int depth;
 
            // empty element / default attribute
            private bool _isEmptyOrDefault;
 
            // entity id
            internal int entityId;
 
            // helper members
            internal bool xmlContextPushed;
 
            // attribute value chunks
            internal NodeData nextAttrValueChunk;
 
            // type info
            internal object schemaType;
            internal object typedValue;
 
            internal NodeData()
            {
                Clear(XmlNodeType.None);
                xmlContextPushed = false;
            }
 
            internal int LineNo
            {
                get
                {
                    return lineInfo.lineNo;
                }
            }
 
            internal int LinePos
            {
                get
                {
                    return lineInfo.linePos;
                }
            }
 
            internal bool IsEmptyElement
            {
                get
                {
                    return type == XmlNodeType.Element && _isEmptyOrDefault;
                }
                set
                {
                    Debug.Assert(type == XmlNodeType.Element);
                    _isEmptyOrDefault = value;
                }
            }
 
            internal bool IsDefaultAttribute
            {
                get
                {
                    return type == XmlNodeType.Attribute && _isEmptyOrDefault;
                }
                set
                {
                    Debug.Assert(type == XmlNodeType.Attribute);
                    _isEmptyOrDefault = value;
                }
            }
 
            internal bool ValueBuffered
            {
                get
                {
                    return _value == null;
                }
            }
 
            internal string StringValue
            {
                get
                {
                    Debug.Assert(_valueStartPos >= 0 || _value != null, "Value not ready.");
 
                    if (_value == null)
                    {
                        _value = new string(_chars, _valueStartPos, _valueLength);
                    }
                    return _value;
                }
            }
 
            internal void TrimSpacesInValue()
            {
                if (ValueBuffered)
                {
                    XmlTextReaderImpl.StripSpaces(_chars, _valueStartPos, ref _valueLength);
                }
                else
                {
                    _value = XmlTextReaderImpl.StripSpaces(_value);
                }
            }
 
            internal void Clear(XmlNodeType type)
            {
                this.type = type;
                ClearName();
                _value = string.Empty;
                _valueStartPos = -1;
                nameWPrefix = string.Empty;
                schemaType = null;
                typedValue = null;
            }
 
            internal void ClearName()
            {
                localName = string.Empty;
                prefix = string.Empty;
                ns = string.Empty;
                nameWPrefix = string.Empty;
            }
 
            internal void SetLineInfo(int lineNo, int linePos)
            {
                lineInfo.Set(lineNo, linePos);
            }
 
            internal void SetLineInfo2(int lineNo, int linePos)
            {
                lineInfo2.Set(lineNo, linePos);
            }
 
            internal void SetValueNode(XmlNodeType type, string value)
            {
                Debug.Assert(value != null);
 
                this.type = type;
                ClearName();
                _value = value;
                _valueStartPos = -1;
            }
 
            internal void SetValueNode(XmlNodeType type, char[] chars, int startPos, int len)
            {
                this.type = type;
                ClearName();
 
                _value = null;
                _chars = chars;
                _valueStartPos = startPos;
                _valueLength = len;
            }
 
            internal void SetNamedNode(XmlNodeType type, string localName)
            {
                SetNamedNode(type, localName, string.Empty, localName);
            }
 
            internal void SetNamedNode(XmlNodeType type, string localName, string prefix, string nameWPrefix)
            {
                Debug.Assert(localName != null);
                Debug.Assert(localName.Length > 0);
 
                this.type = type;
                this.localName = localName;
                this.prefix = prefix;
                this.nameWPrefix = nameWPrefix;
                this.ns = string.Empty;
                _value = string.Empty;
                _valueStartPos = -1;
            }
 
            internal void SetValue(string value)
            {
                _valueStartPos = -1;
                _value = value;
            }
 
            internal void SetValue(char[] chars, int startPos, int len)
            {
                _value = null;
                _chars = chars;
                _valueStartPos = startPos;
                _valueLength = len;
            }
 
            internal void OnBufferInvalidated()
            {
                if (_value == null)
                {
                    Debug.Assert(_valueStartPos != -1);
                    Debug.Assert(_chars != null);
                    _value = new string(_chars, _valueStartPos, _valueLength);
                }
                _valueStartPos = -1;
            }
 
            internal void CopyTo(int valueOffset, BufferBuilder sb)
            {
                if (_value == null)
                {
                    Debug.Assert(_valueStartPos != -1);
                    Debug.Assert(_chars != null);
                    sb.Append(_chars, _valueStartPos + valueOffset, _valueLength - valueOffset);
                }
                else
                {
                    if (valueOffset <= 0)
                    {
                        sb.Append(_value);
                    }
                    else
                    {
                        sb.Append(_value, valueOffset, _value.Length - valueOffset);
                    }
                }
            }
 
            internal int CopyTo(int valueOffset, char[] buffer, int offset, int length)
            {
                if (_value == null)
                {
                    Debug.Assert(_valueStartPos != -1);
                    Debug.Assert(_chars != null);
                    int copyCount = _valueLength - valueOffset;
                    if (copyCount > length)
                    {
                        copyCount = length;
                    }
                    XmlTextReaderImpl.BlockCopyChars(_chars, _valueStartPos + valueOffset, buffer, offset, copyCount);
                    return copyCount;
                }
                else
                {
                    int copyCount = _value.Length - valueOffset;
                    if (copyCount > length)
                    {
                        copyCount = length;
                    }
                    _value.CopyTo(valueOffset, buffer, offset, copyCount);
                    return copyCount;
                }
            }
 
            internal int CopyToBinary(IncrementalReadDecoder decoder, int valueOffset)
            {
                if (_value == null)
                {
                    Debug.Assert(_valueStartPos != -1);
                    Debug.Assert(_chars != null);
                    return decoder.Decode(_chars, _valueStartPos + valueOffset, _valueLength - valueOffset);
                }
                else
                {
                    return decoder.Decode(_value, valueOffset, _value.Length - valueOffset);
                }
            }
 
            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);
                }
            }
 
            // This should be inlined by JIT compiler
            internal string GetNameWPrefix(XmlNameTable nt)
            {
                if (nameWPrefix != null)
                {
                    return nameWPrefix;
                }
                else
                {
                    return CreateNameWPrefix(nt);
                }
            }
 
            internal string CreateNameWPrefix(XmlNameTable nt)
            {
                Debug.Assert(nameWPrefix == null);
                if (prefix.Length == 0)
                {
                    nameWPrefix = localName;
                }
                else
                {
                    nameWPrefix = nt.Add(string.Concat(prefix, ":", localName));
                }
                return nameWPrefix;
            }
 
            int IComparable.CompareTo(object obj)
            {
                NodeData other = obj as NodeData;
                if (other != null)
                {
                    if (Ref.Equal(localName, other.localName))
                    {
                        if (Ref.Equal(ns, other.ns))
                        {
                            return 0;
                        }
                        else
                        {
                            return string.CompareOrdinal(ns, other.ns);
                        }
                    }
                    else
                    {
                        return string.CompareOrdinal(localName, other.localName);
                    }
                }
                else
                {
                    Debug.Assert(false, "We should never get to this point.");
                    // 'other' is null, 'this' is not null. Always return 1, like "".CompareTo(null).
                    return 1;
                }
            }
        }
 
        // 
        // DtdDefaultAttributeInfoToNodeDataComparer
        // 
        // Compares IDtdDefaultAttributeInfo to NodeData
        private class DtdDefaultAttributeInfoToNodeDataComparer : IComparer<object>
        {
            private static IComparer<object> s_instance = new DtdDefaultAttributeInfoToNodeDataComparer();
 
            internal static IComparer<object> Instance
            {
                get { return s_instance; }
            }
 
            public int Compare(object x, object y)
            {
                Debug.Assert(x == null || x is NodeData || x is IDtdDefaultAttributeInfo);
                Debug.Assert(y == null || y is NodeData || y is IDtdDefaultAttributeInfo);
 
                string localName, localName2;
                string prefix, prefix2;
 
                if (x == null)
                {
                    return y == null ? 0 : -1;
                }
                else if (y == null)
                {
                    return 1;
                }
 
                NodeData nodeData = x as NodeData;
                if (nodeData != null)
                {
                    localName = nodeData.localName;
                    prefix = nodeData.prefix;
                }
                else
                {
                    IDtdDefaultAttributeInfo attrDef = x as IDtdDefaultAttributeInfo;
                    if (attrDef != null)
                    {
                        localName = attrDef.LocalName;
                        prefix = attrDef.Prefix;
                    }
                    else
                    {
                        throw new XmlException(ResXml.Xml_DefaultException, string.Empty);
                    }
                }
 
                nodeData = y as NodeData;
                if (nodeData != null)
                {
                    localName2 = nodeData.localName;
                    prefix2 = nodeData.prefix;
                }
                else
                {
                    IDtdDefaultAttributeInfo attrDef = y as IDtdDefaultAttributeInfo;
                    if (attrDef != null)
                    {
                        localName2 = attrDef.LocalName;
                        prefix2 = attrDef.Prefix;
                    }
                    else
                    {
                        throw new XmlException(ResXml.Xml_DefaultException, string.Empty);
                    }
                }
 
                // string.Compare does reference euqality first for us, so we don't have to do it here
                int result = string.Compare(localName, localName2, StringComparison.Ordinal);
                if (result != 0)
                {
                    return result;
                }
 
                return string.Compare(prefix, prefix2, StringComparison.Ordinal);
            }
        }
 
        //
        // OnDefaultAttributeUse delegate
        //
        internal delegate void OnDefaultAttributeUseDelegate(IDtdDefaultAttributeInfo defaultAttribute, XmlTextReaderImpl coreReader);
 
    }
}