示例#1
0
        public override bool DoMatchCollection(Role role, INode pos, Match match, BacktrackingInfo backtrackingInfo)
        {
            var backtrackingStack = backtrackingInfo.backtrackingStack;

            Debug.Assert(pos == null || pos.Role == role);
            int matchCount = 0;

            if (this.MinCount <= 0)
            {
                backtrackingStack.Push(new PossibleMatch(pos, match.CheckPoint()));
            }
            while (matchCount < this.MaxCount && pos != null && childNode.DoMatch(pos, match))
            {
                matchCount++;
                do
                {
                    pos = pos.NextSibling;
                } while (pos != null && pos.Role != role);
                if (matchCount >= this.MinCount)
                {
                    backtrackingStack.Push(new PossibleMatch(pos, match.CheckPoint()));
                }
            }
            return(false);            // never do a normal (single-element) match; always make the caller look at the results on the back-tracking stack.
        }
示例#2
0
        public static bool DoMatchCollection(Role role, INode firstPatternChild, INode firstOtherChild, Match match)
        {
            BacktrackingInfo      backtrackingInfo = new BacktrackingInfo();
            Stack <INode>         patternStack     = new Stack <INode>();
            Stack <PossibleMatch> stack            = backtrackingInfo.backtrackingStack;

            patternStack.Push(firstPatternChild);
            stack.Push(new PossibleMatch(firstOtherChild, match.CheckPoint()));
            while (stack.Count > 0)
            {
                INode cur1 = patternStack.Pop();
                INode cur2 = stack.Peek().NextOther;
                match.RestoreCheckPoint(stack.Pop().Checkpoint);
                bool success = true;
                while (cur1 != null && success)
                {
                    while (cur1 != null && cur1.Role != role)
                    {
                        cur1 = cur1.NextSibling;
                    }
                    while (cur2 != null && cur2.Role != role)
                    {
                        cur2 = cur2.NextSibling;
                    }
                    if (cur1 == null)
                    {
                        break;
                    }

                    Debug.Assert(stack.Count == patternStack.Count);
                    success = cur1.DoMatchCollection(role, cur2, match, backtrackingInfo);
                    Debug.Assert(stack.Count >= patternStack.Count);
                    while (stack.Count > patternStack.Count)
                    {
                        patternStack.Push(cur1.NextSibling);
                    }

                    cur1 = cur1.NextSibling;
                    if (cur2 != null)
                    {
                        cur2 = cur2.NextSibling;
                    }
                }
                while (cur2 != null && cur2.Role != role)
                {
                    cur2 = cur2.NextSibling;
                }
                if (success && cur2 == null)
                {
                    return(true);
                }
            }
            return(false);
        }
示例#3
0
        public override bool DoMatch(INode other, Match match)
        {
            var checkPoint = match.CheckPoint();

            foreach (INode alt in alternatives)
            {
                if (alt.DoMatch(other, match))
                {
                    return(true);
                }
                else
                {
                    match.RestoreCheckPoint(checkPoint);
                }
            }
            return(false);
        }
示例#4
0
 public override bool DoMatchCollection(Role role, INode pos, Match match, BacktrackingInfo backtrackingInfo)
 {
     backtrackingInfo.backtrackingStack.Push(new PossibleMatch(pos, match.CheckPoint()));
     return(childNode.DoMatch(pos, match));
 }