//------------------------------------------------------------------------------
// <copyright file="XmlQueryOutput.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
// <owner current="true" primary="true">Microsoft</owner>
//------------------------------------------------------------------------------
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.Xml;
using System.Xml.XPath;

namespace System.Xml.Xsl.Runtime {
    using Res = System.Xml.Utils.Res;

    internal enum XmlState {
        WithinSequence = 0,     // Adding items to a top-level sequence
        EnumAttrs,              // Adding attributes to an element
        WithinContent,          // Adding content to an element
        WithinAttr,             // Adding text to an attribute
        WithinNmsp,             // Adding text to an namespace
        WithinComment,          // Adding text to a comment
        WithinPI,               // Adding text to a processing instruction
    };


    /// <summary>
    /// At run-time, a number of checks may need to be made in order to generate the correct sequence of calls
    /// to XmlRawWriter:
    ///   1. Well-formedness: Illegal state transitions, StartContent detection, no-content element detection
    ///   2. Cached attributes: In XSLT, attributes override previously constructed attributes with the same name,
    ///      meaning that attribute names and values cannot be prematurely sent to XmlRawWriter.
    ///   3. Cached namespaces: All namespaces are tracked in order to ensure adequate namespaces and to ensure
    ///      minimal (or something close) namespaces.
    /// </summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class XmlQueryOutput : XmlWriter {
        // Never set these fields directly--instead use corresponding properties
        private XmlRawWriter xwrt;                  // Output to XmlRawWriter--get and set this using the Writer property

        // It is OK to set these properties directly
        private XmlQueryRuntime runtime;            // The XmlQueryRuntime instance that keeps global state
        private XmlAttributeCache attrCache;        // Cache used to detect duplicate attributes
        private int depth;                          // Depth of the currently constructing tree
        private XmlState xstate;                    // Current XML state
        private XmlSequenceWriter seqwrt;           // Current XmlSequenceWriter
        private XmlNamespaceManager nsmgr;          // Output namespace manager
        private int cntNmsp;                        // Number of pending namespaces
        private Dictionary<string, string> conflictPrefixes;         // Remembers prefixes that were auto-generated previously in case they can be reused
        private int prefixIndex;                    // Counter used to auto-generate non-conflicting attribute prefixes
        private string piTarget/*nmspPrefix*/;      // Cache pi target or namespace prefix
        private StringConcat nodeText;              // Cache pi, comment, or namespace text
        private Stack<string> stkNames;             // Keep stack of name parts computed during StartElement
        private XPathNodeType rootType;             // NodeType of the root of the tree

        private Dictionary<string, string> usedPrefixes = new Dictionary<string, string>(); //The prefies that used in the current scope

        /// <summary>
        /// This constructor is internal so that external users cannot construct it (and therefore we do not have to test it separately).
        /// Initialize output state to accept top-level sequences.
        /// </summary>
        internal XmlQueryOutput(XmlQueryRuntime runtime, XmlSequenceWriter seqwrt) {
            this.runtime = runtime;
            this.seqwrt = seqwrt;
            this.xstate = XmlState.WithinSequence;
        }

        /// <summary>
        /// This constructor is internal so that external users cannot construct it (and therefore we do not have to test it separately).
        /// Initialize output state to accept Rtf content (top-level sequences are therefore prohibited).
        /// </summary>
        internal XmlQueryOutput(XmlQueryRuntime runtime, XmlEventCache xwrt) {
            this.runtime = runtime;
            this.xwrt = xwrt;
            this.xstate = XmlState.WithinContent;
            this.depth = 1;
            this.rootType = XPathNodeType.Root;
        }

        /// <summary>
        /// Sequence writer to which output is directed by this class.
        /// </summary>
        internal XmlSequenceWriter SequenceWriter {
            get { return this.seqwrt; }
        }

        /// <summary>
        /// Raw writer to which output is directed by this class.
        /// </summary>
        internal XmlRawWriter Writer {
            get { return this.xwrt; }
            set {
                // If new writer might remove itself from pipeline, have it callback on this method when it's ready to go
                IRemovableWriter removable = value as IRemovableWriter;
                if (removable != null)
                    removable.OnRemoveWriterEvent = SetWrappedWriter;

                this.xwrt = value;
            }
        }

        /// <summary>
        /// This method will be called if "xwrt" is a writer which no longer needs to be part of the pipeline and
        /// wishes to replace itself with a different writer.  For example, the auto-detect writer replaces itself
        /// with the Html or Xml writer once it has determined which output mode to use.
        /// </summary>
        private void SetWrappedWriter(XmlRawWriter writer) {
            // Reuse XmlAttributeCache so that it doesn't have to be recreated every time
            if (Writer is XmlAttributeCache)
                this.attrCache = (XmlAttributeCache) Writer;

            Writer = writer;
        }


        //-----------------------------------------------
        // XmlWriter methods
        //-----------------------------------------------

        /// <summary>
        /// Should never be called.
        /// </summary>
        public override void WriteStartDocument() {
            throw new NotSupportedException();
        }

        /// <summary>
        /// Should never be called.
        /// </summary>
        public override void WriteStartDocument(bool standalone) {
            throw new NotSupportedException();
        }

        /// <summary>
        /// Should never be called.
        /// </summary>
        public override void WriteEndDocument() {
            throw new NotSupportedException();
        }

        /// <summary>
        /// Should never be called.
        /// </summary>
        public override void WriteDocType(string name, string pubid, string sysid, string subset) {
            throw new NotSupportedException();
        }

        /// <summary>
        /// Before calling XmlRawWriter.WriteStartElement(), perform various checks to ensure well-formedness.
        /// </summary>
        public override void WriteStartElement(string prefix, string localName, string ns) {
            Debug.Assert(prefix != null && localName != null && localName.Length != 0 && ns != null, "Invalid argument");
            Debug.Assert(ValidateNames.ValidateName(prefix, localName, ns, XPathNodeType.Element, ValidateNames.Flags.All), "Name validation failed");

            // Xml state transitions
            ConstructWithinContent(XPathNodeType.Element);

            // Call XmlRawWriter.WriteStartElement
            WriteStartElementUnchecked(prefix, localName, ns);

            // Ensure that element's namespace declaration is declared
            WriteNamespaceDeclarationUnchecked(prefix, ns);

            // Cache attributes in order to detect duplicates
            if (this.attrCache == null)
                this.attrCache = new XmlAttributeCache();

            this.attrCache.Init(Writer);
            Writer = this.attrCache;
            this.attrCache = null;

            // Push element names onto a stack
            PushElementNames(prefix, localName, ns);
        }

        /// <summary>
        /// Before calling XmlRawWriter.WriteEndElement(), perform various checks to ensure well-formedness.
        /// </summary>
        public override void WriteEndElement() {
            string prefix, localName, ns;

            // Determine whether element had no content
            if (this.xstate == XmlState.EnumAttrs) {
                // No content, so call StartElementContent now
                StartElementContentUnchecked();
            }

            // Call XmlRawWriter.WriteEndElement
            PopElementNames(out prefix, out localName, out ns);
            WriteEndElementUnchecked(prefix, localName, ns);

            // Xml state transitions
            if (this.depth == 0)
                EndTree();
        }

        /// <summary>
        /// Same as calling WriteEndElement().
        /// </summary>
        public override void WriteFullEndElement() {
            WriteEndElement();
        }

        /// <summary>
        /// Before calling XmlRawWriter.WriteStartAttribute(), perform various checks to ensure well-formedness.
        /// </summary>
        public override void WriteStartAttribute(string prefix, string localName, string ns) {
            Debug.Assert(prefix != null && localName != null && ns != null, "Invalid argument");

            if (prefix.Length == 5 && prefix == "xmlns") {
                // Handle namespace attributes that are not sent directly to WriteNamespaceDeclaration
                WriteStartNamespace(localName);
            }
            else {
                // All other attributes
                Debug.Assert(ValidateNames.ValidateName(prefix, localName, ns, XPathNodeType.Attribute, ValidateNames.Flags.All));

                // Xml state transitions
                ConstructInEnumAttrs(XPathNodeType.Attribute);

                // Check for prefix conflicts and possibly declare prefix
                if (ns.Length != 0 && this.depth != 0)
                    prefix = CheckAttributePrefix(prefix, ns);

                // Output the attribute
                WriteStartAttributeUnchecked(prefix, localName, ns);
            }
        }

        /// <summary>
        /// Before calling XmlRawWriter.WriteEndAttribute(), perform various checks to ensure well-formedness.
        /// </summary>
        public override void WriteEndAttribute() {
            if (this.xstate == XmlState.WithinNmsp) {
                WriteEndNamespace();
            }
            else {
                WriteEndAttributeUnchecked();

                if (this.depth == 0)
                    EndTree();
            }
        }

        /// <summary>
        /// Before writing a comment, perform various checks to ensure well-formedness.
        /// </summary>
        public override void WriteComment(string text) {
            WriteStartComment();
            WriteCommentString(text);
            WriteEndComment();
        }

        /// <summary>
        /// Before writing a processing instruction, perform various checks to ensure well-formedness.
        /// </summary>
        public override void WriteProcessingInstruction(string target, string text) {
            WriteStartProcessingInstruction(target);
            WriteProcessingInstructionString(text);
            WriteEndProcessingInstruction();
        }

        /// <summary>
        /// Should never be called.
        /// </summary>
        public override void WriteEntityRef(string name) {
            throw new NotSupportedException();
        }

        /// <summary>
        /// Should never be called.
        /// </summary>
        public override void WriteCharEntity(char ch) {
            throw new NotSupportedException();
        }

        /// <summary>
        /// Should never be called.
        /// </summary>
        public override void WriteSurrogateCharEntity(char lowChar, char highChar) {
            throw new NotSupportedException();
        }

        /// <summary>
        /// Treat whitespace as regular text.
        /// </summary>
        public override void WriteWhitespace(string ws) {
            throw new NotSupportedException();
        }

        /// <summary>
        /// Before writing text, perform various checks to ensure well-formedness.
        /// </summary>
        public override void WriteString(string text) {
            WriteString(text, false);
        }

        /// <summary>
        /// Before writing text, perform various checks to ensure well-formedness.
        /// </summary>
        public override void WriteChars(char[] buffer, int index, int count) {
            throw new NotSupportedException();
        }

        /// <summary>
        /// Write text, but do not escape special characters.
        /// </summary>
        public override void WriteRaw(char[] buffer, int index, int count) {
            throw new NotSupportedException();
        }

        /// <summary>
        /// Write text, but do not escape special characters.
        /// </summary>
        public override void WriteRaw(string data) {
            WriteString(data, true);
        }

        /// <summary>
        /// Write CData text as regular text.
        /// </summary>
        public override void WriteCData(string text) {
            WriteString(text, false);
        }

        /// <summary>
        /// Should never be called.
        /// </summary>
        public override void WriteBase64(byte[] buffer, int index, int count) {
            throw new NotSupportedException();
        }

        /// <summary>
        /// Should never be called.
        /// </summary>
        public override WriteState WriteState {
            get { throw new NotSupportedException(); }
        }

        /// <summary>
        /// No-op.
        /// </summary>
        public override void Close() {
        }

        /// <summary>
        /// No-op.
        /// </summary>
        public override void Flush() {
        }

        /// <summary>
        /// Should never be called.
        /// </summary>
        public override string LookupPrefix(string ns) {
            throw new NotSupportedException();
        }

        /// <summary>
        /// Should never be called.
        /// </summary>
        public override XmlSpace XmlSpace {
            get { throw new NotSupportedException(); }
        }

        /// <summary>
        /// Should never be called.
        /// </summary>
        public override string XmlLang {
            get { throw new NotSupportedException(); }
        }


        //-----------------------------------------------
        // XmlQueryOutput methods (XmlSequenceWriter)
        //-----------------------------------------------

        /// <summary>
        /// Call XmlSequenceWriter.StartTree() in order to start construction of a new tree.
        /// </summary>
        public void StartTree(XPathNodeType rootType) {
            Debug.Assert(this.xstate == XmlState.WithinSequence, "StartTree cannot be called in the " + this.xstate + " state.");
            Writer = this.seqwrt.StartTree(rootType, this.nsmgr, this.runtime.NameTable);
            this.rootType = rootType;
            this.xstate = (rootType == XPathNodeType.Attribute || rootType == XPathNodeType.Namespace) ? XmlState.EnumAttrs : XmlState.WithinContent;
        }

        /// <summary>
        /// Call XmlSequenceWriter.EndTree().
        /// </summary>
        public void EndTree() {
            Debug.Assert(this.xstate == XmlState.EnumAttrs || this.xstate == XmlState.WithinContent, "EndTree cannot be called in the " + this.xstate + " state.");
            this.seqwrt.EndTree();
            this.xstate = XmlState.WithinSequence;
            Writer = null;
        }


        //-----------------------------------------------
        // XmlQueryOutput methods (XmlRawWriter)
        //-----------------------------------------------

        /// <summary>
        /// Call XmlRawWriter.WriteStartElement() with prefix, local-name, ns, and schema type.
        /// </summary>
        public void WriteStartElementUnchecked(string prefix, string localName, string ns) {
            Debug.Assert(this.xstate == XmlState.WithinContent, "WriteStartElement cannot be called in the " + this.xstate + " state.");
            if (this.nsmgr != null) this.nsmgr.PushScope();
            Writer.WriteStartElement(prefix, localName, ns);
            //reset when enter element
            usedPrefixes.Clear();
            usedPrefixes[prefix] = ns;
            this.xstate = XmlState.EnumAttrs;
            this.depth++;
        }

        /// <summary>
        /// Call XmlRawWriter.WriteStartElement() with empty prefix, ns, and null schema type.
        /// </summary>
        public void WriteStartElementUnchecked(string localName) {
            WriteStartElementUnchecked(string.Empty, localName, string.Empty);
        }

        /// <summary>
        /// Call XmlRawWriter.StartElementContent().
        /// </summary>
        public void StartElementContentUnchecked() {
            Debug.Assert(this.xstate == XmlState.EnumAttrs, "StartElementContent cannot be called in the " + this.xstate + " state.");

            // Output any cached namespaces
            if (this.cntNmsp != 0)
                WriteCachedNamespaces();

            Writer.StartElementContent();
            this.xstate = XmlState.WithinContent;
        }

        /// <summary>
        /// Call XmlRawWriter.WriteEndElement() with prefix, local-name, and ns.
        /// </summary>
        public void WriteEndElementUnchecked(string prefix, string localName, string ns) {
            Debug.Assert(this.xstate == XmlState.EnumAttrs || this.xstate == XmlState.WithinContent, "WriteEndElement cannot be called in the " + this.xstate + " state.");
            Writer.WriteEndElement(prefix, localName, ns);
            this.xstate = XmlState.WithinContent;
            this.depth--;
            if (this.nsmgr != null) this.nsmgr.PopScope();
        }

        /// <summary>
        /// Call XmlRawWriter.WriteEndElement() with empty prefix, ns.
        /// </summary>
        public void WriteEndElementUnchecked(string localName) {
            WriteEndElementUnchecked(string.Empty, localName, string.Empty);
        }

        /// <summary>
        /// XmlRawWriter.WriteStartAttribute() with prefix, local-name, ns, and schema type.
        /// </summary>
        public void WriteStartAttributeUnchecked(string prefix, string localName, string ns) {
            Debug.Assert(this.xstate == XmlState.EnumAttrs, "WriteStartAttribute cannot be called in the " + this.xstate + " state.");
            Writer.WriteStartAttribute(prefix, localName, ns);
            this.xstate = XmlState.WithinAttr;
            this.depth++;
        }

        /// <summary>
        /// XmlRawWriter.WriteStartAttribute() with empty prefix, ns, and null schema type.
        /// </summary>
        public void WriteStartAttributeUnchecked(string localName) {
            WriteStartAttributeUnchecked(string.Empty, localName, string.Empty);
        }

        /// <summary>
        /// XmlRawWriter.WriteEndAttribute().
        /// </summary>
        public void WriteEndAttributeUnchecked() {
            Debug.Assert(this.xstate == XmlState.WithinAttr, "WriteEndAttribute cannot be called in the " + this.xstate + " state.");
            Writer.WriteEndAttribute();
            this.xstate = XmlState.EnumAttrs;
            this.depth--;
        }

        /// <summary>
        /// Add a new namespace declaration -- xmlns:prefix="ns" -- to the set of in-scope declarations.
        /// NOTE: This method should only be called if caller can guarantee that the current state is EnumAttrs
        ///       and that there will be no namespace conflicts in the current scope (e.g. trying to map the
        ///       same prefix to different namespaces within the same element start tag).  If no such
        ///       guarantees exist, then WriteNamespaceDeclaration() should be called instead.
        /// </summary>
        public void WriteNamespaceDeclarationUnchecked(string prefix, string ns) {
            Debug.Assert(prefix != null && ns != null);
            Debug.Assert(this.xstate == XmlState.EnumAttrs, "WriteNamespaceDeclaration cannot be called in the " + this.xstate + " state.");

            // xmlns:foo="" is illegal
            Debug.Assert(prefix.Length == 0 || ns.Length != 0);

            if (this.depth == 0) {
                // At top-level, so write namespace declaration directly to output
                Writer.WriteNamespaceDeclaration(prefix, ns);
                return;
            }

            if (this.nsmgr == null) {
                // If namespace manager has no namespaces, then xmlns="" is in scope by default
                if (ns.Length == 0 && prefix.Length == 0)
                    return;

                this.nsmgr = new XmlNamespaceManager(this.runtime.NameTable);
                this.nsmgr.PushScope();
            }

            if (this.nsmgr.LookupNamespace(prefix) != ns)
                AddNamespace(prefix, ns);

            usedPrefixes[prefix] = ns;
        }

        /// <summary>
        /// Write a text block to the XmlRawWriter.
        /// </summary>
        public void WriteStringUnchecked(string text) {
            Debug.Assert(this.xstate != XmlState.WithinSequence && this.xstate != XmlState.EnumAttrs, "WriteTextBlock cannot be called in the " + this.xstate + " state.");
            Writer.WriteString(text);
        }

        /// <summary>
        /// Write a text block without escaping special characters.
        /// </summary>
        public void WriteRawUnchecked(string text) {
            Debug.Assert(this.xstate != XmlState.WithinSequence && this.xstate != XmlState.EnumAttrs, "WriteTextBlockNoEntities cannot be called in the " + this.xstate + " state.");
            Writer.WriteRaw(text);
        }


        //-----------------------------------------------
        // XmlQueryOutput methods
        //-----------------------------------------------

        /// <summary>
        /// Before calling XmlSequenceWriter.StartTree(), perform checks to ensure well-formedness.
        /// </summary>
        public void WriteStartRoot() {
            Debug.Assert(this.depth == 0, "Root node can only be constructed at top-level.");
            if (this.xstate != XmlState.WithinSequence)
                ThrowInvalidStateError(XPathNodeType.Root);

            StartTree(XPathNodeType.Root);
            this.depth++;
        }

        /// <summary>
        /// Call XmlSequenceWriter.EndTree() and reset state.
        /// </summary>
        public void WriteEndRoot() {
            Debug.Assert(this.depth == 1, "Root node can only be constructed at top-level.");
            this.depth--;
            EndTree();
        }

        /// <summary>
        /// WriteStartElement() with empty prefix, ns.
        /// </summary>
        public void WriteStartElementLocalName(string localName) {
            WriteStartElement(string.Empty, localName, string.Empty);
        }

        /// <summary>
        /// WriteStartAttribute() with empty prefix, ns, and null schema type.
        /// </summary>
        public void WriteStartAttributeLocalName(string localName) {
            WriteStartAttribute(string.Empty, localName, string.Empty);
        }

        /// <summary>
        /// Write an element with a name that is computed from a "prefix:localName" tag name and a set of prefix mappings.
        /// </summary>
        public void WriteStartElementComputed(string tagName, int prefixMappingsIndex) {
            WriteStartComputed(XPathNodeType.Element, tagName, prefixMappingsIndex);
        }

        /// <summary>
        /// Write an element with a name that is computed from a "prefix:localName" tag name and a namespace URI.
        /// </summary>
        public void WriteStartElementComputed(string tagName, string ns) {
            WriteStartComputed(XPathNodeType.Element, tagName, ns);
        }

        /// <summary>
        /// Write an element with a name that is copied from the navigator.
        /// </summary>
        public void WriteStartElementComputed(XPathNavigator navigator) {
            WriteStartComputed(XPathNodeType.Element, navigator);
        }

        /// <summary>
        /// Write an element with a name that is derived from the XmlQualifiedName.
        /// </summary>
        public void WriteStartElementComputed(XmlQualifiedName name) {
            WriteStartComputed(XPathNodeType.Element, name);
        }

        /// <summary>
        /// Write an attribute with a name that is computed from a "prefix:localName" tag name and a set of prefix mappings.
        /// </summary>
        public void WriteStartAttributeComputed(string tagName, int prefixMappingsIndex) {
            WriteStartComputed(XPathNodeType.Attribute, tagName, prefixMappingsIndex);
        }

        /// <summary>
        /// Write an attribute with a name that is computed from a "prefix:localName" tag name and a namespace URI.
        /// </summary>
        public void WriteStartAttributeComputed(string tagName, string ns) {
            WriteStartComputed(XPathNodeType.Attribute, tagName, ns);
        }

        /// <summary>
        /// Write an attribute with a name that is copied from the navigator.
        /// </summary>
        public void WriteStartAttributeComputed(XPathNavigator navigator) {
            WriteStartComputed(XPathNodeType.Attribute, navigator);
        }

        /// <summary>
        /// Write an attribute with a name that is derived from the XmlQualifiedName.
        /// </summary>
        public void WriteStartAttributeComputed(XmlQualifiedName name) {
            WriteStartComputed(XPathNodeType.Attribute, name);
        }

        /// <summary>
        /// Before calling XmlRawWriter.WriteNamespaceDeclaration(), perform various checks to ensure well-formedness.
        /// </summary>
        public void WriteNamespaceDeclaration(string prefix, string ns) {
            string nsExisting;
            Debug.Assert(prefix != null && ns != null);

            ConstructInEnumAttrs(XPathNodeType.Namespace);

            if (this.nsmgr == null) {
                // If namespace manager has not yet been created, then there is no possibility of conflict
                WriteNamespaceDeclarationUnchecked(prefix, ns);
            }
            else {
                nsExisting = this.nsmgr.LookupNamespace(prefix);
                if (ns != nsExisting) {
                    // prefix = "", ns = "", nsExisting --> Look for xmlns="", found xmlns="foo"
                    // prefix = "", ns, nsExisting = null --> Look for xmlns="uri", no uri found
                    // prefix = "", ns, nsExisting = "" --> Look for xmlns="uri", found xmlns=""
                    // prefix = "", ns, nsExisting --> Look for xmlns="uri", found xmlns="uri2"
                    // prefix, ns, nsExisting = null --> Look for xmlns:foo="uri", no uri found
                    // prefix, ns, nsExisting --> Look for xmlns:foo="uri", found xmlns:foo="uri2"

                    // If the prefix is mapped to a uri,
                    if (nsExisting != null) {
                        // Then throw an error except if the prefix trying to redefine is already used
                        if (usedPrefixes.ContainsKey(prefix)) {
                            throw new XslTransformException(Res.XmlIl_NmspConflict, new string[] { prefix.Length == 0 ? "" : ":", prefix, ns, nsExisting });
                        }
                    }

                    // Add namespace to manager and write it to output
                    AddNamespace(prefix, ns);
                }
            }

            if (this.depth == 0)
                EndTree();

            usedPrefixes[prefix] = ns;
        }

        /// <summary>
        /// Before writing a namespace, perform various checks to ensure well-formedness.
        /// </summary>
        public void WriteStartNamespace(string prefix) {
            Debug.Assert(prefix != null, "Invalid argument");

            // Handle namespace attributes that are not sent directly to WriteNamespaceDeclaration
            ConstructInEnumAttrs(XPathNodeType.Namespace);
            this.piTarget/*nmspPrefix*/ = prefix;
            this.nodeText.Clear();

            this.xstate = XmlState.WithinNmsp;
            this.depth++;
        }

        /// <summary>
        /// Cache the namespace's text.
        /// </summary>
        public void WriteNamespaceString(string text) {
            Debug.Assert(this.xstate == XmlState.WithinNmsp, "WriteNamespaceString cannot be called in the " + this.xstate + " state.");
            this.nodeText.ConcatNoDelimiter(text);
        }

        /// <summary>
        /// Before writing a namespace, perform various checks to ensure well-formedness.
        /// </summary>
        public void WriteEndNamespace() {
            Debug.Assert(this.xstate == XmlState.WithinNmsp, "WriteEndNamespace cannot be called in the " + this.xstate + " state.");

            this.xstate = XmlState.EnumAttrs;
            this.depth--;

            // Write cached namespace attribute
            WriteNamespaceDeclaration(this.piTarget/*nmspPrefix*/, this.nodeText.GetResult());

            if (this.depth == 0)
                EndTree();
        }

        /// <summary>
        /// Before writing a comment, perform various checks to ensure well-formedness.
        /// </summary>
        public void WriteStartComment() {
            // Xml state transitions
            ConstructWithinContent(XPathNodeType.Comment);

            this.nodeText.Clear();
            this.xstate = XmlState.WithinComment;
            this.depth++;
        }

        /// <summary>
        /// Cache the comment's text.
        /// </summary>
        public void WriteCommentString(string text) {
            Debug.Assert(this.xstate == XmlState.WithinComment, "WriteCommentString cannot be called in the " + this.xstate + " state.");
            this.nodeText.ConcatNoDelimiter(text);
        }

        /// <summary>
        /// Before writing a comment, perform various checks to ensure well-formedness.
        /// </summary>
        public void WriteEndComment() {
            Debug.Assert(this.xstate == XmlState.WithinComment, "WriteEndComment cannot be called in the " + this.xstate + " state.");

            Writer.WriteComment(this.nodeText.GetResult());

            this.xstate = XmlState.WithinContent;
            this.depth--;

            if (this.depth == 0)
                EndTree();
        }

        /// <summary>
        /// Before writing a processing instruction, perform various checks to ensure well-formedness.
        /// </summary>
        public void WriteStartProcessingInstruction(string target) {
            // Xml state transitions
            ConstructWithinContent(XPathNodeType.ProcessingInstruction);

            // Verify PI name
            ValidateNames.ValidateNameThrow("", target, "", XPathNodeType.ProcessingInstruction, ValidateNames.Flags.AllExceptPrefixMapping);

            this.piTarget = target;
            this.nodeText.Clear();

            this.xstate = XmlState.WithinPI;
            this.depth++;
        }

        /// <summary>
        /// Cache the processing instruction's text.
        /// </summary>
        public void WriteProcessingInstructionString(string text) {
            Debug.Assert(this.xstate == XmlState.WithinPI, "WriteProcessingInstructionString cannot be called in the " + this.xstate + " state.");
            this.nodeText.ConcatNoDelimiter(text);
        }

        /// <summary>
        /// Before writing a processing instruction, perform various checks to ensure well-formedness.
        /// </summary>
        public void WriteEndProcessingInstruction() {
            Debug.Assert(this.xstate == XmlState.WithinPI, "WriteEndProcessingInstruction cannot be called in the " + this.xstate + " state.");

            Writer.WriteProcessingInstruction(this.piTarget, this.nodeText.GetResult());

            this.xstate = XmlState.WithinContent;
            this.depth--;

            // Xml state transitions
            if (this.depth == 0)
                EndTree();
        }

        /// <summary>
        /// Write an item to output.  If currently constructing an Xml tree, then the item is always copied.
        /// At the top-level, the item's identity is preserved unless it's an atomic value.
        /// </summary>
        public void WriteItem(XPathItem item) {
            if (item.IsNode) {
                XPathNavigator navigator = (XPathNavigator) item;

                // If this is a top-level node, write a reference to it; else copy it by value
                if (this.xstate == XmlState.WithinSequence)
                    this.seqwrt.WriteItem(navigator);
                else
                    CopyNode(navigator);
            }
            else {
                // Call WriteItem for atomic values
                Debug.Assert(this.xstate == XmlState.WithinSequence, "Values can only be written at the top-level.");
                this.seqwrt.WriteItem(item);
            }
        }

        /// <summary>
        /// Copy a node by value to output according to Xslt rules:
        ///   1. Identity is never preserved
        ///   2. If the item is an Rtf, preserve serialization hints when copying.
        ///   3. If the item is a Root node, copy the children of the Root
        /// </summary>
        public void XsltCopyOf(XPathNavigator navigator) {
            RtfNavigator navRtf = navigator as RtfNavigator;

            if (navRtf != null) {
                // Copy Rtf
                navRtf.CopyToWriter(this);
            }
            else if (navigator.NodeType == XPathNodeType.Root) {
                // Copy children of root
                if (navigator.MoveToFirstChild()) {
                    do {
                        CopyNode(navigator);
                    }
                    while (navigator.MoveToNext());

                    navigator.MoveToParent();
                }
            }
            else {
                // Copy node
                CopyNode(navigator);
            }
        }

        /// <summary>
        /// Begin shallow copy of the navigator's current node to output.  Returns true if EndCopy
        /// should be called to complete the copy operation.
        /// Automatically copies all in-scope namespaces on elements.
        /// </summary>
        public bool StartCopy(XPathNavigator navigator) {
            // StartDocument is a no-op
            if (navigator.NodeType == XPathNodeType.Root)
                return true;

            if (StartCopy(navigator, true)) {
                Debug.Assert(navigator.NodeType == XPathNodeType.Element, "StartCopy should return true only for Element nodes.");

                // Copy namespaces to output
                CopyNamespaces(navigator, XPathNamespaceScope.ExcludeXml);

                return true;
            }

            return false;
        }

        /// <summary>
        /// End shallow copy of the navigator's current node.  Should be called only for Element and Document nodes.
        /// </summary>
        public void EndCopy(XPathNavigator navigator) {
            if (navigator.NodeType == XPathNodeType.Element)
                WriteEndElement();
            else
                Debug.Assert(navigator.NodeType == XPathNodeType.Root, "EndCopy should only be called for Element and Document nodes.");
        }


        //-----------------------------------------------
        // Helper methods
        //-----------------------------------------------

        /// <summary>
        /// Add an in-scope namespace.
        /// </summary>
        private void AddNamespace(string prefix, string ns) {
            this.nsmgr.AddNamespace(prefix, ns);
            this.cntNmsp++;
            usedPrefixes[prefix] = ns;
        }

        /// <summary>
        /// Before writing text, perform various checks to ensure well-formedness.
        /// </summary>
        private void WriteString(string text, bool disableOutputEscaping) {
            Debug.Assert(text != null, "Invalid argument");

            // Xml state transitions
            switch (this.xstate) {
                case XmlState.WithinSequence:
                    // Start constructing new tree
                    StartTree(XPathNodeType.Text);
                    goto case XmlState.WithinContent;

                case XmlState.WithinContent:
                    if (disableOutputEscaping)
                        WriteRawUnchecked(text);
                    else
                        WriteStringUnchecked(text);
                    break;

                case XmlState.EnumAttrs:
                    // Enumerating attributes, so write text as element content
                    StartElementContentUnchecked();
                    goto case XmlState.WithinContent;

                case XmlState.WithinAttr:
                    WriteStringUnchecked(text);
                    break;

                case XmlState.WithinNmsp:
                    WriteNamespaceString(text);
                    break;

                case XmlState.WithinComment:
                    // Comment text
                    WriteCommentString(text);
                    break;

                case XmlState.WithinPI:
                    // PI text
                    WriteProcessingInstructionString(text);
                    break;

                default:
                    Debug.Assert(false, "Text cannot be output in the " + this.xstate + " state.");
                    break;
            }

            if (this.depth == 0)
                EndTree();
        }

        /// <summary>
        /// Deep copy the subtree that is rooted at this navigator's current position to output.  If the current
        /// item is an element, copy all in-scope namespace nodes.
        /// </summary>
        private void CopyNode(XPathNavigator navigator) {
            XPathNodeType nodeType;
            int depthStart = this.depth;
            Debug.Assert(navigator != null);

            while (true) {
                if (StartCopy(navigator, this.depth == depthStart)) {
                    nodeType = navigator.NodeType;
                    Debug.Assert(nodeType == XPathNodeType.Element, "StartCopy should return true only for Element nodes.");

                    // Copy attributes
                    if (navigator.MoveToFirstAttribute()) {
                        do {
                            StartCopy(navigator, false);
                        }
                        while (navigator.MoveToNextAttribute());
                        navigator.MoveToParent();
                    }

                    // Copy namespaces in document order (navigator returns them in reverse document order)
                    CopyNamespaces(navigator, (this.depth - 1 == depthStart) ? XPathNamespaceScope.ExcludeXml : XPathNamespaceScope.Local);

                    StartElementContentUnchecked();

                    // If children exist, move down to next level
                    if (navigator.MoveToFirstChild())
                        continue;

                    EndCopy(navigator, (this.depth - 1) == depthStart);
                }

                // No children
                while (true) {
                    if (this.depth == depthStart) {
                        // The entire subtree has been copied
                        return;
                    }

                    if (navigator.MoveToNext()) {
                        // Found a sibling, so break to outer loop
                        break;
                    }

                    // No siblings, so move up to previous level
                    navigator.MoveToParent();

                    EndCopy(navigator, (this.depth - 1) == depthStart);
                }
            }
        }

        /// <summary>
        /// Begin shallow copy of the navigator's current node to output.  Returns true if EndCopy
        /// should be called to complete the copy operation.
        /// </summary>
        private bool StartCopy(XPathNavigator navigator, bool callChk) {
            bool mayHaveChildren = false;

            switch (navigator.NodeType) {
                case XPathNodeType.Element:
                    // If checks need to be made, call XmlQueryOutput.WriteStartElement
                    if (callChk) {
                        WriteStartElement(navigator.Prefix, navigator.LocalName, navigator.NamespaceURI);
                    }
                    else {
                        WriteStartElementUnchecked(navigator.Prefix, navigator.LocalName, navigator.NamespaceURI);
                    }

                    mayHaveChildren = true;
                    break;

                case XPathNodeType.Attribute:
                    // If checks need to be made, call XmlQueryOutput.WriteStartAttribute
                    if (callChk) {
                        WriteStartAttribute(navigator.Prefix, navigator.LocalName, navigator.NamespaceURI);
                    }
                    else {
                        WriteStartAttributeUnchecked(navigator.Prefix, navigator.LocalName, navigator.NamespaceURI);
                    }

                    // Write attribute text
                    WriteString(navigator.Value);

                    // If checks need to be made, call XmlQueryOutput.WriteEndAttribute
                    if (callChk) {
                        WriteEndAttribute();
                    }
                    else {
                        WriteEndAttributeUnchecked();
                    }
                    break;

                case XPathNodeType.Namespace:
                    // If checks need to be made, call XmlQueryOutput.WriteNamespaceDeclaration
                    if (callChk) {
                        // Do not allow namespaces to be copied after attributes
                        XmlAttributeCache attrCache = Writer as XmlAttributeCache;
                        if (attrCache != null && attrCache.Count != 0)
                            throw new XslTransformException(Res.XmlIl_NmspAfterAttr, string.Empty);

                        WriteNamespaceDeclaration(navigator.LocalName, navigator.Value);
                    }
                    else {
                        WriteNamespaceDeclarationUnchecked(navigator.LocalName, navigator.Value);
                    }
                    break;

                case XPathNodeType.Text:
                case XPathNodeType.SignificantWhitespace:
                case XPathNodeType.Whitespace:
                    // If checks need to be made, call XmlQueryOutput.WriteString
                    if (callChk) {
                        WriteString(navigator.Value, false);
                    }
                    else {
                        // No flags are set, so this is simple element text (attributes, comments, pi's copy own text)
                        WriteStringUnchecked(navigator.Value);
                    }
                    break;

                case XPathNodeType.Root:
                    // Document node is invalid except at the top-level
                    Debug.Assert(this.xstate != XmlState.WithinSequence, "StartCopy should not called if state is WithinSequence");
                    ThrowInvalidStateError(XPathNodeType.Root);
                    break;

                case XPathNodeType.Comment:
                    WriteStartComment();
                    WriteCommentString(navigator.Value);
                    WriteEndComment();
                    break;

                case XPathNodeType.ProcessingInstruction:
                    WriteStartProcessingInstruction(navigator.LocalName);
                    WriteProcessingInstructionString(navigator.Value);
                    WriteEndProcessingInstruction();
                    break;

                default:
                    Debug.Assert(false);
                    break;
            }

            return mayHaveChildren;
        }

        /// <summary>
        /// End shallow copy of the navigator's current node to output.  This method should only be called if StartCopy
        /// returned true.
        /// </summary>
        private void EndCopy(XPathNavigator navigator, bool callChk) {
            Debug.Assert(navigator.NodeType == XPathNodeType.Element);
            Debug.Assert(this.xstate == XmlState.WithinContent, "EndCopy cannot be called in the " + this.xstate + " state.");

            if (callChk)
                WriteEndElement();
            else
                WriteEndElementUnchecked(navigator.Prefix, navigator.LocalName, navigator.NamespaceURI);
        }

        /// <summary>
        /// Copy all namespaces of the specified type (in-scope, exclude-xml, local) in document order to output.
        /// </summary>
        private void CopyNamespaces(XPathNavigator navigator, XPathNamespaceScope nsScope) {
            Debug.Assert(navigator.NodeType == XPathNodeType.Element, "Only elements have namespaces to copy");

            // Default namespace undeclaration isn't included in navigator's namespace list, so add it now
            if (navigator.NamespaceURI.Length == 0) {
                Debug.Assert(navigator.LocalName.Length != 0, "xmlns:foo='' isn't allowed");
                WriteNamespaceDeclarationUnchecked(string.Empty, string.Empty);
            }

            // Since the namespace list is arranged in reverse-document order, recursively reverse it.
            if (navigator.MoveToFirstNamespace(nsScope)) {
                CopyNamespacesHelper(navigator, nsScope);
                navigator.MoveToParent();
            }
        }

        /// <summary>
        /// Recursive helper function that reverses order of the namespaces retrieved by MoveToFirstNamespace and
        /// MoveToNextNamespace.
        /// </summary>
        private void CopyNamespacesHelper(XPathNavigator navigator, XPathNamespaceScope nsScope) {
            string prefix = navigator.LocalName;
            string ns = navigator.Value;

            if (navigator.MoveToNextNamespace(nsScope))
                CopyNamespacesHelper(navigator, nsScope);

            // No possibility for conflict, since we're copying namespaces from well-formed element
            WriteNamespaceDeclarationUnchecked(prefix, ns);
        }

        /// <summary>
        /// Ensure that state transitions to WithinContent.
        /// </summary>
        private void ConstructWithinContent(XPathNodeType rootType) {
            Debug.Assert(rootType == XPathNodeType.Element || rootType == XPathNodeType.Comment || rootType == XPathNodeType.ProcessingInstruction);

            switch (this.xstate) {
                case XmlState.WithinSequence:
                    // If state is WithinSequence, call XmlSequenceWriter.StartTree
                    StartTree(rootType);
                    this.xstate = XmlState.WithinContent;
                    break;

                case XmlState.WithinContent:
                    // Already within element content
                    break;

                case XmlState.EnumAttrs:
                    // Start element content
                    StartElementContentUnchecked();
                    break;

                default:
                    // Construction is not allowed in this state
                    ThrowInvalidStateError(rootType);
                    break;
            }
        }

        /// <summary>
        /// Ensure that state transitions to EnumAttrs.
        /// </summary>
        private void ConstructInEnumAttrs(XPathNodeType rootType) {
            Debug.Assert(rootType == XPathNodeType.Attribute || rootType == XPathNodeType.Namespace);

            switch (this.xstate) {
                case XmlState.WithinSequence:
                    StartTree(rootType);
                    this.xstate = XmlState.EnumAttrs;
                    break;

                case XmlState.EnumAttrs:
                    // Already in EnumAttrs state
                    break;

                default:
                    // Construction is not allowed in this state
                    ThrowInvalidStateError(rootType);
                    break;
            }
        }

        /// <summary>
        /// Namespace declarations are added to this.nsmgr.  Just before element content has begun, write out
        /// all namespaces that were declared locally on the element.
        /// </summary>
        private void WriteCachedNamespaces() {
            string prefix, ns;

            while (this.cntNmsp != 0) {
                // Output each prefix->ns mapping pair
                Debug.Assert(this.nsmgr != null);
                this.cntNmsp--;
                this.nsmgr.GetNamespaceDeclaration(this.cntNmsp, out prefix, out ns);
                Writer.WriteNamespaceDeclaration(prefix, ns);
            }
        }

        /// <summary>
        /// Return the type of node that is under construction given the specified XmlState.
        /// </summary>
        private XPathNodeType XmlStateToNodeType(XmlState xstate) {
            switch (xstate) {
                case XmlState.EnumAttrs: return XPathNodeType.Element;
                case XmlState.WithinContent: return XPathNodeType.Element;
                case XmlState.WithinAttr: return XPathNodeType.Attribute;
                case XmlState.WithinComment: return XPathNodeType.Comment;
                case XmlState.WithinPI: return XPathNodeType.ProcessingInstruction;
            }

            Debug.Assert(false, xstate.ToString() + " is not a valid XmlState.");
            return XPathNodeType.Element;
        }

        /// <summary>
        /// If attribute's prefix conflicts with other prefixes then redeclare the prefix.  If the prefix has
        /// not yet been declared, then add it to the namespace manager.
        /// </summary>
        private string CheckAttributePrefix(string prefix, string ns) {
            string nsExisting;
            Debug.Assert(prefix.Length != 0 && ns.Length != 0);

            // Ensure that this attribute's prefix does not conflict with previously declared prefixes in this scope
            if (this.nsmgr == null) {
                // If namespace manager has no namespaces, then there is no possibility of conflict
                WriteNamespaceDeclarationUnchecked(prefix, ns);
            }
            else {
                while (true) {
                    // If prefix is already mapped to a different namespace,
                    nsExisting = this.nsmgr.LookupNamespace(prefix);
                    if (nsExisting != ns) {

                        // Then if the prefix is already mapped,
                        if (nsExisting != null) {
                            // Then there is a conflict that must be resolved by finding another prefix
                            // Always find a new prefix, even if the conflict didn't occur in the current scope
                            // This decision allows more aggressive namespace analysis at compile-time
                            prefix = RemapPrefix(prefix, ns, false);
                            continue;
                        }

                        // Add the mapping to the current scope
                        AddNamespace(prefix, ns);
                    }
                    break;
                }
            }

            return prefix;
        }

        /// <summary>
        /// Remaps an element or attribute prefix using the following rules:
        ///
        ///   1. If another in-scope prefix is already mapped to "ns", then use that
        ///   2. Otherwise, if a prefix was previously mapped to "ns" by this method, then use that
        ///   3. Otherwise, generate a new prefix of the form 'xp_??', where ?? is a stringized counter
        ///
        /// These rules tend to reduce the number of unique prefixes used throughout the tree.
        /// </summary>
        private string RemapPrefix(string prefix, string ns, bool isElemPrefix) {
            string genPrefix;
            Debug.Assert(prefix != null && ns != null && ns.Length != 0);

            if (this.conflictPrefixes == null)
                this.conflictPrefixes = new Dictionary<string, string>(16);

            if (this.nsmgr == null) {
                this.nsmgr = new XmlNamespaceManager(this.runtime.NameTable);
                this.nsmgr.PushScope();
            }

            // Rule #1: If another in-scope prefix is already mapped to "ns", then use that
            genPrefix = this.nsmgr.LookupPrefix(ns);
            if (genPrefix != null) {
                // Can't use an empty prefix for an attribute
                if (isElemPrefix || genPrefix.Length != 0)
                    goto ReturnPrefix;
            }

            // Rule #2: Otherwise, if a prefix was previously mapped to "ns" by this method, then use that
            // Make sure that any previous prefix is different than "prefix"
            if (this.conflictPrefixes.TryGetValue(ns, out genPrefix) && genPrefix != prefix) {
                // Can't use an empty prefix for an attribute
                if (isElemPrefix || genPrefix.Length != 0)
                    goto ReturnPrefix;
            }

            // Rule #3: Otherwise, generate a new prefix of the form 'xp_??', where ?? is a stringized counter
            genPrefix = "xp_" + (this.prefixIndex++).ToString(CultureInfo.InvariantCulture);


        ReturnPrefix:
            // Save generated prefix so that it can be possibly be reused later
            this.conflictPrefixes[ns] = genPrefix;

            return genPrefix;
        }

        /// <summary>
        /// Write an element or attribute with a name that is computed from a "prefix:localName" tag name and a set of prefix mappings.
        /// </summary>
        private void WriteStartComputed(XPathNodeType nodeType, string tagName, int prefixMappingsIndex) {
            string prefix, localName, ns;

            // Parse the tag name and map the prefix to a namespace
            runtime.ParseTagName(tagName, prefixMappingsIndex, out prefix, out localName, out ns);

            // Validate the name parts
            prefix = EnsureValidName(prefix, localName, ns, nodeType);

            if (nodeType == XPathNodeType.Element)
                WriteStartElement(prefix, localName, ns);
            else
                WriteStartAttribute(prefix, localName, ns);
        }

        /// <summary>
        /// Write an element or attribute with a name that is computed from a "prefix:localName" tag name and a namespace URI.
        /// </summary>
        private void WriteStartComputed(XPathNodeType nodeType, string tagName, string ns) {
            string prefix, localName;

            // Parse the tagName as a prefix, localName pair
            ValidateNames.ParseQNameThrow(tagName, out prefix, out localName);

            // Validate the name parts
            prefix = EnsureValidName(prefix, localName, ns, nodeType);

            if (nodeType == XPathNodeType.Element)
                WriteStartElement(prefix, localName, ns);
            else
                WriteStartAttribute(prefix, localName, ns);
        }

        /// <summary>
        /// Write an element or attribute with a name that is copied from the navigator.
        /// </summary>
        private void WriteStartComputed(XPathNodeType nodeType, XPathNavigator navigator) {
            string prefix, localName, ns;

            prefix = navigator.Prefix;
            localName = navigator.LocalName;
            ns = navigator.NamespaceURI;

            if (navigator.NodeType != nodeType) {
                // Validate the name parts
                prefix = EnsureValidName(prefix, localName, ns, nodeType);
            }

            if (nodeType == XPathNodeType.Element)
                WriteStartElement(prefix, localName, ns);
            else
                WriteStartAttribute(prefix, localName, ns);
        }

        /// <summary>
        /// Write an element or attribute with a name that is derived from the XmlQualifiedName.
        /// </summary>
        private void WriteStartComputed(XPathNodeType nodeType, XmlQualifiedName name) {
            string prefix;
            Debug.Assert(ValidateNames.ParseNCName(name.Name, 0) == name.Name.Length);

            // Validate the name parts
            prefix = (name.Namespace.Length != 0) ? RemapPrefix(string.Empty, name.Namespace, nodeType == XPathNodeType.Element) : string.Empty;
            prefix = EnsureValidName(prefix, name.Name, name.Namespace, nodeType);

            if (nodeType == XPathNodeType.Element)
                WriteStartElement(prefix, name.Name, name.Namespace);
            else
                WriteStartAttribute(prefix, name.Name, name.Namespace);
        }

        /// <summary>
        /// Ensure that the specified name parts are valid according to Xml 1.0 and Namespace 1.0 rules.  Try to remap
        /// the prefix in order to attain validity.  Throw if validity is not possible.  Otherwise, return the (possibly
        /// remapped) prefix.
        /// </summary>
        private string EnsureValidName(string prefix, string localName, string ns, XPathNodeType nodeType) {
            if (!ValidateNames.ValidateName(prefix, localName, ns, nodeType, ValidateNames.Flags.AllExceptNCNames)) {
                // Name parts are not valid as is.  Try to re-map the prefix.
                prefix = (ns.Length != 0) ? RemapPrefix(string.Empty, ns, nodeType == XPathNodeType.Element) : string.Empty;

                // Throw if validation does not work this time
                ValidateNames.ValidateNameThrow(prefix, localName, ns, nodeType, ValidateNames.Flags.AllExceptNCNames);
            }

            return prefix;
        }

        /// <summary>
        /// Push element name parts onto the stack.
        /// </summary>
        private void PushElementNames(string prefix, string localName, string ns) {
            // Push the name parts onto a stack
            if (this.stkNames == null)
                this.stkNames = new Stack<string>(15);

            this.stkNames.Push(prefix);
            this.stkNames.Push(localName);
            this.stkNames.Push(ns);
        }

        /// <summary>
        /// Pop element name parts from the stack.
        /// </summary>
        private void PopElementNames(out string prefix, out string localName, out string ns) {
            Debug.Assert(this.stkNames != null);

            ns = this.stkNames.Pop();
            localName = this.stkNames.Pop();
            prefix = this.stkNames.Pop();
        }

        /// <summary>
        /// Throw an invalid state transition error.
        /// </summary>
        private void ThrowInvalidStateError(XPathNodeType constructorType) {
            switch (constructorType) {
                case XPathNodeType.Element:
                case XPathNodeType.Root:
                case XPathNodeType.Text:
                case XPathNodeType.Comment:
                case XPathNodeType.ProcessingInstruction:
                    throw new XslTransformException(Res.XmlIl_BadXmlState, new string[] {constructorType.ToString(), XmlStateToNodeType(this.xstate).ToString()});

                case XPathNodeType.Attribute:
                case XPathNodeType.Namespace:
                    if (this.depth == 1)
                        throw new XslTransformException(Res.XmlIl_BadXmlState, new string[] {constructorType.ToString(), this.rootType.ToString()});

                    if (this.xstate == XmlState.WithinContent)
                        throw new XslTransformException(Res.XmlIl_BadXmlStateAttr, string.Empty);

                    goto case XPathNodeType.Element;

                default:
                    throw new XslTransformException(Res.XmlIl_BadXmlState, new string[] {"Unknown", XmlStateToNodeType(this.xstate).ToString()});
            }
        }
    }
}