File: TextExpressionCompilerHelper.cs

package info (click to toggle)
mono 6.8.0.105%2Bdfsg-3.3
  • links: PTS, VCS
  • area: main
  • in suites: bookworm
  • size: 1,284,512 kB
  • sloc: cs: 11,172,132; xml: 2,850,069; ansic: 671,653; cpp: 122,091; perl: 59,366; javascript: 30,841; asm: 22,168; makefile: 20,093; sh: 15,020; python: 4,827; pascal: 925; sql: 859; sed: 16; php: 1
file content (106 lines) | stat: -rw-r--r-- 4,372 bytes parent folder | download | duplicates (7)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
// <copyright>
//   Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>

namespace System.Activities.XamlIntegration
{
    using System;
    using System.Activities.Expressions;
    using System.Collections.Generic;
    using System.IO;
    using System.Xaml;
    using System.Xml;

    internal static class TextExpressionCompilerHelper
    {
        public static void GetNamespacesLineInfo(string sourceXamlFileName, Dictionary<string, int> lineNumbersForNSes, Dictionary<string, int> lineNumbersForNSesForImpl)
        {
            // read until StartMember: TextExpression.NamespacesForImplementation OR TextExpression.Namespaces
            // create a subtree reader,
            // in the subtree, 
            // look for StartObject nodes of String type.  their values are added to either LineNumbersForNSes or LineNumbersForNSesForImpl dictionaries.
            if (!File.Exists(sourceXamlFileName))
            {
                return;
            }

            using (XmlReader xmlReader = XmlReader.Create(sourceXamlFileName))
            {
                using (XamlXmlReader xreader = new XamlXmlReader(xmlReader, new XamlXmlReaderSettings() { ProvideLineInfo = true }))
                {
                    bool hasHitFirstStartObj = false;
                    while (!hasHitFirstStartObj && xreader.Read())
                    {
                        if (xreader.NodeType == XamlNodeType.StartObject)
                        {
                            hasHitFirstStartObj = true;
                        }
                    }

                    if (hasHitFirstStartObj)
                    {
                        xreader.Read();
                        do
                        {
                            if (IsStartMemberTextExprNS(xreader))
                            {
                                XamlReader subTreeReader = xreader.ReadSubtree();
                                WalkSubTree(subTreeReader, lineNumbersForNSes);
                            }
                            else if (IsStartMemberTextExprNSForImpl(xreader))
                            {
                                XamlReader subTreeReader = xreader.ReadSubtree();
                                WalkSubTree(subTreeReader, lineNumbersForNSesForImpl);
                            }
                            else
                            {
                                xreader.Skip();
                            }
                        }
                        while (!xreader.IsEof);
                    }
                }
            }
        }

        private static bool IsStartMemberTextExprNS(XamlXmlReader xreader)
        {
            return xreader.NodeType == XamlNodeType.StartMember && xreader.Member.DeclaringType != null &&
                xreader.Member.DeclaringType.UnderlyingType == typeof(TextExpression) &&
                xreader.Member.Name == "Namespaces";
        }

        private static bool IsStartMemberTextExprNSForImpl(XamlXmlReader xreader)
        {
            return xreader.NodeType == XamlNodeType.StartMember && xreader.Member.DeclaringType != null &&
                xreader.Member.DeclaringType.UnderlyingType == typeof(TextExpression) &&
                xreader.Member.Name == "NamespacesForImplementation";
        }

        private static bool IsNamespaceString(XamlReader subTreeReader)
        {
            return subTreeReader.NodeType == XamlNodeType.StartObject && subTreeReader.Type.UnderlyingType == typeof(string);
        }

        private static void WalkSubTree(XamlReader subTreeReader, Dictionary<string, int> lineNumbersDictionary)
        {
            while (subTreeReader.Read())
            {
                if (IsNamespaceString(subTreeReader))
                {
                    while (subTreeReader.NodeType != XamlNodeType.Value)
                    {
                        subTreeReader.Read();
                    }

                    IXamlLineInfo ixamlLineInfo = (IXamlLineInfo)subTreeReader;
                    string namespaceName = subTreeReader.Value as string;
                    if (!string.IsNullOrEmpty(namespaceName))
                    {
                        lineNumbersDictionary[namespaceName] = ixamlLineInfo.LineNumber;
                    }
                }
            }
        }        
    }
}