private bool MoveFirstChild(BamlNodeType type)
        {
            var node = _state.Node;

            if (!node.IsBlock)
            {
                return(false);
            }

            var nextNode = ((BamlBlock)node).FirstChild;

            while (nextNode != null && IsSkipNode(nextNode))
            {
                nextNode = nextNode.NextSibling;
            }

            if (nextNode == null)
            {
                return(false);
            }

            if (nextNode.NodeType != type)
            {
                return(false);
            }

            MoveNext();
            return(true);
        }
        // Token: 0x06006EB6 RID: 28342 RVA: 0x001FCF00 File Offset: 0x001FB100
        internal bool TryGetContent(BamlLocalizableResourceKey key, BamlTreeNode currentNode, out string content)
        {
            content = string.Empty;
            BamlNodeType nodeType = currentNode.NodeType;

            if (nodeType == BamlNodeType.StartElement)
            {
                BamlStartElementNode bamlStartElementNode = (BamlStartElementNode)currentNode;
                if (bamlStartElementNode.Content == null)
                {
                    StringBuilder stringBuilder = new StringBuilder();
                    foreach (BamlTreeNode bamlTreeNode in bamlStartElementNode.Children)
                    {
                        nodeType = bamlTreeNode.NodeType;
                        if (nodeType != BamlNodeType.StartElement)
                        {
                            if (nodeType == BamlNodeType.Text)
                            {
                                stringBuilder.Append(BamlResourceContentUtil.EscapeString(((BamlTextNode)bamlTreeNode).Content));
                            }
                        }
                        else
                        {
                            string value;
                            if (!this.TryFormatElementContent(key, (BamlStartElementNode)bamlTreeNode, out value))
                            {
                                return(false);
                            }
                            stringBuilder.Append(value);
                        }
                    }
                    bamlStartElementNode.Content = stringBuilder.ToString();
                }
                content = bamlStartElementNode.Content;
                return(true);
            }
            if (nodeType == BamlNodeType.Property)
            {
                bool             result           = true;
                BamlPropertyNode bamlPropertyNode = (BamlPropertyNode)currentNode;
                content = BamlResourceContentUtil.EscapeString(bamlPropertyNode.Value);
                string text = content;
                string text2;
                string text3;
                if (MarkupExtensionParser.GetMarkupExtensionTypeAndArgs(ref text, out text2, out text3))
                {
                    LocalizabilityGroup localizabilityComment = this._resolver.GetLocalizabilityComment(bamlPropertyNode.Parent as BamlStartElementNode, bamlPropertyNode.PropertyName);
                    result = (localizabilityComment != null && localizabilityComment.Readability == Readability.Readable);
                }
                return(result);
            }
            if (nodeType != BamlNodeType.LiteralContent)
            {
                return(true);
            }
            content = BamlResourceContentUtil.EscapeString(((BamlLiteralContentNode)currentNode).Content);
            return(true);
        }
Exemple #3
0
        // Token: 0x06006E21 RID: 28193 RVA: 0x001FB3C4 File Offset: 0x001F95C4
        internal static BamlLocalizableResourceKey GetKey(BamlTreeNode node)
        {
            BamlLocalizableResourceKey result = null;
            BamlNodeType nodeType             = node.NodeType;

            if (nodeType != BamlNodeType.StartElement)
            {
                if (nodeType != BamlNodeType.Property)
                {
                    if (nodeType == BamlNodeType.LiteralContent)
                    {
                        BamlLiteralContentNode bamlLiteralContentNode = (BamlLiteralContentNode)node;
                        BamlStartElementNode   bamlStartElementNode   = (BamlStartElementNode)node.Parent;
                        if (bamlStartElementNode.Uid != null)
                        {
                            result = new BamlLocalizableResourceKey(bamlStartElementNode.Uid, bamlStartElementNode.TypeFullName, "$LiteralContent", bamlStartElementNode.AssemblyName);
                        }
                    }
                }
                else
                {
                    BamlPropertyNode     bamlPropertyNode      = (BamlPropertyNode)node;
                    BamlStartElementNode bamlStartElementNode2 = (BamlStartElementNode)bamlPropertyNode.Parent;
                    if (bamlStartElementNode2.Uid != null)
                    {
                        string uid;
                        if (bamlPropertyNode.Index <= 0)
                        {
                            uid = bamlStartElementNode2.Uid;
                        }
                        else
                        {
                            uid = string.Format(TypeConverterHelper.InvariantEnglishUS, "{0}.{1}_{2}", new object[]
                            {
                                bamlStartElementNode2.Uid,
                                bamlPropertyNode.PropertyName,
                                bamlPropertyNode.Index
                            });
                        }
                        result = new BamlLocalizableResourceKey(uid, bamlPropertyNode.OwnerTypeFullName, bamlPropertyNode.PropertyName, bamlPropertyNode.AssemblyName);
                    }
                }
            }
            else
            {
                BamlStartElementNode bamlStartElementNode3 = (BamlStartElementNode)node;
                if (bamlStartElementNode3.Uid != null)
                {
                    result = new BamlLocalizableResourceKey(bamlStartElementNode3.Uid, bamlStartElementNode3.TypeFullName, "$Content", bamlStartElementNode3.AssemblyName);
                }
            }
            return(result);
        }
        private bool MoveNext(BamlNodeType type)
        {
            var next = GetNext(_state.Node);

            if (next == null)
            {
                return(false);
            }

            if (next.NodeType != type)
            {
                return(false);
            }

            MoveNext();
            return(true);
        }
        /***************************************************************************\
        *
        * BamlReader.ReadElementEndRecord
        *
        * Read the end of an element.  This is either a CLR or DependencyObject
        * that is part of an object tree.
        *
        \***************************************************************************/

        private void ReadElementEndRecord()
        {
            // If we are processing a deferable content block and we've reached the
            // end record for the deferable element, then pop off the deferable content
            // start record that is on the stack.
            if (_deferableContentBlockDepth == _nodeStack.Count)
            {
                _deferableContentBlockDepth = -1;
                _deferableContentPosition = -1;
            }

            // Pop information off the node stack that tells us what element this
            // is the end of.  Check to make sure the record on the stack is for a
            // start element.
            BamlNodeInfo nodeInfo = (BamlNodeInfo)_nodeStack.Pop();
            if (nodeInfo.RecordType != BamlRecordType.ElementStart)
            {
                throw new InvalidOperationException(SR.Get(SRID.BamlScopeError,
                                                 _currentBamlRecord.RecordType.ToString(),
                                                 BamlRecordType.ElementEnd.ToString()));
            }

            ClearProperties();
            NodeTypeInternal = BamlNodeType.EndElement;
            _name = nodeInfo.Name;
            _localName = nodeInfo.LocalName;
            _ownerTypeName = string.Empty;
            _assemblyName = nodeInfo.AssemblyName;
            _prefix = nodeInfo.Prefix;
            _xmlNamespace = nodeInfo.XmlNamespace;
            _clrNamespace = nodeInfo.ClrNamespace;
            _parserContext.PopScope();
            _prefixDictionary.PopScope();

            // read properties, if any, after this end tag.
            ReadProperties();

        }
        /***************************************************************************\
        *
        * BamlReader.ReadElementStartRecord
        *
        * Read the start of an element.  This is either a CLR or DependencyObject
        * that is part of an object tree.
        *
        \***************************************************************************/

        private void ReadElementStartRecord()
        {
            ClearProperties();
            _propertyDP = null;
            _parserContext.PushScope();
            _prefixDictionary.PushScope();

            BamlElementStartRecord bamlRecord = (BamlElementStartRecord)_currentBamlRecord;
            BamlTypeInfoRecord typeInfo = MapTable.GetTypeInfoFromId(bamlRecord.TypeId);

            NodeTypeInternal = BamlNodeType.StartElement;
            _name = typeInfo.TypeFullName;
            _localName = _name.Substring(_name.LastIndexOf(".", StringComparison.Ordinal) + 1);
            _ownerTypeName = string.Empty;
            _clrNamespace = typeInfo.ClrNamespace;
            GetAssemblyAndPrefixAndXmlns(typeInfo, out _assemblyName, out _prefix, out _xmlNamespace);

            // Push information on the node stack to indicate we have a start element
            BamlNodeInfo nodeInfo = new BamlNodeInfo();
            nodeInfo.Name = _name;
            nodeInfo.LocalName = _localName;
            nodeInfo.AssemblyName = _assemblyName;
            nodeInfo.Prefix = _prefix;
            nodeInfo.ClrNamespace = _clrNamespace;
            nodeInfo.XmlNamespace = _xmlNamespace;
            nodeInfo.RecordType = BamlRecordType.ElementStart;

            _useTypeConverter = bamlRecord.CreateUsingTypeConverter;
            _isInjected = bamlRecord.IsInjected;

            // If we are in a deferable block, then see if this is a top level element for
            // that block that matches an offset in the list of defered dictionary keys.  If
            // so, then insert a x:Key="keystring" to make this appear like a normal
            // dictionary.
            if (_deferableContentBlockDepth == _nodeStack.Count)
            {
                // Calculate the offset for the start of the current element record in
                // the baml stream.
                Int32 offset = (Int32)(_bamlRecordReader.StreamPosition - _deferableContentPosition);

                // Subtract off the size of the current Record.
                offset -= bamlRecord.RecordSize + BamlRecord.RecordTypeFieldLength;

                // If there is a debug extension record then subtract that off also.
                if (BamlRecordHelper.HasDebugExtensionRecord(_parserContext.IsDebugBamlStream, bamlRecord))
                {
                    BamlRecord bamlDebugRecord = bamlRecord.Next;
                    offset -= bamlDebugRecord.RecordSize + BamlRecord.RecordTypeFieldLength;
                }
                InsertDeferedKey(offset);
            }

            _nodeStack.Push(nodeInfo);

            // Read the properties that may be part of the start tag of this element
            ReadProperties();
        }
        /***************************************************************************\
        *
        * BamlReader.ReadLiteralContentRecord
        *
        * Read literal content record, which is the responsibility of the current
        * element to parse.
        *
        \***************************************************************************/

        private void ReadLiteralContentRecord()
        {
            ClearProperties();

            BamlLiteralContentRecord bamlRecord = (BamlLiteralContentRecord)_currentBamlRecord;
            NodeTypeInternal = BamlNodeType.LiteralContent;
            _value = bamlRecord.Value;
        }
        /***************************************************************************\
        *
        * BamlReader.ReadPIMappingRecord
        *
        * Read the clr to xml namespace to assembly mapping record.  The contents
        * of this record are represented as three properties, one each for
        * XmlNamespace, ClrNamespace and Assembly Name.
        *
        \***************************************************************************/

        private void ReadPIMappingRecord()
        {
            BamlPIMappingRecord piMappingRecord = (BamlPIMappingRecord)_currentBamlRecord;
            BamlAssemblyInfoRecord assemblyInfo = MapTable.GetAssemblyInfoFromId(
                                                                  piMappingRecord.AssemblyId);
            if (assemblyInfo == null)
            {
                throw new InvalidOperationException(SR.Get(SRID.ParserMapPIMissingAssembly));
            }

            // If this mapping has not already been set up, then set it now
            if (!_parserContext.XamlTypeMapper.PITable.Contains(piMappingRecord.XmlNamespace))
            {
                // Add information to the MappingPI hashtable and the reverse lookup
                // hashtable.
                _parserContext.XamlTypeMapper.AddMappingProcessingInstruction(piMappingRecord.XmlNamespace,
                                                   piMappingRecord.ClrNamespace,
                                                   assemblyInfo.AssemblyFullName);
            }

            ClearProperties();
            NodeTypeInternal = BamlNodeType.PIMapping;
            _name = "Mapping";
            _localName = _name;
            _ownerTypeName = string.Empty;

            // Set the xml namespace, clr namespace and assembly properties as defined
            // in the mapping PI.
            _xmlNamespace = piMappingRecord.XmlNamespace;
            _clrNamespace = piMappingRecord.ClrNamespace;
            _assemblyName = assemblyInfo.AssemblyFullName;

            StringBuilder valueBuilder = new StringBuilder(100);
            valueBuilder.Append("XmlNamespace=\"");
            valueBuilder.Append(_xmlNamespace);
            valueBuilder.Append("\" ClrNamespace=\"");
            valueBuilder.Append(_clrNamespace);
            valueBuilder.Append("\" Assembly=\"");
            valueBuilder.Append(_assemblyName);
            valueBuilder.Append("\"");
            _value = valueBuilder.ToString();

        }
 public T FindPreviousSibling <T>(BamlNodeType type, bool throwIfMissing = false)
     where T : BamlNode
 {
     return((T)FindPreviousSibling(n => n.NodeType == type, throwIfMissing));
 }
        /***************************************************************************\
        *
        * BamlReader.ReadNextRecord
        *
        * Read the next record, setting the ReadState, NodeType and other pertinent
        * information about the record just read.
        *
        \***************************************************************************/

        private void ReadNextRecord()
        {
            // If this is the first call to Read.  Then read the Version Header.
            if(_readState == ReadState.Initial)
            {
                _bamlRecordReader.ReadVersionHeader();
            }

            // We'll read in a loop until we get to a significant record.  Note that Assembly,
            // Type and Attribute records are read and processed, but the BamlReader never stops
            // on one of these records, since they are not externally exposed.
            bool keepOnReading = true;
            while (keepOnReading)
            {
                // We may already have a record that was previously read in but not
                // processed.  This occurs when we've looped through all the properties
                // on an element and have encountered a non-property record to stop
                // the loop.  In that case don't read another record and just process
                // the one we have.
                if (_haveUnprocessedRecord)
                {
                    _haveUnprocessedRecord = false;
                }
                else
                {
                    GetNextRecord();
                }

                // If the current baml record is null, then the stream is finished, closed
                // or something else that prevents us reading further, so treat this
                // as an end-of-file condition
                if (_currentBamlRecord == null)
                {
                    NodeTypeInternal = BamlNodeType.None;
                    _readState = ReadState.EndOfFile;
                    ClearProperties();
                    return;
                }


                // By default, the read state is interactive after a record has been read, and we
                // should stop reading after this record is processed.  This may be altered for
                // specific record types.
                _readState = ReadState.Interactive;
                keepOnReading = false;

                switch (_currentBamlRecord.RecordType)
                {
                    // The following three records are internal to the BAMLReader and
                    // are not exposed publicly.  They are used to update the map table
                    // that maps ids to assemblies, types and attributes.
                    case BamlRecordType.AssemblyInfo:
                        ReadAssemblyInfoRecord();
                        keepOnReading = true;
                        break;

                    case BamlRecordType.TypeInfo:
                    case BamlRecordType.TypeSerializerInfo:
                        MapTable.LoadTypeInfoRecord((BamlTypeInfoRecord)_currentBamlRecord);
                        keepOnReading = true;
                        break;

                    case BamlRecordType.AttributeInfo:
                        MapTable.LoadAttributeInfoRecord((BamlAttributeInfoRecord)_currentBamlRecord);
                        keepOnReading = true;
                        break;

                    case BamlRecordType.StringInfo:
                        MapTable.LoadStringInfoRecord((BamlStringInfoRecord)_currentBamlRecord);
                        keepOnReading = true;
                        break;

                    case BamlRecordType.ContentProperty:
                        // This is just a cache of meta-data, no visible effect.
                        ReadContentPropertyRecord();
                        keepOnReading = true;
                        break;

                    // The following records are publically exposed
                    case BamlRecordType.DocumentStart:
                        ReadDocumentStartRecord();
                        break;

                    case BamlRecordType.DocumentEnd:
                        ReadDocumentEndRecord();
                        break;

                    case BamlRecordType.PIMapping:
                        ReadPIMappingRecord();
                        break;

                    case BamlRecordType.LiteralContent:
                        ReadLiteralContentRecord();
                        break;

                    case BamlRecordType.ElementStart:
                    case BamlRecordType.StaticResourceStart:
                        ReadElementStartRecord();
                        break;

                    case BamlRecordType.ElementEnd:
                    case BamlRecordType.StaticResourceEnd:
                        ReadElementEndRecord();
                        break;

                    case BamlRecordType.PropertyComplexStart:
                    case BamlRecordType.PropertyArrayStart:
                    case BamlRecordType.PropertyIListStart:
                    case BamlRecordType.PropertyIDictionaryStart:
                        ReadPropertyComplexStartRecord();
                        break;

                    case BamlRecordType.PropertyComplexEnd:
                    case BamlRecordType.PropertyArrayEnd:
                    case BamlRecordType.PropertyIListEnd:
                    case BamlRecordType.PropertyIDictionaryEnd:
                        ReadPropertyComplexEndRecord();
                        break;

                    case BamlRecordType.Text:
                    case BamlRecordType.TextWithId:
                    case BamlRecordType.TextWithConverter:
                        ReadTextRecord();
                        break;

                    case BamlRecordType.DeferableContentStart:
                        ReadDeferableContentRecord();
                        keepOnReading = true;
                        break;

                    case BamlRecordType.ConstructorParametersStart:
                        ReadConstructorStart();
                        break;

                    case BamlRecordType.ConstructorParametersEnd:
                        ReadConstructorEnd();
                        break;

                    case BamlRecordType.ConnectionId:
                        ReadConnectionIdRecord();
                        break;

                    case BamlRecordType.StaticResourceId:
                        ReadStaticResourceId();
                        keepOnReading = true;
                        break;

                    default:
                        // Can't have any other type of record at this point.
                        throw new InvalidOperationException(SR.Get(SRID.ParserUnknownBaml,
                                         ((int)_currentBamlRecord.RecordType).ToString(CultureInfo.CurrentCulture)));
                }

            }

        }
        // Token: 0x06006EB5 RID: 28341 RVA: 0x001FCDA0 File Offset: 0x001FAFA0
        internal BamlLocalizableResource BuildFromNode(BamlLocalizableResourceKey key, BamlTreeNode node)
        {
            if (node.Formatted)
            {
                return(null);
            }
            BamlLocalizableResource bamlLocalizableResource = null;
            LocalizabilityAttribute localizabilityAttribute = null;
            BamlStartElementNode    node2 = null;
            string       localName        = null;
            BamlNodeType nodeType         = node.NodeType;

            if (nodeType != BamlNodeType.StartElement)
            {
                if (nodeType != BamlNodeType.Property)
                {
                    if (nodeType != BamlNodeType.LiteralContent)
                    {
                        Invariant.Assert(false);
                    }
                    else
                    {
                        string text;
                        this.GetLocalizabilityForElementNode((BamlStartElementNode)node.Parent, out localizabilityAttribute, out text);
                        node2     = (BamlStartElementNode)node.Parent;
                        localName = "$Content";
                    }
                }
                else
                {
                    BamlStartComplexPropertyNode bamlStartComplexPropertyNode = (BamlStartComplexPropertyNode)node;
                    if (LocComments.IsLocCommentsProperty(bamlStartComplexPropertyNode.OwnerTypeFullName, bamlStartComplexPropertyNode.PropertyName) || LocComments.IsLocLocalizabilityProperty(bamlStartComplexPropertyNode.OwnerTypeFullName, bamlStartComplexPropertyNode.PropertyName))
                    {
                        return(null);
                    }
                    this.GetLocalizabilityForPropertyNode(bamlStartComplexPropertyNode, out localizabilityAttribute);
                    localName = bamlStartComplexPropertyNode.PropertyName;
                    node2     = (BamlStartElementNode)node.Parent;
                }
            }
            else
            {
                node2 = (BamlStartElementNode)node;
                string text;
                this.GetLocalizabilityForElementNode(node2, out localizabilityAttribute, out text);
                localName = "$Content";
            }
            localizabilityAttribute = this.CombineAndPropagateInheritanceValues(node as ILocalizabilityInheritable, localizabilityAttribute);
            string content = null;

            if (localizabilityAttribute.Category != LocalizationCategory.NeverLocalize && localizabilityAttribute.Category != LocalizationCategory.Ignore && this.TryGetContent(key, node, out content))
            {
                bamlLocalizableResource            = new BamlLocalizableResource();
                bamlLocalizableResource.Readable   = (localizabilityAttribute.Readability == Readability.Readable);
                bamlLocalizableResource.Modifiable = (localizabilityAttribute.Modifiability == Modifiability.Modifiable);
                bamlLocalizableResource.Category   = localizabilityAttribute.Category;
                bamlLocalizableResource.Content    = content;
                bamlLocalizableResource.Comments   = this._resolver.GetStringComment(node2, localName);
            }
            return(bamlLocalizableResource);
        }
        /***************************************************************************\
        *
        * BamlReader.ReadTextRecord
        *
        * Read record containing text content that goes between the start and end
        * tags of an object.
        *
        \***************************************************************************/

        private void ReadTextRecord()
        {
            ClearProperties();

            BamlTextWithIdRecord textWithIdRecord = _currentBamlRecord as BamlTextWithIdRecord;
            if (textWithIdRecord != null)
            {
                // Get the value string from the string table, and cache it in the
                // record.
                textWithIdRecord.Value = MapTable.GetStringFromStringId(
                                                textWithIdRecord.ValueId);
            }

            BamlTextWithConverterRecord textWithConverter = _currentBamlRecord as BamlTextWithConverterRecord;
            if (textWithConverter != null)
            {
                short converterTypeId = textWithConverter.ConverterTypeId;
                Type converter = MapTable.GetTypeFromId(converterTypeId);
                _typeConverterAssemblyName = converter.Assembly.FullName;
                _typeConverterName = converter.FullName;
            }

            NodeTypeInternal = BamlNodeType.Text;
            _prefix = string.Empty;
            _value = ((BamlTextRecord)_currentBamlRecord).Value;
        }
 //---------------------------
 // Constructor
 //---------------------------
 internal BamlTreeNode(BamlNodeType type)
 {
     NodeType = type;
 }
        // Token: 0x06006EAC RID: 28332 RVA: 0x001FC674 File Offset: 0x001FA874
        private static bool ApplyChangeToBamlTree(BamlLocalizableResourceKey key, BamlLocalizableResource resource, BamlTreeUpdater.BamlTreeUpdateMap treeMap)
        {
            if (resource == null || resource.Content == null || !resource.Modifiable)
            {
                return(true);
            }
            if (!treeMap.LocalizationDictionary.Contains(key) && !treeMap.IsNewBamlTreeNode(key))
            {
                return(true);
            }
            BamlTreeNode bamlTreeNode = treeMap.MapKeyToBamlTreeNode(key);

            Invariant.Assert(bamlTreeNode != null);
            BamlNodeType nodeType = bamlTreeNode.NodeType;

            if (nodeType != BamlNodeType.StartElement)
            {
                if (nodeType != BamlNodeType.Property)
                {
                    if (nodeType == BamlNodeType.LiteralContent)
                    {
                        BamlLiteralContentNode bamlLiteralContentNode = (BamlLiteralContentNode)bamlTreeNode;
                        bamlLiteralContentNode.Content = BamlResourceContentUtil.UnescapeString(resource.Content);
                        if (bamlLiteralContentNode.Parent == null)
                        {
                            BamlTreeNode bamlTreeNode2 = treeMap.MapUidToBamlTreeElementNode(key.Uid);
                            if (bamlTreeNode2 == null)
                            {
                                return(false);
                            }
                            bamlTreeNode2.AddChild(bamlLiteralContentNode);
                        }
                    }
                }
                else
                {
                    BamlPropertyNode bamlPropertyNode = (BamlPropertyNode)bamlTreeNode;
                    bamlPropertyNode.Value = BamlResourceContentUtil.UnescapeString(resource.Content);
                    if (bamlPropertyNode.Parent == null)
                    {
                        BamlStartElementNode bamlStartElementNode = treeMap.MapUidToBamlTreeElementNode(key.Uid);
                        if (bamlStartElementNode == null)
                        {
                            return(false);
                        }
                        bamlStartElementNode.InsertProperty(bamlTreeNode);
                    }
                }
            }
            else
            {
                string b = null;
                if (treeMap.LocalizationDictionary.Contains(key))
                {
                    b = treeMap.LocalizationDictionary[key].Content;
                }
                if (resource.Content != b)
                {
                    BamlTreeUpdater.ReArrangeChildren(key, bamlTreeNode, resource.Content, treeMap);
                }
            }
            return(true);
        }
        // Token: 0x06006EAE RID: 28334 RVA: 0x001FC7C0 File Offset: 0x001FA9C0
        private static void MergeChildrenList(BamlLocalizableResourceKey key, BamlTreeUpdater.BamlTreeUpdateMap treeMap, BamlTreeNode parent, IList <BamlTreeNode> newChildren)
        {
            if (newChildren == null)
            {
                return;
            }
            List <BamlTreeNode> children = parent.Children;
            int           i             = 0;
            StringBuilder stringBuilder = new StringBuilder();

            if (children != null)
            {
                Hashtable hashtable = new Hashtable(newChildren.Count);
                foreach (BamlTreeNode bamlTreeNode in newChildren)
                {
                    if (bamlTreeNode.NodeType == BamlNodeType.StartElement)
                    {
                        BamlStartElementNode bamlStartElementNode = (BamlStartElementNode)bamlTreeNode;
                        if (bamlStartElementNode.Uid != null)
                        {
                            if (hashtable.ContainsKey(bamlStartElementNode.Uid))
                            {
                                treeMap.Resolver.RaiseErrorNotifyEvent(new BamlLocalizerErrorNotifyEventArgs(key, BamlLocalizerError.DuplicateElement));
                                return;
                            }
                            hashtable[bamlStartElementNode.Uid] = null;
                        }
                    }
                }
                parent.Children = null;
                for (int j = 0; j < children.Count - 1; j++)
                {
                    BamlTreeNode bamlTreeNode2 = children[j];
                    BamlNodeType nodeType      = bamlTreeNode2.NodeType;
                    if (nodeType != BamlNodeType.StartElement)
                    {
                        if (nodeType != BamlNodeType.Text)
                        {
                            parent.AddChild(bamlTreeNode2);
                        }
                    }
                    else
                    {
                        BamlStartElementNode bamlStartElementNode2 = (BamlStartElementNode)bamlTreeNode2;
                        if (bamlStartElementNode2.Uid != null)
                        {
                            if (!hashtable.ContainsKey(bamlStartElementNode2.Uid))
                            {
                                parent.Children = children;
                                treeMap.Resolver.RaiseErrorNotifyEvent(new BamlLocalizerErrorNotifyEventArgs(key, BamlLocalizerError.MismatchedElements));
                                return;
                            }
                            hashtable.Remove(bamlStartElementNode2.Uid);
                        }
                        while (i < newChildren.Count)
                        {
                            BamlTreeNode bamlTreeNode3 = newChildren[i++];
                            Invariant.Assert(bamlTreeNode3 != null);
                            if (bamlTreeNode3.NodeType == BamlNodeType.Text)
                            {
                                stringBuilder.Append(((BamlTextNode)bamlTreeNode3).Content);
                            }
                            else
                            {
                                BamlTreeUpdater.TryFlushTextToBamlNode(parent, stringBuilder);
                                parent.AddChild(bamlTreeNode3);
                                if (bamlTreeNode3.NodeType == BamlNodeType.StartElement)
                                {
                                    break;
                                }
                            }
                        }
                    }
                }
            }
            while (i < newChildren.Count)
            {
                BamlTreeNode bamlTreeNode4 = newChildren[i];
                Invariant.Assert(bamlTreeNode4 != null);
                if (bamlTreeNode4.NodeType == BamlNodeType.Text)
                {
                    stringBuilder.Append(((BamlTextNode)bamlTreeNode4).Content);
                }
                else
                {
                    BamlTreeUpdater.TryFlushTextToBamlNode(parent, stringBuilder);
                    parent.AddChild(bamlTreeNode4);
                }
                i++;
            }
            BamlTreeUpdater.TryFlushTextToBamlNode(parent, stringBuilder);
            parent.AddChild(new BamlEndElementNode());
        }
 //---------------------------
 // Constructor
 //---------------------------
 internal BamlTreeNode(BamlNodeType type)
 {
     NodeType = type;
 }    
        /***************************************************************************\
        *
        * BamlReader.ReadPropertyComplexStartRecord
        *
        * Read the start of a complex property.  This can be any type of complex
        * property, including arrays, ILists, IDictionaries, Clr properties or
        * dependency properties.
        *
        \***************************************************************************/

        private void ReadPropertyComplexStartRecord()
        {
            ClearProperties();
            _parserContext.PushScope();
            _prefixDictionary.PushScope();

            BamlNodeInfo nodeInfo = new BamlNodeInfo();

            SetCommonPropertyInfo(nodeInfo,
                      ((BamlPropertyComplexStartRecord)_currentBamlRecord).AttributeId);

            // Set instance variables to node info extracted from record.
            NodeTypeInternal = BamlNodeType.StartComplexProperty;
            _localName = nodeInfo.LocalName;
            int index = nodeInfo.Name.LastIndexOf(".", StringComparison.Ordinal);
            if (index > 0)
            {
                _ownerTypeName = nodeInfo.Name.Substring(0, index);
            }
            else
            {
                // Eg. xmlns property
                _ownerTypeName = string.Empty;
            }
            _name = nodeInfo.Name;
            _clrNamespace = nodeInfo.ClrNamespace;
            _assemblyName = nodeInfo.AssemblyName;
            _prefix = nodeInfo.Prefix;
            _xmlNamespace = nodeInfo.XmlNamespace;
            nodeInfo.RecordType = _currentBamlRecord.RecordType;


            _nodeStack.Push(nodeInfo);

            // Read the properties that may be part of the start tag
            ReadProperties();
        }
        /***************************************************************************\
        *
        * BamlReader.ReadConstructorEnd
        *
        * Read a <\x:ConstructorParameters   ...   > end tag, which indicates that
        * the previous objects are to be used as constructor parameters.
        *
        \***************************************************************************/

        private void ReadConstructorEnd()
        {
            ClearProperties();

            NodeTypeInternal = BamlNodeType.EndConstructor;

            // Pop information off the node stack that tells us what element this
            // is the end of.  Check to make sure the record on the stack is for a
            // start element.
            BamlNodeInfo nodeInfo = (BamlNodeInfo)_nodeStack.Pop();
            if (nodeInfo.RecordType != BamlRecordType.ConstructorParametersStart)
            {
                throw new InvalidOperationException(SR.Get(SRID.BamlScopeError,
                                                 _currentBamlRecord.RecordType.ToString(),
                                                 BamlRecordType.ConstructorParametersEnd.ToString()));
            }

            // read properties, if any, after this end tag.
            ReadProperties();
        }
        /***************************************************************************\
        *
        * BamlReader.ReadPropertyComplexEndRecord
        *
        * Read the end of a complex property.  This can be any type of complex
        * property, including arrays, ILists, IDictionaries, Clr properties or
        * dependency properties.
        *
        \***************************************************************************/

        private void ReadPropertyComplexEndRecord()
        {
            // Pop information off the node info stack that tells us what the starting
            // record was for this ending record.  Check to make sure it is the
            // correct type.  If not, throw an exception.
            BamlNodeInfo nodeInfo = (BamlNodeInfo)_nodeStack.Pop();
            BamlRecordType expectedType;
            switch (nodeInfo.RecordType)
            {
                case BamlRecordType.PropertyComplexStart:
                    expectedType = BamlRecordType.PropertyComplexEnd;
                    break;
                case BamlRecordType.PropertyArrayStart:
                    expectedType = BamlRecordType.PropertyArrayEnd;
                    break;
                case BamlRecordType.PropertyIListStart:
                    expectedType = BamlRecordType.PropertyIListEnd;
                    break;
                case BamlRecordType.PropertyIDictionaryStart:
                    expectedType = BamlRecordType.PropertyIDictionaryEnd;
                    break;
                default:
                    expectedType = BamlRecordType.Unknown;
                    break;
            }

            if (_currentBamlRecord.RecordType != expectedType)
            {
                throw new InvalidOperationException(SR.Get(SRID.BamlScopeError,
                                          _currentBamlRecord.RecordType.ToString(),
                                          expectedType.ToString()));
            }

            ClearProperties();
            NodeTypeInternal = BamlNodeType.EndComplexProperty;
            _name = nodeInfo.Name;
            _localName = nodeInfo.LocalName;
            int index = nodeInfo.Name.LastIndexOf(".", StringComparison.Ordinal);
            if (index > 0)
            {
                _ownerTypeName = nodeInfo.Name.Substring(0, index);
            }
            else
            {
                // Eg. xmlns property
                _ownerTypeName = string.Empty;
            }
            _assemblyName = nodeInfo.AssemblyName;
            _prefix = nodeInfo.Prefix;
            _xmlNamespace = nodeInfo.XmlNamespace;
            _clrNamespace = nodeInfo.ClrNamespace;
            _parserContext.PopScope();
            _prefixDictionary.PopScope();

            ReadProperties();
        }
        // Token: 0x06006EBA RID: 28346 RVA: 0x001FD2AC File Offset: 0x001FB4AC
        private LocalizabilityAttribute CombineAndPropagateInheritanceValues(ILocalizabilityInheritable node, LocalizabilityAttribute localizabilityFromSource)
        {
            if (node == null)
            {
                return(localizabilityFromSource);
            }
            if (node.InheritableAttribute != null)
            {
                if (node.IsIgnored)
                {
                    return(this.LocalizabilityIgnore);
                }
                return(node.InheritableAttribute);
            }
            else
            {
                if (localizabilityFromSource.Category != LocalizationCategory.Ignore && localizabilityFromSource.Category != LocalizationCategory.Inherit && localizabilityFromSource.Readability != Readability.Inherit && localizabilityFromSource.Modifiability != Modifiability.Inherit)
                {
                    node.InheritableAttribute = localizabilityFromSource;
                    return(node.InheritableAttribute);
                }
                ILocalizabilityInheritable localizabilityAncestor = node.LocalizabilityAncestor;
                LocalizabilityAttribute    inheritableAttribute   = localizabilityAncestor.InheritableAttribute;
                if (inheritableAttribute == null)
                {
                    BamlStartElementNode bamlStartElementNode = localizabilityAncestor as BamlStartElementNode;
                    if (bamlStartElementNode != null)
                    {
                        string text;
                        this.GetLocalizabilityForElementNode(bamlStartElementNode, out inheritableAttribute, out text);
                    }
                    else
                    {
                        BamlStartComplexPropertyNode node2 = localizabilityAncestor as BamlStartComplexPropertyNode;
                        this.GetLocalizabilityForPropertyNode(node2, out inheritableAttribute);
                    }
                    this.CombineAndPropagateInheritanceValues(localizabilityAncestor, inheritableAttribute);
                    inheritableAttribute = localizabilityAncestor.InheritableAttribute;
                }
                if (localizabilityFromSource.Category == LocalizationCategory.Ignore)
                {
                    node.InheritableAttribute = inheritableAttribute;
                    node.IsIgnored            = true;
                    return(this.LocalizabilityIgnore);
                }
                BamlTreeNode bamlTreeNode = (BamlTreeNode)node;
                BamlNodeType nodeType     = bamlTreeNode.NodeType;
                if (nodeType <= BamlNodeType.Property)
                {
                    if (nodeType != BamlNodeType.StartElement)
                    {
                        if (nodeType != BamlNodeType.Property)
                        {
                            goto IL_174;
                        }
                        goto IL_127;
                    }
                }
                else
                {
                    if (nodeType == BamlNodeType.StartComplexProperty)
                    {
                        goto IL_127;
                    }
                    if (nodeType != BamlNodeType.LiteralContent)
                    {
                        goto IL_174;
                    }
                }
                if (localizabilityFromSource.Category == LocalizationCategory.Inherit && localizabilityFromSource.Readability == Readability.Inherit && localizabilityFromSource.Modifiability == Modifiability.Inherit)
                {
                    node.InheritableAttribute = inheritableAttribute;
                    goto IL_174;
                }
                node.InheritableAttribute = this.CreateInheritedLocalizability(localizabilityFromSource, inheritableAttribute);
                goto IL_174;
IL_127:
                ILocalizabilityInheritable localizabilityInheritable = (ILocalizabilityInheritable)bamlTreeNode.Parent;
                LocalizabilityAttribute inheritable = this.CombineMinimumLocalizability(inheritableAttribute, localizabilityInheritable.InheritableAttribute);
                node.InheritableAttribute = this.CreateInheritedLocalizability(localizabilityFromSource, inheritable);
                if (localizabilityInheritable.IsIgnored && localizabilityFromSource.Category == LocalizationCategory.Inherit)
                {
                    node.IsIgnored = true;
                    return(this.LocalizabilityIgnore);
                }
IL_174:
                return(node.InheritableAttribute);
            }
        }
        /***************************************************************************\
        *
        * BamlReader.ReadConstructorStart
        *
        * Read a <x:ConstructorParameters   ...   > start tag, which indicates that
        * the following objects are to be used as constructor parameters.
        *
        \***************************************************************************/

        private void ReadConstructorStart()
        {
            ClearProperties();

            NodeTypeInternal = BamlNodeType.StartConstructor;

            // Push information on the node stack to indicate we have a start array
            BamlNodeInfo nodeInfo = new BamlNodeInfo();
            nodeInfo.RecordType = BamlRecordType.ConstructorParametersStart;

            _nodeStack.Push(nodeInfo);
        }
Exemple #22
0
        // Token: 0x06006E10 RID: 28176 RVA: 0x001FA87C File Offset: 0x001F8A7C
        private BamlTree LoadBamlImp(Stream bamlSteam)
        {
            this._reader = new BamlReader(bamlSteam);
            this._reader.Read();
            if (this._reader.NodeType != BamlNodeType.StartDocument)
            {
                throw new XamlParseException(SR.Get("InvalidStartOfBaml"));
            }
            this._root = new BamlStartDocumentNode();
            this.PushNodeToStack(this._root);
            Hashtable hashtable = new Hashtable(8);

IL_5C8:
            while (this._bamlTreeStack.Count > 0 && this._reader.Read())
            {
                switch (this._reader.NodeType)
                {
                case BamlNodeType.EndDocument:
                {
                    BamlTreeNode node = new BamlEndDocumentNode();
                    this.AddChildToCurrentParent(node);
                    this.PopStack();
                    break;
                }

                case BamlNodeType.ConnectionId:
                case BamlNodeType.Property:
                case BamlNodeType.ContentProperty:
                case BamlNodeType.XmlnsProperty:
                case BamlNodeType.IncludeReference:
                case BamlNodeType.DefAttribute:
                case BamlNodeType.PresentationOptionsAttribute:
                    goto IL_2DF;

                case BamlNodeType.StartElement:
                {
                    BamlTreeNode node2 = new BamlStartElementNode(this._reader.AssemblyName, this._reader.Name, this._reader.IsInjected, this._reader.CreateUsingTypeConverter);
                    this.PushNodeToStack(node2);
                    break;
                }

                case BamlNodeType.EndElement:
                {
                    BamlTreeNode node3 = new BamlEndElementNode();
                    this.AddChildToCurrentParent(node3);
                    this.PopStack();
                    break;
                }

                case BamlNodeType.StartComplexProperty:
                {
                    BamlStartComplexPropertyNode bamlStartComplexPropertyNode = new BamlStartComplexPropertyNode(this._reader.AssemblyName, this._reader.Name.Substring(0, this._reader.Name.LastIndexOf('.')), this._reader.LocalName);
                    bamlStartComplexPropertyNode.LocalizabilityAncestor = this.PeekPropertyStack(bamlStartComplexPropertyNode.PropertyName);
                    this.PushPropertyToStack(bamlStartComplexPropertyNode.PropertyName, bamlStartComplexPropertyNode);
                    this.PushNodeToStack(bamlStartComplexPropertyNode);
                    break;
                }

                case BamlNodeType.EndComplexProperty:
                {
                    BamlTreeNode node4 = new BamlEndComplexPropertyNode();
                    this.AddChildToCurrentParent(node4);
                    this.PopStack();
                    break;
                }

                case BamlNodeType.LiteralContent:
                {
                    BamlTreeNode node5 = new BamlLiteralContentNode(this._reader.Value);
                    this.AddChildToCurrentParent(node5);
                    break;
                }

                case BamlNodeType.Text:
                {
                    BamlTreeNode node6 = new BamlTextNode(this._reader.Value, this._reader.TypeConverterAssemblyName, this._reader.TypeConverterName);
                    this.AddChildToCurrentParent(node6);
                    break;
                }

                case BamlNodeType.RoutedEvent:
                {
                    BamlTreeNode node7 = new BamlRoutedEventNode(this._reader.AssemblyName, this._reader.Name.Substring(0, this._reader.Name.LastIndexOf('.')), this._reader.LocalName, this._reader.Value);
                    this.AddChildToCurrentParent(node7);
                    break;
                }

                case BamlNodeType.Event:
                {
                    BamlTreeNode node8 = new BamlEventNode(this._reader.Name, this._reader.Value);
                    this.AddChildToCurrentParent(node8);
                    break;
                }

                case BamlNodeType.PIMapping:
                {
                    BamlTreeNode node9 = new BamlPIMappingNode(this._reader.XmlNamespace, this._reader.ClrNamespace, this._reader.AssemblyName);
                    this.AddChildToCurrentParent(node9);
                    break;
                }

                case BamlNodeType.StartConstructor:
                {
                    BamlTreeNode node10 = new BamlStartConstructorNode();
                    this.AddChildToCurrentParent(node10);
                    break;
                }

                case BamlNodeType.EndConstructor:
                {
                    BamlTreeNode node11 = new BamlEndConstructorNode();
                    this.AddChildToCurrentParent(node11);
                    break;
                }

                default:
                    goto IL_2DF;
                }
                if (this._reader.HasProperties)
                {
                    hashtable.Clear();
                    this._reader.MoveToFirstProperty();
                    for (;;)
                    {
                        BamlNodeType nodeType = this._reader.NodeType;
                        switch (nodeType)
                        {
                        case BamlNodeType.ConnectionId:
                        {
                            BamlTreeNode node12 = new BamlConnectionIdNode(this._reader.ConnectionId);
                            this.AddChildToCurrentParent(node12);
                            break;
                        }

                        case BamlNodeType.StartElement:
                        case BamlNodeType.EndElement:
                            goto IL_58F;

                        case BamlNodeType.Property:
                        {
                            BamlPropertyNode bamlPropertyNode = new BamlPropertyNode(this._reader.AssemblyName, this._reader.Name.Substring(0, this._reader.Name.LastIndexOf('.')), this._reader.LocalName, this._reader.Value, this._reader.AttributeUsage);
                            bamlPropertyNode.LocalizabilityAncestor = this.PeekPropertyStack(bamlPropertyNode.PropertyName);
                            this.PushPropertyToStack(bamlPropertyNode.PropertyName, bamlPropertyNode);
                            this.AddChildToCurrentParent(bamlPropertyNode);
                            if (hashtable.Contains(this._reader.Name))
                            {
                                object obj = hashtable[this._reader.Name];
                                int    num = 2;
                                if (obj is BamlPropertyNode)
                                {
                                    ((BamlPropertyNode)obj).Index = 1;
                                }
                                else
                                {
                                    num = (int)obj;
                                }
                                bamlPropertyNode.Index       = num;
                                hashtable[this._reader.Name] = num + 1;
                            }
                            else
                            {
                                hashtable[this._reader.Name] = bamlPropertyNode;
                            }
                            break;
                        }

                        case BamlNodeType.ContentProperty:
                        {
                            BamlTreeNode node13 = new BamlContentPropertyNode(this._reader.AssemblyName, this._reader.Name.Substring(0, this._reader.Name.LastIndexOf('.')), this._reader.LocalName);
                            this.AddChildToCurrentParent(node13);
                            break;
                        }

                        case BamlNodeType.XmlnsProperty:
                        {
                            BamlTreeNode node14 = new BamlXmlnsPropertyNode(this._reader.LocalName, this._reader.Value);
                            this.AddChildToCurrentParent(node14);
                            break;
                        }

                        default:
                            if (nodeType != BamlNodeType.DefAttribute)
                            {
                                if (nodeType != BamlNodeType.PresentationOptionsAttribute)
                                {
                                    goto Block_6;
                                }
                                BamlTreeNode node15 = new BamlPresentationOptionsAttributeNode(this._reader.Name, this._reader.Value);
                                this.AddChildToCurrentParent(node15);
                            }
                            else
                            {
                                if (this._reader.Name == "Uid")
                                {
                                    ((BamlStartElementNode)this._currentParent).Uid = this._reader.Value;
                                }
                                BamlTreeNode node16 = new BamlDefAttributeNode(this._reader.Name, this._reader.Value);
                                this.AddChildToCurrentParent(node16);
                            }
                            break;
                        }
                        if (!this._reader.MoveToNextProperty())
                        {
                            goto IL_5C8;
                        }
                    }
Block_6:
IL_58F:
                    throw new XamlParseException(SR.Get("UnRecognizedBamlNodeType", new object[]
                    {
                        this._reader.NodeType
                    }));
                }
                continue;
IL_2DF:
                throw new XamlParseException(SR.Get("UnRecognizedBamlNodeType", new object[]
                {
                    this._reader.NodeType
                }));
            }
            if (this._reader.Read() || this._bamlTreeStack.Count > 0)
            {
                throw new XamlParseException(SR.Get("InvalidEndOfBaml"));
            }
            return(new BamlTree(this._root, this._nodeCount));
        }
        /// <summary>
        /// Move to the next property for this element or object.
        /// Return true if there is a next property; false if there are no more properties.
        /// </summary>
        public bool MoveToNextProperty()
        {
            if (_propertiesIndex < _properties.Count - 1)
            {
                _propertiesIndex++;
                object obj = _properties[_propertiesIndex];

                BamlPropertyInfo info = obj as BamlPropertyInfo;
                if (info != null)
                {
                    _name = info.Name;
                    _localName = info.LocalName;
                    int index = info.Name.LastIndexOf(".", StringComparison.Ordinal);
                    if (index > 0)
                    {
                        _ownerTypeName = info.Name.Substring(0, index);
                    }
                    else
                    {
                        // Eg. xmlns property
                        _ownerTypeName = string.Empty;
                    }
                    _value = info.Value;
                    _assemblyName = info.AssemblyName;
                    _prefix = info.Prefix;
                    _xmlNamespace = info.XmlNamespace;
                    _clrNamespace = info.ClrNamespace;
                    _connectionId = 0;
                    _contentPropertyName = string.Empty;
                    _attributeUsage = info.AttributeUsage;

                    // There are several node types for properties, but for now the only one that
                    // doesn't map to BamlNodeType.Property is xml namespace declarations.
                    if (info.RecordType == BamlRecordType.XmlnsProperty)
                    {
                        NodeTypeInternal = BamlNodeType.XmlnsProperty;
                    }
                    else if (info.RecordType == BamlRecordType.DefAttribute)
                    {
                        NodeTypeInternal = BamlNodeType.DefAttribute;
                    }
                    else if (info.RecordType == BamlRecordType.PresentationOptionsAttribute)
                    {
                        NodeTypeInternal = BamlNodeType.PresentationOptionsAttribute;
                    }
                    else
                    {
                        NodeTypeInternal = BamlNodeType.Property;
                    }
                    return true;
                }

                BamlContentPropertyInfo cpInfo = obj as BamlContentPropertyInfo;
                if(null != cpInfo)
                {
                    _contentPropertyName = cpInfo.LocalName;
                    _connectionId = 0;
                    _prefix = string.Empty;
                    _name = cpInfo.Name;
                    int index = cpInfo.Name.LastIndexOf(".", StringComparison.Ordinal);
                    if (index > 0)
                    {
                        _ownerTypeName = cpInfo.Name.Substring(0, index);
                    }

                    _localName = cpInfo.LocalName;
                    _ownerTypeName = string.Empty;
                    _assemblyName = cpInfo.AssemblyName;
                    _xmlNamespace = string.Empty;
                    _clrNamespace = string.Empty;
                    _attributeUsage = BamlAttributeUsage.Default;
                    _value = cpInfo.LocalName;
                    NodeTypeInternal = BamlNodeType.ContentProperty;
                    return true;
                }
                // Otherwise it must be a ConnectionId.
                // Is there something we can Assert on for that?
                _connectionId = (Int32)obj;
                _contentPropertyName = string.Empty;
                _prefix = string.Empty;
                _name = string.Empty;
                _localName = string.Empty;
                _ownerTypeName = string.Empty;
                _assemblyName = string.Empty;
                _xmlNamespace = string.Empty;
                _clrNamespace = string.Empty;
                _attributeUsage = BamlAttributeUsage.Default;
                _value = _connectionId.ToString(CultureInfo.CurrentCulture);
                NodeTypeInternal = BamlNodeType.ConnectionId;
                return true;
            }
            else
            {
                return false;
            }
        }
        /***************************************************************************\
        *
        * BamlReader.ReadDocumentStartRecord
        *
        * Read the start of the document record.  This should contain some
        * version information.
        *
        \***************************************************************************/

        private void ReadDocumentStartRecord()
        {
            ClearProperties();
            NodeTypeInternal = BamlNodeType.StartDocument;

            BamlDocumentStartRecord documentStartRecord = (BamlDocumentStartRecord)_currentBamlRecord;
            _parserContext.IsDebugBamlStream = documentStartRecord.DebugBaml;

            // Push information on the node stack to indicate we have a start document
            BamlNodeInfo nodeInfo = new BamlNodeInfo();
            nodeInfo.RecordType = BamlRecordType.DocumentStart;
            _nodeStack.Push(nodeInfo);
        }
 public T FindLastChild <T>(BamlNodeType type, bool throwIfMissing = false)
     where T : BamlNode
 {
     return((T)FindLastChild(n => n.NodeType == type, throwIfMissing));
 }
        /***************************************************************************\
        *
        * BamlReader.ReadDocumentEndRecord
        *
        * Read the end of the document record.  This is used to flag that the end
        * of the file has been reached.
        *
        \***************************************************************************/

        private void ReadDocumentEndRecord()
        {
            // Pop information off the node stack to ensure we have matched all the
            // start and end nodes and have nothing left but the start document node.
            BamlNodeInfo nodeInfo = (BamlNodeInfo)_nodeStack.Pop();
            if (nodeInfo.RecordType != BamlRecordType.DocumentStart)
            {
                throw new InvalidOperationException(SR.Get(SRID.BamlScopeError,
                                                    nodeInfo.RecordType.ToString(),
                                                    "DocumentEnd"));
            }

            ClearProperties();
            NodeTypeInternal = BamlNodeType.EndDocument;
        }