コード例 #1
0
        private Node ApplyRulesToSubtree(
            RuleProcessingContext context,
            ReadOnlyCollection <ReadOnlyCollection <Rule> > rules,
            Node subTreeRoot,
            Node parent,
            int childIndexInParent)
        {
            int num = 0;
            Dictionary <SubTreeId, SubTreeId> dictionary = new Dictionary <SubTreeId, SubTreeId>();
            SubTreeId key;

            while (true)
            {
                ++num;
                context.PreProcessSubTree(subTreeRoot);
                key = new SubTreeId(context, subTreeRoot, parent, childIndexInParent);
                if (!this.m_processedNodeMap.ContainsKey(key))
                {
                    if (!dictionary.ContainsKey(key))
                    {
                        dictionary[key] = key;
                        for (int childIndexInParent1 = 0; childIndexInParent1 < subTreeRoot.Children.Count; ++childIndexInParent1)
                        {
                            Node child = subTreeRoot.Children[childIndexInParent1];
                            if (RuleProcessor.ShouldApplyRules(child, subTreeRoot))
                            {
                                subTreeRoot.Children[childIndexInParent1] = this.ApplyRulesToSubtree(context, rules, child, subTreeRoot, childIndexInParent1);
                            }
                        }
                        Node newNode;
                        if (RuleProcessor.ApplyRulesToNode(context, rules, subTreeRoot, out newNode))
                        {
                            context.PostProcessSubTree(subTreeRoot);
                            subTreeRoot = newNode;
                        }
                        else
                        {
                            goto label_10;
                        }
                    }
                    else
                    {
                        break;
                    }
                }
                else
                {
                    goto label_12;
                }
            }
            this.m_processedNodeMap[key] = key;
            goto label_12;
label_10:
            this.m_processedNodeMap[key] = key;
label_12:
            context.PostProcessSubTree(subTreeRoot);
            return(subTreeRoot);
        }
コード例 #2
0
        /// <summary>
        /// Apply rules to the current subtree in a bottom-up fashion. 
        /// </summary>
        /// <param name="context">Current rule processing context</param>
        /// <param name="rules">The look-up table with the rules to be applied</param>
        /// <param name="subTreeRoot">Current subtree</param>
        /// <param name="parent">Parent node</param>
        /// <param name="childIndexInParent">Index of this child within the parent</param>
        /// <returns>the result of the transformation</returns>
        private Node ApplyRulesToSubtree(
            RuleProcessingContext context,
            ReadOnlyCollection<ReadOnlyCollection<Rule>> rules,
            Node subTreeRoot, Node parent, int childIndexInParent)
        {
            var loopCount = 0;
            var localProcessedMap = new Dictionary<SubTreeId, SubTreeId>();
            SubTreeId subTreeId;

            while (true)
            {
                // Am I looping forever
                Debug.Assert(loopCount < 12, "endless loops?");
                loopCount++;

                //
                // We may need to update state regardless of whether this subTree has 
                // changed after it has been processed last. For example, it may be 
                // affected by transformation in its siblings due to external references.
                //
                context.PreProcessSubTree(subTreeRoot);
                subTreeId = new SubTreeId(context, subTreeRoot, parent, childIndexInParent);

                // Have I seen this subtree already? Just return, if so
                if (m_processedNodeMap.ContainsKey(subTreeId))
                {
                    break;
                }

                // Avoid endless loops here - avoid cycles of 2 or more
                if (localProcessedMap.ContainsKey(subTreeId))
                {
                    // mark this subtree as processed
                    m_processedNodeMap[subTreeId] = subTreeId;
                    break;
                }
                // Keep track of this one
                localProcessedMap[subTreeId] = subTreeId;

                // Walk my children
                for (var i = 0; i < subTreeRoot.Children.Count; i++)
                {
                    subTreeRoot.Children[i] = ApplyRulesToSubtree(context, rules, subTreeRoot.Children[i], subTreeRoot, i);
                }

                // Apply rules to myself. If no transformations were performed, 
                // then mark this subtree as processed, and break out
                Node newSubTreeRoot;
                if (!ApplyRulesToNode(context, rules, subTreeRoot, out newSubTreeRoot))
                {
                    Debug.Assert(subTreeRoot == newSubTreeRoot);
                    // mark this subtree as processed
                    m_processedNodeMap[subTreeId] = subTreeId;
                    break;
                }
                context.PostProcessSubTree(subTreeRoot);
                subTreeRoot = newSubTreeRoot;
            }

            context.PostProcessSubTree(subTreeRoot);
            return subTreeRoot;
        }
コード例 #3
0
        /// <summary>
        ///     Apply rules to the current subtree in a bottom-up fashion.
        /// </summary>
        /// <param name="context"> Current rule processing context </param>
        /// <param name="rules"> The look-up table with the rules to be applied </param>
        /// <param name="subTreeRoot"> Current subtree </param>
        /// <param name="parent"> Parent node </param>
        /// <param name="childIndexInParent"> Index of this child within the parent </param>
        /// <returns> the result of the transformation </returns>
        private Node ApplyRulesToSubtree(
            RuleProcessingContext context,
            ReadOnlyCollection <ReadOnlyCollection <Rule> > rules,
            Node subTreeRoot, Node parent, int childIndexInParent)
        {
            var       loopCount         = 0;
            var       localProcessedMap = new Dictionary <SubTreeId, SubTreeId>();
            SubTreeId subTreeId;

            while (true)
            {
                // Am I looping forever
                Debug.Assert(loopCount < 12, "endless loops?");
                loopCount++;

                //
                // We may need to update state regardless of whether this subTree has
                // changed after it has been processed last. For example, it may be
                // affected by transformation in its siblings due to external references.
                //
                context.PreProcessSubTree(subTreeRoot);
                subTreeId = new SubTreeId(context, subTreeRoot, parent, childIndexInParent);

                // Have I seen this subtree already? Just return, if so
                if (m_processedNodeMap.ContainsKey(subTreeId))
                {
                    break;
                }

                // Avoid endless loops here - avoid cycles of 2 or more
                if (localProcessedMap.ContainsKey(subTreeId))
                {
                    // mark this subtree as processed
                    m_processedNodeMap[subTreeId] = subTreeId;
                    break;
                }
                // Keep track of this one
                localProcessedMap[subTreeId] = subTreeId;

                // Walk my children
                for (var i = 0; i < subTreeRoot.Children.Count; i++)
                {
                    var childNode = subTreeRoot.Children[i];
                    if (ShouldApplyRules(childNode, subTreeRoot))
                    {
                        subTreeRoot.Children[i] = ApplyRulesToSubtree(context, rules, childNode, subTreeRoot, i);
                    }
                }

                // Apply rules to myself. If no transformations were performed,
                // then mark this subtree as processed, and break out
                Node newSubTreeRoot;
                if (!ApplyRulesToNode(context, rules, subTreeRoot, out newSubTreeRoot))
                {
                    Debug.Assert(subTreeRoot == newSubTreeRoot);
                    // mark this subtree as processed
                    m_processedNodeMap[subTreeId] = subTreeId;
                    break;
                }
                context.PostProcessSubTree(subTreeRoot);
                subTreeRoot = newSubTreeRoot;
            }

            context.PostProcessSubTree(subTreeRoot);
            return(subTreeRoot);
        }