Exemplo n.º 1
0
        private IEnumerable <XamlNode> ReadMemberNode(XamlDomMember memberNode)
        {
            if (memberNode.Items != null && memberNode.Items.Count > 0)
            {
                yield return(XamlNode.GetStartMember(memberNode));

                foreach (var itemNode in memberNode.Items)
                {
                    var objectNode = itemNode as XamlDomObject;
                    IEnumerable <XamlNode> enumerable;
                    if (objectNode != null)
                    {
                        enumerable = ReadObjectNode(objectNode);
                    }
                    else
                    {
                        enumerable = ReadValueNode(itemNode as XamlDomValue);
                    }

                    foreach (var node in enumerable)
                    {
                        yield return(node);
                    }
                }
                yield return(XamlNode.GetEndMember(memberNode));
            }
        }
Exemplo n.º 2
0
        public void WriteNode(XamlNode node)
        {
            Guard.ThrowIfNull(node, nameof(node));

            switch (node.NodeType)
            {
                case XamlNodeType.None:
                    break;
                case XamlNodeType.StartObject:
                    startObjectWriter.WriteStartObject(node.XamlType);
                    break;
                case XamlNodeType.EndObject:
                    WriteEndObject();
                    break;
                case XamlNodeType.StartMember:
                    startMemberWriter.WriteStartMember(node.Member);
                    break;
                case XamlNodeType.EndMember:
                    WriteEndMember();
                    break;
                case XamlNodeType.Value:
                    valueWriter.WriteValue(node.Value);
                    break;
                case XamlNodeType.GetObject:
                    getObjectWriter.WriteGetObject();
                    break;
                case XamlNodeType.NamespaceDeclaration:
                    WriteNamespace(node.NamespaceDeclaration);
                    break;
                default:
                    throw new InvalidOperationException($"Cannot handle this kind of node type: {node.NodeType}");
            }
        }
Exemplo n.º 3
0
        // =================== Logic Functions ========================

        private XamlNode Logic_LineInfo()
        {
            LineInfo lineInfo     = new LineInfo(LineNumber, LinePosition);
            XamlNode lineInfoNode = new XamlNode(lineInfo);

            return(lineInfoNode);
        }
Exemplo n.º 4
0
        public void Process(XamlNode node)
        {
            Command command;

            switch (node.NodeType)
            {
                case XamlNodeType.NamespaceDeclaration:
                    command = new NamespaceDeclarationCommand(this, node.NamespaceDeclaration);
                    break;
                case XamlNodeType.StartObject:
                    command = new StartObjectCommand(this, node.XamlType, rootInstance);
                    break;
                case XamlNodeType.StartMember:
                    command = new StartMemberCommand(this, GetMember(node.Member));
                    break;
                case XamlNodeType.Value:
                    command = new ValueCommand(this, (string)node.Value);
                    break;
                case XamlNodeType.EndObject:
                    command = new EndObjectCommand(this);
                    break;
                case XamlNodeType.EndMember:
                    command = new EndMemberCommand(this, topDownMemberValueContext);
                    break;
                case XamlNodeType.GetObject:
                    command = new GetObjectCommand(this);
                    break;
                default:
                    throw new InvalidOperationException();
            }

            command.Execute();
        }
Exemplo n.º 5
0
        private XamlNode Logic_Text()
        {
            string   text     = _tokenizer.TokenText;
            XamlNode textNode = new XamlNode(XamlNodeType.Value, text);

            return(textNode);
        }
        public IEnumerable <XamlNode> P_StartElement()
        {
            if (this._xamlScanner.NodeType != ScannerNodeType.ELEMENT)
            {
                throw new XamlUnexpectedParseException(this._xamlScanner, this._xamlScanner.NodeType, System.Xaml.SR.Get("StartElementRuleException"));
            }
            yield return(this.Logic_StartObject(this._xamlScanner.Type, this._xamlScanner.Namespace));

            this._xamlScanner.Read();
            if (this.ProvideLineInfo)
            {
                yield return(this.Logic_LineInfo());
            }
            while (this._xamlScanner.NodeType == ScannerNodeType.DIRECTIVE)
            {
                IEnumerator <XamlNode> enumerator = this.LogicStream_Attribute().GetEnumerator();
                while (enumerator.MoveNext())
                {
                    XamlNode current = enumerator.Current;
                    yield return(current);
                }
                this._xamlScanner.Read();
                if (this.ProvideLineInfo)
                {
                    yield return(this.Logic_LineInfo());
                }
            }
        }
        private IEnumerable <XamlNode> LogicStream_Attribute()
        {
            XamlMember propertyAttribute     = this._xamlScanner.PropertyAttribute;
            XamlText   propertyAttributeText = this._xamlScanner.PropertyAttributeText;

            if (this._xamlScanner.IsCtorForcingMember)
            {
                this._context.CurrentForcedToUseConstructor = true;
            }
            XamlNode iteratorVariable2 = new XamlNode(XamlNodeType.StartMember, propertyAttribute);

            yield return(iteratorVariable2);

            if (propertyAttributeText.LooksLikeAMarkupExtension)
            {
                MePullParser iteratorVariable3 = new MePullParser(this._context);
                foreach (XamlNode iteratorVariable4 in iteratorVariable3.Parse(propertyAttributeText.Text, this.LineNumber, this.LinePosition))
                {
                    yield return(iteratorVariable4);
                }
            }
            else
            {
                XamlNode iteratorVariable5 = new XamlNode(XamlNodeType.Value, propertyAttributeText.AttributeText);
                yield return(iteratorVariable5);
            }
            yield return(new XamlNode(XamlNodeType.EndMember));
        }
        public IEnumerable <XamlNode> P_PropertyElement()
        {
            ScannerNodeType nodeType = this._xamlScanner.NodeType;

            switch (nodeType)
            {
            case ScannerNodeType.PROPERTYELEMENT:
            {
                IEnumerator <XamlNode> enumerator = this.P_NonemptyPropertyElement().GetEnumerator();
                while (enumerator.MoveNext())
                {
                    XamlNode current = enumerator.Current;
                    yield return(current);
                }
                break;
            }

            default:
                throw new XamlUnexpectedParseException(this._xamlScanner, nodeType, System.Xaml.SR.Get("PropertyElementRuleException"));
                foreach (XamlNode iteratorVariable1 in this.P_EmptyPropertyElement())
                {
                    yield return(iteratorVariable1);
                }
                break;
            }
        }
Exemplo n.º 9
0
        /// <summary>
        /// It seems like BamlReader will always output 'x:Key' as last property. However, it must be specified as attribute in valid .xaml, so we move it to the front
        /// of the attribute list.
        /// </summary>
        void MoveXKeyToFront(XamlNode node)
        {
            foreach (XamlNode child in node.Children)
            {
                MoveXKeyToFront(child);
            }

            XamlObjectNode obj = node as XamlObjectNode;

            if (obj != null && obj.Children.Count > 0)
            {
                XamlMemberNode memberNode = obj.Children[obj.Children.Count - 1] as XamlMemberNode;
                if (memberNode != null && memberNode.Member == XamlLanguage.Key)
                {
                    // move memberNode in front of the first member node:
                    for (int i = 0; i < obj.Children.Count; i++)
                    {
                        if (obj.Children[i] is XamlMemberNode)
                        {
                            obj.Children.Insert(i, memberNode);
                            obj.Children.RemoveAt(obj.Children.Count - 1);
                            break;
                        }
                    }
                }
            }
        }
Exemplo n.º 10
0
        private IEnumerable <XamlNode> LogicStream_Attribute()
        {
            XamlMember property = _xamlScanner.PropertyAttribute;
            XamlText   text     = _xamlScanner.PropertyAttributeText;

            if (_xamlScanner.IsCtorForcingMember)
            {
                _context.CurrentForcedToUseConstructor = true;
            }

            XamlNode startProperty = new XamlNode(XamlNodeType.StartMember, property);

            yield return(startProperty);

            if (text.LooksLikeAMarkupExtension)
            {
                MePullParser me = new MePullParser(_context);
                foreach (XamlNode node in me.Parse(text.Text, LineNumber, LinePosition))
                {
                    yield return(node);
                }
            }
            else
            {
                XamlNode textNode = new XamlNode(XamlNodeType.Value, text.AttributeText);
                yield return(textNode);
            }
            yield return(new XamlNode(XamlNodeType.EndMember));
        }
Exemplo n.º 11
0
        private XamlNode Logic_StartPositionalParameters()
        {
            _context.CurrentMember = XamlLanguage.PositionalParameters;

            XamlNode startProperty = new XamlNode(XamlNodeType.StartMember, XamlLanguage.PositionalParameters);

            return(startProperty);
        }
Exemplo n.º 12
0
        /// <summary>
        ///   Convert from Xaml read by a token reader into baml being written
        ///   out by a record writer.  The context gives mapping information.
        /// </summary>
#if !PBTCOMPILER
        //CASRemoval:[StrongNameIdentityPermission(SecurityAction.InheritanceDemand, PublicKey = Microsoft.Internal.BuildInfo.WCP_PUBLIC_KEY_STRING)]
#endif        
        internal virtual void ConvertXamlToBaml (
            XamlReaderHelper          tokenReader,
            ParserContext       context,
            XamlNode            xamlNode,
            BamlRecordWriter    bamlWriter)
        {
            throw new InvalidOperationException(SR.Get(SRID.InvalidDeSerialize));
        }
Exemplo n.º 13
0
        /// <summary>
        ///   Convert from Xaml read by a token reader into baml being written
        ///   out by a record writer.  The context gives mapping information.
        /// </summary>
#if !PBTCOMPILER
        //CASRemoval:[StrongNameIdentityPermission(SecurityAction.InheritanceDemand, PublicKey = Microsoft.Internal.BuildInfo.WCP_PUBLIC_KEY_STRING)]
#endif
        internal virtual void ConvertXamlToBaml(
            XamlReaderHelper tokenReader,
            ParserContext context,
            XamlNode xamlNode,
            BamlRecordWriter bamlWriter)
        {
            throw new InvalidOperationException(SR.Get(SRID.InvalidDeSerialize));
        }
Exemplo n.º 14
0
 public ReaderDelegate(XamlSchemaContext schemaContext, XamlNodeNextDelegate next, bool hasLineInfo)
     : base(schemaContext)
 {
     _nextDelegate    = next;
     _currentNode     = new XamlNode(XamlNode.InternalNodeType.StartOfStream);
     _currentLineInfo = null;
     _hasLineInfo     = hasLineInfo;
 }
Exemplo n.º 15
0
        private XamlNode Logic_PrefixDefinition()
        {
            string   prefix = _xamlScanner.Prefix;
            string   xamlNs = _xamlScanner.Namespace;
            XamlNode addNs  = new XamlNode(XamlNodeType.NamespaceDeclaration, new NamespaceDeclaration(xamlNs, prefix));

            return(addNs);
        }
Exemplo n.º 16
0
        private void Initialize(XmlReader givenXmlReader, XamlSchemaContext schemaContext, XamlTextReaderSettings settings)
        {
            XmlReader myXmlReader;

            if (givenXmlReader == null)
            {
                throw new ArgumentNullException("XmlReader is null");
            }

            _mergedSettings = (settings == null) ? new XamlTextReaderSettings() : new XamlTextReaderSettings(settings);

            //Wrap the xmlreader with a XmlCompatReader instance to apply MarkupCompat rules.
            if (!_mergedSettings.SkipXmlCompatibilityProcessing)
            {
                XmlCompatibilityReader mcReader =
                    new XmlCompatibilityReader(givenXmlReader,
                                               new IsXmlNamespaceSupportedCallback(IsXmlNamespaceSupported)
                                               );
                myXmlReader = mcReader;
            }
            else
            {   // Don't wrap the xmlreader with XmlCompatReader.
                // Useful for uses where users want to keep mc: content in the XamlNode stream.
                // Or have already processed the markup compat and want that extra perf.
                // We need to go make sure the parser thinks it knows mc: uri,
                // in case SkipXmlCompatibilityProcessing is true... likely won't work yet.
                myXmlReader = givenXmlReader;
            }
            // Pick up the XmlReader settings to override the "settings" defaults.
            if (!String.IsNullOrEmpty(myXmlReader.BaseURI))
            {
                _mergedSettings.BaseUri = new Uri(myXmlReader.BaseURI);
            }
            if (myXmlReader.XmlSpace == XmlSpace.Preserve)
            {
                _mergedSettings.XmlSpacePreserve = true;
            }
            if (!String.IsNullOrEmpty(myXmlReader.XmlLang))
            {
                _mergedSettings.XmlLang = myXmlReader.XmlLang;
            }

            if (schemaContext == null)
            {
                schemaContext = new XamlSchemaContext();
            }

            _endOfStreamNode = new InternalNode(InternalNodeType.EndOfStream);

            _context = (XamlParserContext)XamlContext.CreateContext(UsageMode.Parser, schemaContext,
                                                                    _mergedSettings.LocalAssembly, false /*ignoreCanConvert*/);

            XamlScanner    xamlScanner = new XamlScanner(_context, myXmlReader, _mergedSettings);
            XamlPullParser parser      = new XamlPullParser(_context, xamlScanner, _mergedSettings);

            _nodeStream = new NodeStreamSorter(_context, parser, _mergedSettings);
            _current    = _endOfStreamNode; // user must call Read() before using properties.
        }
Exemplo n.º 17
0
 /// <summary>
 ///   Convert from Xaml read by a token reader into a live
 ///   object tree.  The context gives mapping information.
 /// </summary>
 //CASRemoval:[StrongNameIdentityPermission(SecurityAction.InheritanceDemand, PublicKey = Microsoft.Internal.BuildInfo.WCP_PUBLIC_KEY_STRING)]
 internal virtual void ConvertXamlToObject(
     XamlReaderHelper tokenReader,
     ReadWriteStreamManager streamManager,
     ParserContext context,
     XamlNode xamlNode,
     BamlRecordReader reader)
 {
     throw new InvalidOperationException(SR.Get(SRID.InvalidDeSerialize));
 }
Exemplo n.º 18
0
 /// <summary>
 ///   Convert from Xaml read by a token reader into a live
 ///   object tree.  The context gives mapping information.
 /// </summary>
 //CASRemoval:[StrongNameIdentityPermission(SecurityAction.InheritanceDemand, PublicKey = Microsoft.Internal.BuildInfo.WCP_PUBLIC_KEY_STRING)]
 internal virtual void ConvertXamlToObject (
     XamlReaderHelper             tokenReader,
     ReadWriteStreamManager streamManager,
     ParserContext          context,
     XamlNode               xamlNode,
     BamlRecordReader       reader)
 {
     throw new InvalidOperationException(SR.Get(SRID.InvalidDeSerialize));
 }
Exemplo n.º 19
0
        public XamlNode GetNextNode()
        {
            if (nodeQueue.Count != 0)
            {
                XamlNode x = (XamlNode)nodeQueue[0];
                nodeQueue.RemoveAt(0);
                return(x);
            }
            while (reader.Read())
            {
                Debug.WriteLine("XamlParser: NOW PARSING: " + reader.NodeType + "; " + reader.Name + "; " + reader.Value);
                if (goneTooFar())
                {
                    throw new XamlParseException(reader.LineNumber, reader.LinePosition,
                                                 "Too far: " + reader.NodeType + ", " + reader.Name);
                }
                if (currentState() != null && currentState().type == CurrentType.Code)
                {
                    processElementInCodeState();
                    continue;
                }
                switch (reader.NodeType)
                {
                case XmlNodeType.ProcessingInstruction:
                    parsePI();
                    break;

                case XmlNodeType.Element:
                    parseElement();
                    break;

                case XmlNodeType.EndElement:
                    parseEndElement();
                    break;

                case XmlNodeType.Text:
                    parseText();
                    break;

                case XmlNodeType.Whitespace:
                case XmlNodeType.Comment:
                    // skip whitespace and comments
                    break;

                default:
                    throw new XamlParseException(reader.LineNumber, reader.LinePosition, "Unknown element type " + reader.NodeType);
                }
                if (nodeQueue.Count != 0)
                {
                    XamlNode x = (XamlNode)nodeQueue[0];
                    nodeQueue.RemoveAt(0);
                    return(x);
                }
            }
            return(null);
        }
Exemplo n.º 20
0
        private XamlNode Logic_StartObject(XamlType xamlType, string xamlNamespace)
        {
            _context.PushScope();
            _context.CurrentType          = xamlType;
            _context.CurrentTypeNamespace = xamlNamespace;

            XamlNode startObj = new XamlNode(XamlNodeType.StartObject, xamlType);

            return(startObj);
        }
Exemplo n.º 21
0
        private XamlNode Logic_StartMember()
        {
            XamlMember member = _tokenizer.TokenProperty;

            _context.CurrentMember = member;

            XamlNode startMember = new XamlNode(XamlNodeType.StartMember, member);

            return(startMember);
        }
Exemplo n.º 22
0
        private XamlNode Logic_StartItemsProperty(XamlType collectionType)
        {
            _context.CurrentMember = XamlLanguage.Items;
            _context.CurrentInContainerDirective = true;

            var startProperty = new XamlNode(XamlNodeType.StartMember, XamlLanguage.Items);

            //SetLineInfo(startProperty);  // No line number info for implicit properties.
            return(startProperty);
        }
Exemplo n.º 23
0
        private XamlNode Logic_StartGetObjectFromMember(XamlType realType)
        {
            _context.PushScope();
            _context.CurrentType = realType;
            _context.CurrentInCollectionFromMember = true;

            var startObj = new XamlNode(XamlNodeType.GetObject);

            return(startObj);
        }
Exemplo n.º 24
0
        private XamlNode Logic_StartInitProperty(XamlType ownerType)
        {
            var initProperty = XamlLanguage.Initialization;

            _context.CurrentMember = initProperty;

            var startProperty = new XamlNode(XamlNodeType.StartMember, initProperty);

            // SetLineInfo(startProperty);  // No line number info for implicit properties.
            return(startProperty);
        }
Exemplo n.º 25
0
        private static bool NodeHasSameType(XamlType oldType, XamlNode node)
        {
            var xamlType = node.XamlType;
            if (xamlType != null)
            {
                var nodeHasSameType = xamlType.Equals(oldType);
                return nodeHasSameType;
            }

            return false;
        }
Exemplo n.º 26
0
        private XamlNode Logic_EndObject()
        {
            XamlType xamlType = _context.CurrentType;

            _context.PopScope();
            _context.CurrentPreviousChildType = xamlType;

            XamlNode endObj = new XamlNode(XamlNodeType.EndObject);

            return(endObj);
        }
Exemplo n.º 27
0
 private string getKeyFromNode(XamlNode n)
 {
     // we know that n is a XamlElementStartNode, but don't need that knowledge
     if (n is XamlKeyElementStartNode)
     {
         return(((XamlKeyElementStartNode)n).key);
     }
     else
     {
         return(null);
     }
 }
Exemplo n.º 28
0
        private XamlNode Logic_StartContentProperty(XamlMember property)
        {
            if (property == null)
            {
                property = XamlLanguage.UnknownContent;
            }
            _context.CurrentMember = property;
            var startProperty = new XamlNode(XamlNodeType.StartMember, property);

            // SetLineInfo(startProperty);  // No line number info for objects from members.
            return(startProperty);
        }
Exemplo n.º 29
0
 public override bool Read()
 {
     if (_nodeStream.MoveNext())
     {
         _current = _nodeStream.Current;
     }
     else
     {
         _current = _endOfStreamNode;
     }
     return(!IsEof);
 }
Exemplo n.º 30
0
        XamlNode getNextNode(object p)
        {
            MethodInfo getter = p.GetType().GetMethod("GetNextNode");

            Assert.IsTrue(getter != null, "Couldn't get next-node-getter");
            try {
                XamlNode n = (XamlNode)getter.Invoke(p, null);
                Assert.IsTrue(n != null, "Couldn't get next node");
                return(n);
            } catch (TargetInvocationException ex) {
                throw ex.InnerException;
            }
        }
        private IEnumerable <XamlNode> P_MarkupExtension(Found f)
        {
            if (this.Expect(MeTokenType.Open, "MarkupExtension ::= @'{' Expr '}'"))
            {
                this.NextToken();
                if (this._tokenizer.Token != MeTokenType.TypeName)
                {
                    this.SetBrokenRuleString("MarkupExtension ::= '{' @TYPENAME (Arguments)? '}'");
                }
                else
                {
                    XamlType tokenType = this._tokenizer.TokenType;
                    yield return(this.Logic_StartElement(tokenType, this._tokenizer.Namespace));

                    this.NextToken();
                    Found iteratorVariable1 = new Found();
                    switch (this._tokenizer.Token)
                    {
                    case MeTokenType.PropertyName:
                    case MeTokenType.String:
                    case MeTokenType.QuotedMarkupExtension:
                    case MeTokenType.Open:
                    {
                        IEnumerator <XamlNode> enumerator = this.P_Arguments(iteratorVariable1).GetEnumerator();
                        while (enumerator.MoveNext())
                        {
                            XamlNode current = enumerator.Current;
                            yield return(current);
                        }
                        break;
                    }

                    default:
                        this.SetBrokenRuleString("MarkupExtension ::= '{' TYPENAME @(Arguments)? '}'");
                        break;
                        yield return(this.Logic_EndObject());

                        this.NextToken();
                        f.found = true;
                        break;
                    }
                    if (iteratorVariable1.found && this.Expect(MeTokenType.Close, "MarkupExtension ::= '{' TYPENAME (Arguments)? @'}'"))
                    {
                        yield return(this.Logic_EndObject());

                        f.found = true;
                        this.NextToken();
                    }
                }
            }
        }
Exemplo n.º 32
0
        // ================================================

        private XamlNode Logic_StartElement(XamlType xamlType, string xamlNamespace)
        {
            _context.PushScope();
            _context.CurrentType          = xamlType;
            _context.CurrentTypeNamespace = xamlNamespace;

            _context.InitLongestConstructor(xamlType);
            _context.InitBracketCharacterCacheForType(xamlType);
            _context.CurrentBracketModeParseParameters = new BracketModeParseParameters(_context);

            var startObj = new XamlNode(XamlNodeType.StartObject, xamlType);

            return(startObj);
        }
Exemplo n.º 33
0
        void RemoveConnectionIds(XamlNode node, Dictionary <int, EventRegistration[]> eventMappings, XamlSchemaContext context)
        {
            foreach (XamlNode child in node.Children)
            {
                RemoveConnectionIds(child, eventMappings, context);
            }

            XamlObjectNode obj = node as XamlObjectNode;

            if (obj != null && obj.Children.Count > 0)
            {
                var removableNodes = new List <XamlMemberNode>();
                var addableNodes   = new List <XamlMemberNode>();
                foreach (XamlMemberNode memberNode in obj.Children.OfType <XamlMemberNode>())
                {
                    if (memberNode.Member == XamlLanguage.ConnectionId && memberNode.Children.Single() is XamlValueNode)
                    {
                        var value = memberNode.Children.Single() as XamlValueNode;
                        int id;
                        if (value.Value is string && int.TryParse(value.Value as string, out id) && eventMappings.ContainsKey(id))
                        {
                            var map = eventMappings[id];
                            foreach (var entry in map)
                            {
                                if (entry.IsAttached)
                                {
                                    var type   = context.GetXamlType(Type.GetType(entry.AttachSourceType));
                                    var member = new XamlMemberNode(new XamlMember(entry.EventName, type, true));
                                    member.Children.Add(new XamlValueNode(entry.MethodName));
                                    addableNodes.Add(member);
                                }
                                else
                                {
                                    var member = new XamlMemberNode(obj.Type.GetMember(entry.EventName));
                                    member.Children.Add(new XamlValueNode(entry.MethodName));
                                    addableNodes.Add(member);
                                }
                            }
                            removableNodes.Add(memberNode);
                        }
                    }
                }
                foreach (var rnode in removableNodes)
                {
                    node.Children.Remove(rnode);
                }
                node.Children.InsertRange(node.Children.Count > 1 ? node.Children.Count - 1 : 0, addableNodes);
            }
        }
Exemplo n.º 34
0
        private XamlNode Logic_StartMember(XamlMember member)
        {
            _context.CurrentMember = member;
            if (_xamlScanner.IsCtorForcingMember)
            {
                _context.CurrentForcedToUseConstructor = true;
            }
            XamlType memberXamlType = member.Type;

            _context.CurrentInContainerDirective = member.IsDirective && (memberXamlType != null && (memberXamlType.IsCollection || memberXamlType.IsDictionary));

            var startMember = new XamlNode(XamlNodeType.StartMember, member);

            return(startMember);
        }
        /// <summary>
        ///   Convert from Xaml read by a token reader into baml being written
        ///   out by a record writer.  The context gives mapping information.
        /// </summary>
        internal override void ConvertXamlToBaml (
            XamlReaderHelper             tokenReader,
            ParserContext          context,
            XamlNode               xamlNode,
            BamlRecordWriter       bamlWriter)
        {

            TemplateXamlParser templateParser = new TemplateXamlParser(tokenReader, context);
            templateParser.ParserHooks = _parserHooks;
            templateParser.BamlRecordWriter = bamlWriter;

            // Process the xamlNode that is passed in so that the <Template> element is written to baml
            templateParser.WriteElementStart((XamlElementStartNode)xamlNode);

            // Parse the entire Template section now, writing everything out directly to BAML.
            templateParser.Parse();
       }
        /// <summary>
        ///   Convert from Xaml read by a token reader into baml being written
        ///   out by a record writer.  The context gives mapping information.
        /// </summary>
        internal override void ConvertXamlToBaml(
            XamlReaderHelper tokenReader,
            ParserContext context,
            XamlNode xamlNode,
            BamlRecordWriter bamlWriter)
        {
            TemplateXamlParser templateParser = new TemplateXamlParser(tokenReader, context);

            templateParser.ParserHooks      = _parserHooks;
            templateParser.BamlRecordWriter = bamlWriter;

            // Process the xamlNode that is passed in so that the <Template> element is written to baml
            templateParser.WriteElementStart((XamlElementStartNode)xamlNode);

            // Parse the entire Template section now, writing everything out directly to BAML.
            templateParser.Parse();
        }
        internal override ParserAction LoadNode(XamlNode tokenNode)
        {   
            switch (tokenNode.TokenType)
            {
                case XamlNodeType.DocumentStart :
                {
                    // A single ParserHooks might be used to parse multiple bamls. 
                    // We need to clear the comments list at the begining of each baml.
                    _commentList.Clear();
                    _currentComment = new LocalizationComment();       
                    return ParserAction.Normal;
                }                
                case XamlNodeType.DefAttribute : 
                {
                    XamlDefAttributeNode node = (XamlDefAttributeNode) tokenNode;
                    if (node.Name == XamlReaderHelper.DefinitionUid)
                    {
                        _currentComment.Uid = node.Value;
                    }

                    return ParserAction.Normal;
                }
                case XamlNodeType.Property : 
                {
                    XamlPropertyNode node = (XamlPropertyNode) tokenNode; 

                    // When this parer hook is invoked, comments is always output to a seperate file.                    
                    if (LocComments.IsLocCommentsProperty(node.TypeFullName, node.PropName))
                    {
                        // try parse the value. Exception will be thrown if not valid.
                        LocComments.ParsePropertyComments(node.Value);
                        _currentComment.Comments = node.Value;
                        return ParserAction.Skip;  // skips outputing this node to baml
                    }

                    if (  _directivesToFile == LocalizationDirectivesToLocFile.All
                       && LocComments.IsLocLocalizabilityProperty(node.TypeFullName, node.PropName))                     
                    {
                        // try parse the value. Exception will be thrown if not valid.
                        LocComments.ParsePropertyLocalizabilityAttributes(node.Value);                        
                        _currentComment.Attributes = node.Value;
                        return ParserAction.Skip;  // skips outputing this node to baml                      
                    }

                    return ParserAction.Normal;                    
                }
                case XamlNodeType.EndAttributes : 
                {
                    FlushCommentToList(ref _currentComment);
                    return ParserAction.Normal;
                }
                case XamlNodeType.DocumentEnd : 
                {
                    //
                    // When reaching document end, we output all the comments we have collected 
                    // so far into a localization comment file. If the parsing was aborted in 
                    // MarkupCompilePass1, we would not out the incomplete set of comments because
                    // it will not reach document end.
                    //
                
                    if (_commentList.Count > 0)
                    {
                        string absoluteOutputPath = _compiler.TargetPath + _compiler.SourceFileInfo.RelativeSourceFilePath + SharedStrings.LocExtension;
                        MemoryStream memStream = new MemoryStream();

                        // TaskFileService.WriteFile adds BOM for UTF8 Encoding, thus don't add here 
                        // when creating XmlTextWriter.
                        using (XmlTextWriter writer = new XmlTextWriter(memStream, new UTF8Encoding(false)))
                        {
                            // output XML for each piece of comment                            
                            writer.Formatting = Formatting.Indented;
                            writer.WriteStartElement(LocComments.LocResourcesElement);    
                            writer.WriteAttributeString(LocComments.LocFileNameAttribute, _compiler.SourceFileInfo.RelativeSourceFilePath);
                            
                            foreach (LocalizationComment comment in _commentList)
                            {
                                writer.WriteStartElement(LocComments.LocCommentsElement);
                                writer.WriteAttributeString(LocComments.LocCommentIDAttribute, comment.Uid);

                                if (comment.Attributes != null)
                                {
                                    writer.WriteAttributeString(LocComments.LocLocalizabilityAttribute, comment.Attributes);                                    
                                }

                                if (comment.Comments != null)
                                {
                                    writer.WriteAttributeString(LocComments.LocCommentsAttribute, comment.Comments);
                                }

                                writer.WriteEndElement();
                            }
                            writer.WriteEndElement();

                            writer.Flush();
                            _compiler.TaskFileService.WriteFile(memStream.ToArray(), absoluteOutputPath);
                        }
                    }
                    
                    return ParserAction.Normal;
                }
                default: 
                {
                    return ParserAction.Normal;
                }
            }
        }        
        // Helper to write out the baml record, with line numbers obtained from
        // the associated xaml node.
        private void WriteAndReleaseRecord(
            BamlRecord    bamlRecord,
            XamlNode      xamlNode)
        {
            int lineNumber = xamlNode != null ? xamlNode.LineNumber : 0;
            int linePosition = xamlNode != null ? xamlNode.LinePosition : 0;

            // If we are currently parsing a deferable content section, then queue
            // up the records for later writing
            if (_deferLoadingSupport && _deferElementDepth > 0)
            {
                if (InStaticResourceSection)
                {
                    // Gather all the BamlRecords within the StaticResource section
                    _staticResourceRecordList.Add(new ValueDeferRecord(bamlRecord, lineNumber, linePosition));
                }
                else
                {
                    ValueDeferRecord deferRec = new ValueDeferRecord(bamlRecord,
                                                                     lineNumber,
                                                                     linePosition);
                    if (_deferEndOfStartReached)
                    {
                        // If we are starting/ending a complex property, and we are at the same
                        // depth as the defered element, then track a mode so that we write to
                        // the _deferElement array instead of the key/value arrays.
                        if(_deferElementDepth == 1 && xamlNode is XamlPropertyComplexStartNode)
                        {
                            _deferComplexPropertyDepth++;
                        }

                        if(_deferComplexPropertyDepth > 0)
                        {
                            _deferElement.Add(deferRec);

                            if(_deferElementDepth == 1 && xamlNode is XamlPropertyComplexEndNode)
                            {
                                _deferComplexPropertyDepth--;
                            }
                        }
                        else if (_deferKeyCollecting)
                        {
                            ((KeyDeferRecord)_deferKeys[_deferKeys.Count-1]).RecordList.Add(deferRec);
                        }
                        else
                        {
                            _deferValues.Add(deferRec);
                        }
                    }
                    else
                    {
                        _deferElement.Add(deferRec);
                    }
                }
            }
            else
            {
                WriteBamlRecord(bamlRecord,
                                lineNumber,
                                linePosition);

                BamlRecordManager.ReleaseWriteRecord(bamlRecord);
            }
        }
 private static bool IsMarkupExtension(XamlNode node)
 {
     Fx.Assert(node != null, "node != null");
     return node.Type != null && node.Type.IsMarkupExtension;
 }
Exemplo n.º 40
0
        /// <summary> 
        /// Override of the main switch statement that processes the xaml nodes. 
        /// </summary>
        /// <remarks> 
        ///  We need to control when cleanup is done and when the calling parse loop
        ///  is exited, so do this here.
        /// </remarks>
        internal override void ProcessXamlNode( 
               XamlNode xamlNode,
           ref bool     cleanup, 
           ref bool     done) 
        {
            switch(xamlNode.TokenType) 
            {
                // Ignore some types of xaml nodes, since they are not
                // relevent to template parsing.
                case XamlNodeType.DocumentStart: 
                case XamlNodeType.DocumentEnd:
                    break; 
 
                case XamlNodeType.ElementEnd:
                    base.ProcessXamlNode(xamlNode, ref cleanup, ref done); 
                    // If we're at the depth that we started out, then we must be done.  In that case quit
                    // and restore the XamlParser that the token reader was using before parsing templates.
                    if (_styleModeStack.Depth == 0)
                    { 
                        done = true;      // Stop the template parse
                        cleanup = false;  // Don't close the stream 
                        TokenReader.ControllingXamlParser = _previousXamlParser; 
                    }
                    break; 

                case XamlNodeType.PropertyArrayStart:
                case XamlNodeType.PropertyArrayEnd:
                case XamlNodeType.DefTag: 
                    ThrowException(SRID.TemplateTagNotSupported, xamlNode.TokenType.ToString(),
                                   xamlNode.LineNumber, xamlNode.LinePosition); 
                    break; 

#if PBTCOMPILER 
                case XamlNodeType.EndAttributes:
                    // if there's a DataType present but no x:Key, write out
                    // the key now based on the DataType
                    if (_dataTypePropertyNode != null && _dataTypePropertyNodeDepth == _styleModeStack.Depth) 
                    {
                        if (!_defNameFound) 
                        { 
                            WriteDataTypeKey(_dataTypePropertyNode);
                        } 
                        _dataTypePropertyNode = null;
                        _dataTypePropertyNodeDepth = -1;
                    }
 
                    base.ProcessXamlNode(xamlNode, ref cleanup, ref done);
                    break; 
#endif 

                // Most nodes are handled by the base XamlParser by creating a 
                // normal BamlRecord.
                default:
                    base.ProcessXamlNode(xamlNode, ref cleanup, ref done);
                    break; 
            }
 
        } 
Exemplo n.º 41
0
 private static bool RaisesLevel(XamlNode current)
 {
     return current.NodeType.ToString().Contains("Start") || current.NodeType == XamlNodeType.GetObject;
 }
Exemplo n.º 42
0
		void XamlNode_OnAttribute (XamlNode node, XamlAttribute ai)
		{
			if (!(CurrentElement is XamlObjectElement))
				return;
			if (IsStaticResourceElement ())
				return;
			currentNode = ai;
			ParseAttribute (CurrentElement as XamlObjectElement, ai);
			currentNode = node;
		}
Exemplo n.º 43
0
       /// <summary>
       /// Big switch to handle all the records.
       /// </summary>
       /// <param name="xamlNode"> Node received from TokenReader to process</param>
       /// <param name="cleanup"> True if end of stream reached and document is
       ///                        totally finished and should be closed </param>
       /// <param name="done"> True if done processing and want to exit.  Doesn't
       ///                     necessarily mean document is finished (see cleanup) </param>
       internal virtual void ProcessXamlNode(
               XamlNode xamlNode,
           ref bool     cleanup,
           ref bool     done)
       {
            switch(xamlNode.TokenType)
            {
                case XamlNodeType.DocumentStart:
                    XamlDocumentStartNode xamlDocumentStartNode =
                        (XamlDocumentStartNode) xamlNode;

                    WriteDocumentStart(xamlDocumentStartNode);

                    break;
                case XamlNodeType.DocumentEnd:
                    XamlDocumentEndNode xamlEndDocumentNode =
                        (XamlDocumentEndNode) xamlNode;
                    cleanup = true;
                    done = true;
                    WriteDocumentEnd(xamlEndDocumentNode);

                    break;

                case XamlNodeType.ElementStart:
                    XamlElementStartNode xamlElementNode =
                        (XamlElementStartNode) xamlNode;
                    WriteElementStart(xamlElementNode);

                    break;

                case XamlNodeType.ElementEnd:
                    XamlElementEndNode xamlEndElementNode =
                        (XamlElementEndNode) xamlNode;

                    WriteElementEnd(xamlEndElementNode);

                    break;
                case XamlNodeType.UnknownTagStart:
                    XamlUnknownTagStartNode xamlUnknownTagStartNode =
                        (XamlUnknownTagStartNode) xamlNode;

                    WriteUnknownTagStart(xamlUnknownTagStartNode);

                    break;
                case XamlNodeType.UnknownTagEnd:
                    XamlUnknownTagEndNode xamlUnknownTagEndNode =
                        (XamlUnknownTagEndNode) xamlNode;

                    WriteUnknownTagEnd(xamlUnknownTagEndNode);

                    break;
                case XamlNodeType.XmlnsProperty:

                    XamlXmlnsPropertyNode xamlXmlnsPropertyNode =
                        (XamlXmlnsPropertyNode) xamlNode;

                    WriteNamespacePrefix(xamlXmlnsPropertyNode);

                    break;

                case XamlNodeType.Property:

                    XamlPropertyNode xamlPropertyNode =
                        (XamlPropertyNode) xamlNode;
                    if (xamlPropertyNode.AttributeUsage == BamlAttributeUsage.RuntimeName)
                    {
                        _parserContext.XamlTypeMapper.ValidateNames(
                                            xamlPropertyNode.Value,
                                            xamlPropertyNode.LineNumber,
                                            xamlPropertyNode.LinePosition);
                    }

                    WriteProperty(xamlPropertyNode);
                    break;

                case XamlNodeType.PropertyWithExtension:

                    XamlPropertyWithExtensionNode xamlPropertyWithExtensionNode =
                        (XamlPropertyWithExtensionNode)xamlNode;
                    WritePropertyWithExtension(xamlPropertyWithExtensionNode);
                    break;

                case XamlNodeType.PropertyWithType:

                    XamlPropertyWithTypeNode xamlPropertyWithTypeNode =
                        (XamlPropertyWithTypeNode) xamlNode;
                    WritePropertyWithType(xamlPropertyWithTypeNode);
                    break;

                case XamlNodeType.UnknownAttribute:
                    XamlUnknownAttributeNode xamlUnknownAttributeNode =
                        (XamlUnknownAttributeNode) xamlNode;

                    WriteUnknownAttribute(xamlUnknownAttributeNode);

                    break;

                case XamlNodeType.PropertyComplexStart:
                    XamlPropertyComplexStartNode xamlPropertyComplexStartNode =
                        (XamlPropertyComplexStartNode) xamlNode;
                    WritePropertyComplexStart(xamlPropertyComplexStartNode);
                    break;

                case XamlNodeType.PropertyComplexEnd:
                    XamlPropertyComplexEndNode xamlPropertyComplexEndNode =
                        (XamlPropertyComplexEndNode) xamlNode;
                    WritePropertyComplexEnd(xamlPropertyComplexEndNode);
                    break;

                case XamlNodeType.LiteralContent:
                    XamlLiteralContentNode xamlLiteralContentNode =
                        (XamlLiteralContentNode) xamlNode;
                    WriteLiteralContent(xamlLiteralContentNode);
                    break;

                case XamlNodeType.Text:
                    XamlTextNode xamlTextNode =
                        (XamlTextNode) xamlNode;
                    WriteText(xamlTextNode);
                    break;

                case XamlNodeType.ClrEvent:
                    XamlClrEventNode xamlClrEventNode =
                        (XamlClrEventNode) xamlNode;
                    WriteClrEvent(xamlClrEventNode);
                    break;


                case XamlNodeType.PropertyArrayStart:
                    XamlPropertyArrayStartNode xamlPropertyArrayStartNode =
                        (XamlPropertyArrayStartNode) xamlNode;
                    WritePropertyArrayStart(xamlPropertyArrayStartNode);
                    break;

                case XamlNodeType.PropertyArrayEnd:
                    XamlPropertyArrayEndNode xamlPropertyArrayEndNode =
                        (XamlPropertyArrayEndNode) xamlNode;
                    WritePropertyArrayEnd(xamlPropertyArrayEndNode);
                    break;

                case XamlNodeType.PropertyIListStart:
                    XamlPropertyIListStartNode xamlPropertyIListStartNode =
                        (XamlPropertyIListStartNode) xamlNode;
                    WritePropertyIListStart(xamlPropertyIListStartNode);
                    break;

                case XamlNodeType.PropertyIListEnd:
                    XamlPropertyIListEndNode xamlPropertyIListEndNode =
                        (XamlPropertyIListEndNode) xamlNode;
                    WritePropertyIListEnd(xamlPropertyIListEndNode);
                    break;

                case XamlNodeType.PropertyIDictionaryStart:
                    XamlPropertyIDictionaryStartNode xamlPropertyIDictionaryStartNode =
                        (XamlPropertyIDictionaryStartNode) xamlNode;
                    WritePropertyIDictionaryStart(xamlPropertyIDictionaryStartNode);
                    break;

                case XamlNodeType.PropertyIDictionaryEnd:
                    XamlPropertyIDictionaryEndNode xamlPropertyIDictionaryEndNode =
                        (XamlPropertyIDictionaryEndNode) xamlNode;
                    WritePropertyIDictionaryEnd(xamlPropertyIDictionaryEndNode);
                    break;

                case XamlNodeType.DefTag:
                    XamlDefTagNode xamlDefTagNode =
                        (XamlDefTagNode) xamlNode;
                    WriteDefTag(xamlDefTagNode);

                    break;

                case XamlNodeType.DefKeyTypeAttribute:
                    XamlDefAttributeKeyTypeNode xamlDefAttributeKeyTypeNode =
                        (XamlDefAttributeKeyTypeNode) xamlNode;
                    WriteDefAttributeKeyType(xamlDefAttributeKeyTypeNode);
                    break;

                case XamlNodeType.DefAttribute:
                    XamlDefAttributeNode xamlDefAttributeNode =
                        (XamlDefAttributeNode) xamlNode;

                    if (xamlDefAttributeNode.AttributeUsage == BamlAttributeUsage.RuntimeName)
                    {
                        _parserContext.XamlTypeMapper.ValidateNames(
                                            xamlDefAttributeNode.Value,
                                            xamlDefAttributeNode.LineNumber,
                                            xamlDefAttributeNode.LinePosition);
                    }

                    WriteDefAttributeCore(xamlDefAttributeNode);
                    break;

                case XamlNodeType.PresentationOptionsAttribute:
                    XamlPresentationOptionsAttributeNode xamlPresentationOptionsAttributeNode =
                        (XamlPresentationOptionsAttributeNode) xamlNode;
                    WritePresentationOptionsAttribute(xamlPresentationOptionsAttributeNode);
                    break;

                case XamlNodeType.PIMapping:
                    XamlPIMappingNode xamlPIMappingNode =
                        (XamlPIMappingNode) xamlNode;
                    WritePIMapping(xamlPIMappingNode);
                    break;

                // The following tokens that are used primarily by the markup compiler
                case XamlNodeType.EndAttributes:
                    XamlEndAttributesNode xamlEndAttributesNode =
                        (XamlEndAttributesNode) xamlNode;
                    // if first tag and haven't alredy set the ParseMode
                    // set it to synchronous.
                    if (0 == xamlEndAttributesNode.Depth)
                    {
                        if (XamlParseMode == XamlParseMode.Uninitialized)
                        {
                            XamlParseMode = XamlParseMode.Synchronous;
                        }
                    }
                    WriteEndAttributes(xamlEndAttributesNode);
                    break;

                case XamlNodeType.KeyElementStart:
                    XamlKeyElementStartNode xamlKeyElementStartNode =
                        (XamlKeyElementStartNode) xamlNode;
                    WriteKeyElementStart(xamlKeyElementStartNode);
                    break;

                case XamlNodeType.KeyElementEnd:
                    XamlKeyElementEndNode xamlKeyElementEndNode =
                        (XamlKeyElementEndNode) xamlNode;
                    WriteKeyElementEnd(xamlKeyElementEndNode);
                    break;

                case XamlNodeType.ConstructorParametersEnd:
                    XamlConstructorParametersEndNode xamlConstructorParametersEndNode =
                        (XamlConstructorParametersEndNode) xamlNode;
                    WriteConstructorParametersEnd(xamlConstructorParametersEndNode);
                    break;

                case XamlNodeType.ConstructorParametersStart:
                    XamlConstructorParametersStartNode xamlConstructorParametersStartNode =
                        (XamlConstructorParametersStartNode) xamlNode;
                    WriteConstructorParametersStart(xamlConstructorParametersStartNode);
                    break;

                case XamlNodeType.ContentProperty:
                    XamlContentPropertyNode xamlContentPropertyNode =
                        (XamlContentPropertyNode)xamlNode;
                    WriteContentProperty(xamlContentPropertyNode);
                    break;

                case XamlNodeType.ConstructorParameterType:
                    XamlConstructorParameterTypeNode xamlConstructorParameterTypeNode =
                        (XamlConstructorParameterTypeNode)xamlNode;
                    WriteConstructorParameterType(xamlConstructorParameterTypeNode);
                    break;
                default:
                    Debug.Assert(false,"Unknown Xaml Token.");
                    break;
            }

       }
Exemplo n.º 44
0
        /// <summary>
        /// Override of the main switch statement that processes the xaml nodes.
        /// </summary>
        /// <remarks> 
        ///  We need to control when cleanup is done and when the calling parse loop
        ///  is exited, so do this here. 
        /// </remarks> 
        internal override void ProcessXamlNode(
               XamlNode xamlNode, 
           ref bool     cleanup,
           ref bool     done)
        {
            switch(xamlNode.TokenType) 
            {
                // Ignore some types of xaml nodes, since they are not 
                // relevent to style parsing. 
                case XamlNodeType.DocumentStart:
                case XamlNodeType.DocumentEnd: 
                    break;

                case XamlNodeType.ElementEnd:
                    base.ProcessXamlNode(xamlNode, ref cleanup, ref done); 
                    // If we're at the depth that we started out, then we must be done.  In that case quit
                    // and restore the XamlParser that the token reader was using before parsing styles. 
                    if (_styleModeStack.Depth == 0) 
                    {
                        done = true;      // Stop the style parse 
                        cleanup = false;  // Don't close the stream
                        TokenReader.ControllingXamlParser = _previousXamlParser;
                    }
                    break; 

                case XamlNodeType.PropertyArrayStart: 
                case XamlNodeType.PropertyArrayEnd: 
                case XamlNodeType.DefTag:
                    ThrowException(SRID.StyleTagNotSupported, xamlNode.TokenType.ToString(), 
                                   xamlNode.LineNumber, xamlNode.LinePosition);
                    break;

                // Most nodes are handled by the base XamlParser by creating a 
                // normal BamlRecord.
                default: 
                    base.ProcessXamlNode(xamlNode, ref cleanup, ref done); 
                    break;
            } 

        }
Exemplo n.º 45
0
		public object Parse (XamlNode node)
		{
			try {

				node.Parse (XamlNode_OnElementStart, XamlNode_OnElementEnd, XamlNode_OnAttribute);

			} catch (XamlParseException pe) {
				Console.WriteLine ("Exception while parsing string ({0}:{1})", pe.LineNumber, pe.LinePosition);
				Console.WriteLine (pe);
				Console.WriteLine ("string:");
				Console.WriteLine (node.OuterXml);
				throw pe;
			} catch (Exception e) {
				Console.WriteLine ("Exception while parsing string:");
				Console.WriteLine (e);
				Console.WriteLine ("string:");
				Console.WriteLine (node.OuterXml);
				throw ParseException ("Caught exception: {0}", e.Message);
			}

			XamlObjectElement obj = top_element as XamlObjectElement;
			if (obj == null) {
				// We actually return the type of the property here
				// or the object that it wraps
				return null;
			}

			return obj.Object;
		}
Exemplo n.º 46
0
        private MemberInfo GetPropertyOrEventInfo(XamlNode xamlNode, ref string member)
        {
            // Strip off namespace prefix from the event or property name and
            // map this to an xmlnamespace.  Also extract the class name, if present 
            string prefix = string.Empty;
            string target = member; 
            string propOrEvent = member; 
            int dotIndex = member.LastIndexOf('.');
            if (-1 != dotIndex) 
            {
                target = propOrEvent.Substring(0, dotIndex);
                member = propOrEvent.Substring(dotIndex + 1);
            } 
            int colonIndex = target.IndexOf(':');
            if (-1 != colonIndex) 
            { 
                // If using .net then match against the class.
                prefix = target.Substring(0, colonIndex); 
                if (-1 == dotIndex)
                {
                    member = target.Substring(colonIndex + 1);
                } 
            }
 
            string xmlNamespace = TokenReader.XmlReader.LookupNamespace(prefix); 
            Type targetType = null;
 
            // Get the type associated with the property or event from the XamlTypeMapper and
            // use this to resolve the property or event into an EventInfo, PropertyInfo
            // or MethodInfo
            if (-1 != dotIndex) 
            {
                targetType = XamlTypeMapper.GetTypeFromBaseString(target, ParserContext, false); 
            } 
            else if (_styleTargetTypeString != null)
            { 
                targetType = XamlTypeMapper.GetTypeFromBaseString(_styleTargetTypeString, ParserContext, false);
                target = _styleTargetTypeString;
            }
            else if (_styleTargetTypeType != null) 
            {
                targetType = _styleTargetTypeType; 
                target = targetType.Name; 
            }
 
            MemberInfo memberInfo = null;
            if (targetType != null)
            {
                string objectName = propOrEvent; 
                memberInfo = XamlTypeMapper.GetClrInfo(
                                        _inEventSetter, 
                                        targetType, 
                                        xmlNamespace,
                                        member, 
                                    ref objectName) as MemberInfo;
            }

            if (memberInfo != null) 
            {
                if (!_inEventSetter) 
                { 
                    PropertyInfo pi = memberInfo as PropertyInfo;
                    if (pi != null) 
                    {
                        // For trigger condition only allow if public or internal getter
                        if (_inSetterDepth < 0 && _styleModeStack.Mode == StyleMode.TriggerBase)
                        { 
                            if (!XamlTypeMapper.IsAllowedPropertyGet(pi))
                            { 
                                ThrowException(SRID.ParserCantSetTriggerCondition, 
                                               pi.Name,
                                               xamlNode.LineNumber, 
                                               xamlNode.LinePosition);
                            }
                        }
                        else // for general Setters check prop setters 
                        {
                            if (!XamlTypeMapper.IsAllowedPropertySet(pi)) 
                            { 
                                ThrowException(SRID.ParserCantSetAttribute,
                                               "Property Setter", 
                                               pi.Name,
                                               "set",
                                               xamlNode.LineNumber,
                                               xamlNode.LinePosition); 
                            }
                        } 
                    } 
                }
            } 
            // local properties and events will be added to the baml in pass2 of the compilation.
            // so don't throw now.
            else
#if PBTCOMPILER 
                if (!IsLocalPass1)
#endif 
            { 
                if (targetType != null)
                { 
                    ThrowException(SRID.StyleNoPropOrEvent,
                                   (_inEventSetter ? "Event" : "Property"),
                                   member,
                                   targetType.FullName, 
                                   xamlNode.LineNumber,
                                   xamlNode.LinePosition); 
                } 
                else
                { 
                    ThrowException(SRID.StyleNoTarget,
                                   (_inEventSetter ? "Event" : "Property"),
                                   member,
                                   xamlNode.LineNumber, 
                                   xamlNode.LinePosition);
                } 
            } 

            return memberInfo; 
        }
Exemplo n.º 47
0
 /// <summary>
 /// Called by parser after it determines what node type for
 /// the XML Node and has tokenized the xml node content. 
 /// </summary>
 /// <remarks>
 /// Node types are Resources, Code: Element Object, properties, events etc.
 /// The return value is a ParserAction value which indicates if the parser
 /// should: continue normal processing; skip this node and any children
 /// </remarks>
 internal virtual ParserAction LoadNode(XamlNode  tokenNode)
 {
     return ParserAction.Normal;
 }
 public XamlDebuggerXmlReader(XamlReader underlyingReader, IXamlLineInfo xamlLineInfo, TextReader textReader)
 {
     this.underlyingReader = underlyingReader;
     this.xamlLineInfo = xamlLineInfo;
     this.xmlReaderWithSourceLocation = new XmlReaderWithSourceLocation(textReader);
     this.initializationValueRanges = new Dictionary<XamlNode, DocumentRange>();
     // Parse the XML at once to get all the locations we wanted.
     while (this.xmlReaderWithSourceLocation.Read())
     {
     }
     this.schemaContext = underlyingReader.SchemaContext;
     this.objectDeclarationRecords = new Stack<XamlNode>();
     this.bufferedXamlNodes = new Queue<XamlNode>();
     this.current = this.CreateCurrentNode();
     this.SourceLocationFound += XamlDebuggerXmlReader.SetSourceLocation;
 }
Exemplo n.º 49
0
 public XamlParsingContext()
 {
     root = new XamlRootNode();
 }
 /// <summary>
 /// Инициализирует новый экземпляр класса <see cref="T:System.Object"/>.
 /// </summary>
 public XamlNamespaceResolver(XamlNode node)
 {
     this.node = node;
 }
Exemplo n.º 51
0
        /// <summary>
        /// If there are ParserHooks, call it with the current xamlNode and perform
        /// as directed by the callback.
        /// </summary>
        private void SetParserAction(XamlNode xamlNode)
        {
            // if no ParserHooks then process as normal
            if (null == ParserHooks)
            {
                ParserAction = ParserAction.Normal;
                return;
            }

            // if ParserHooks want to skip the current node and its children,
            // check for end of scope where it asked to be skipped.
            if (ParserAction == ParserAction.Skip)
            {
                if (xamlNode.Depth <= SkipActionDepthCount &&
                    xamlNode.TokenType == SkipActionToken)
                {
                    // We found the end token at the correct depth.  Reset the depth count
                    // so that in the next call we won't skip calling the ParserHooks.  Don't
                    // reset the ParserAction since we want to skip this end token.
                    SkipActionDepthCount = -1;
                    SkipActionToken = XamlNodeType.Unknown;
                    return;
                }
                else if (SkipActionDepthCount >= 0)
                {
                    return;
                }
            }

            // If we get to here, the ParserHooks want to be called.
            ParserAction = ParserHooks.LoadNode(xamlNode);

            // if the ParserHooks want to skip the current node and its children then
            // set the callback depth so that we'll know when to start processing again.
            if (ParserAction == ParserAction.Skip)
            {
                // For tokens with no scope (eg = attributes), don't set the depth so
                // that we will only skip once
                Debug.Assert(SkipActionDepthCount == -1);
                int tokenIndex = ((IList)XamlNode.ScopeStartTokens).IndexOf(xamlNode.TokenType);
                if (tokenIndex != -1)
                {
                    SkipActionDepthCount = xamlNode.Depth;
                    SkipActionToken = XamlNode.ScopeEndTokens[tokenIndex];
                }
            }
        }
Exemplo n.º 52
0
 public VisualizationNode(XamlNode xamlNode)
 {
     this.XamlNode = xamlNode;
     this.Children = new Collection<VisualizationNode>();
 }
Exemplo n.º 53
0
		private string getKeyFromNode(XamlNode n)
		{
			// we know that n is a XamlElementStartNode, but don't need that knowledge
			if (n is XamlKeyElementStartNode)
				return ((XamlKeyElementStartNode)n).key;
			else
				return null;
		}
Exemplo n.º 54
0
 public XamlNodeStackItem (XamlNode node, JToken token)
 {
     Node = node;
     JToken = token;
 }
Exemplo n.º 55
0
 private static bool LowersLevel(XamlNode current)
 {
     return current.NodeType.ToString().Contains("End");
 }
Exemplo n.º 56
0
		void XamlNode_OnElementEnd (XamlNode node)
		{
			reader = node;
			ParseEndElement ();
		}
Exemplo n.º 57
0
        //
        //  CommonElementStartProcessing 
        //
        //  This is used by WriteElementStart and WriteUnknownTagStart.  It is used 
        //  to keep style mode up-to-date. 
        //
        private void CommonElementStartProcessing (XamlNode xamlNode, Type elementType, ref StyleMode mode) 
        {

            if (mode == StyleMode.Base && _styleModeStack.Depth > 0 )
            { 
                if (_templateRootCount++ > 0)
                { 
                    ThrowException(SRID.TemplateNoMultipleRoots, 
                                   (elementType == null ? "Unknown tag" : elementType.Name),
                                   xamlNode.LineNumber, 
                                   xamlNode.LinePosition);
                }

                // Validate that the root is an FE or FCE.  If the type is unknown (and internal type), we'll 
                // catch this during template instantiation.
 
                if (elementType != null 
                    &&
                    !KnownTypes.Types[(int)KnownElements.FrameworkElement].IsAssignableFrom(elementType) 
                    &&
                    !KnownTypes.Types[(int)KnownElements.FrameworkContentElement].IsAssignableFrom(elementType))
                {
                    ThrowException(SRID.TemplateInvalidRootElementTag, 
                                   elementType.ToString(),
                                   xamlNode.LineNumber, 
                                   xamlNode.LinePosition); 
                }
 
                mode = StyleMode.VisualTree;
            }

        } 
Exemplo n.º 58
0
		void XamlNode_OnElementStart (XamlNode node) {
			reader = node;
			currentNode = (IXamlNode) node;

			switch (node.NodeType) {
				case XmlNodeType.Element:
					Log ("Next node: {0}", reader.Name);
					ParseElement ();
					break;
				case XmlNodeType.Text:
					Log ("Next node: {0}", reader.Name);
					ParseText ();
					break;
				case XmlNodeType.Whitespace:
					Log ("Next node: {0}", reader.Name);

					ParseWhitespace ();
					break;
				case XmlNodeType.SignificantWhitespace:
					Log ("Next node: {0}", reader.Name);
					ParseSignificantWhitespace ();
					break;
			}
		}
        private static XamlNode CreateCurrentNode(XamlReader xamlReader, IXamlLineInfo xamlLineInfo)
        {
            XamlNode currentNode = new XamlNode
            {
                Namespace = xamlReader.Namespace,
                NodeType = xamlReader.NodeType,
                Type = xamlReader.Type,
                Member = xamlReader.Member,
                Value = xamlReader.Value,
                LineNumber = xamlLineInfo.LineNumber,
                LinePosition = xamlLineInfo.LinePosition,
            };

            return currentNode;
        }
 internal XamlDebuggerXmlReader(TextReader underlyingTextReader, XamlSchemaContext schemaContext, Assembly localAssembly)
 {
     UnitTestUtility.Assert(underlyingTextReader != null, "underlyingTextReader should not be null and is ensured by caller.");
     this.xmlReaderWithSourceLocation = new XmlReaderWithSourceLocation(underlyingTextReader);
     this.underlyingReader = new XamlXmlReader(this.xmlReaderWithSourceLocation, schemaContext, new XamlXmlReaderSettings { ProvideLineInfo = true, LocalAssembly = localAssembly });
     this.xamlLineInfo = (IXamlLineInfo)this.underlyingReader;
     UnitTestUtility.Assert(this.xamlLineInfo.HasLineInfo, "underlyingReader is constructed with the ProvideLineInfo option above.");
     this.schemaContext = schemaContext;
     this.objectDeclarationRecords = new Stack<XamlNode>();
     this.initializationValueRanges = new Dictionary<XamlNode, DocumentRange>();
     this.bufferedXamlNodes = new Queue<XamlNode>();
     this.current = this.CreateCurrentNode();
     this.SourceLocationFound += XamlDebuggerXmlReader.SetSourceLocation;
 }