RegexRunner.cs

using System.ComponentModel;

namespace System.Text.RegularExpressions
{
    [EditorBrowsable(EditorBrowsableState.Never)]
    public abstract class RegexRunner
    {
        protected internal int runtextbeg;

        protected internal int runtextend;

        protected internal int runtextstart;

        protected internal string runtext;

        protected internal int runtextpos;

        protected internal int[] runtrack;

        protected internal int runtrackpos;

        protected internal int[] runstack;

        protected internal int runstackpos;

        protected internal int[] runcrawl;

        protected internal int runcrawlpos;

        protected internal int runtrackcount;

        protected internal Match runmatch;

        protected internal Regex runregex;

        private int timeout;

        private bool ignoreTimeout;

        private int timeoutOccursAt;

        private const int TimeoutCheckFrequency = 1000;

        private int timeoutChecksToSkip;

        protected internal RegexRunner()
        {
        }

        protected internal Match Scan(Regex regex, string text, int textbeg, int textend, int textstart, int prevlen, bool quick)
        {
            return Scan(regex, text, textbeg, textend, textstart, prevlen, quick, regex.MatchTimeout);
        }

        protected internal Match Scan(Regex regex, string text, int textbeg, int textend, int textstart, int prevlen, bool quick, TimeSpan timeout)
        {
            bool flag = false;
            Regex.ValidateMatchTimeout(timeout);
            ignoreTimeout = (Regex.InfiniteMatchTimeout == timeout);
            this.timeout = (ignoreTimeout ? ((int)Regex.InfiniteMatchTimeout.TotalMilliseconds) : ((int)(timeout.TotalMilliseconds + 0.5)));
            runregex = regex;
            runtext = text;
            runtextbeg = textbeg;
            runtextend = textend;
            runtextstart = textstart;
            int num = (!runregex.RightToLeft) ? 1 : (-1);
            int num2 = runregex.RightToLeft ? runtextbeg : runtextend;
            runtextpos = textstart;
            if (prevlen == 0)
            {
                if (runtextpos == num2)
                {
                    return Match.Empty;
                }
                runtextpos += num;
            }
            StartTimeoutWatch();
            while (true)
            {
                if (FindFirstChar())
                {
                    CheckTimeout();
                    if (!flag)
                    {
                        InitMatch();
                        flag = true;
                    }
                    Go();
                    if (runmatch._matchcount[0] > 0)
                    {
                        return TidyMatch(quick);
                    }
                    runtrackpos = runtrack.Length;
                    runstackpos = runstack.Length;
                    runcrawlpos = runcrawl.Length;
                }
                if (runtextpos == num2)
                {
                    break;
                }
                runtextpos += num;
            }
            TidyMatch(quick: true);
            return Match.Empty;
        }

        private void StartTimeoutWatch()
        {
            if (!ignoreTimeout)
            {
                timeoutChecksToSkip = 1000;
                timeoutOccursAt = Environment.TickCount + timeout;
            }
        }

        protected void CheckTimeout()
        {
            if (!ignoreTimeout && --timeoutChecksToSkip == 0)
            {
                timeoutChecksToSkip = 1000;
                DoCheckTimeout();
            }
        }

        private void DoCheckTimeout()
        {
            int tickCount = Environment.TickCount;
            if (tickCount < timeoutOccursAt || (0 > timeoutOccursAt && 0 < tickCount))
            {
                return;
            }
            throw new RegexMatchTimeoutException(runtext, runregex.pattern, TimeSpan.FromMilliseconds(timeout));
        }

        protected abstract void Go();

        protected abstract bool FindFirstChar();

        protected abstract void InitTrackCount();

        private void InitMatch()
        {
            if (runmatch == null)
            {
                if (runregex.caps != null)
                {
                    runmatch = new MatchSparse(runregex, runregex.caps, runregex.capsize, runtext, runtextbeg, runtextend - runtextbeg, runtextstart);
                }
                else
                {
                    runmatch = new Match(runregex, runregex.capsize, runtext, runtextbeg, runtextend - runtextbeg, runtextstart);
                }
            }
            else
            {
                runmatch.Reset(runregex, runtext, runtextbeg, runtextend, runtextstart);
            }
            if (runcrawl != null)
            {
                runtrackpos = runtrack.Length;
                runstackpos = runstack.Length;
                runcrawlpos = runcrawl.Length;
                return;
            }
            InitTrackCount();
            int num = runtrackcount * 8;
            int num2 = runtrackcount * 8;
            if (num < 32)
            {
                num = 32;
            }
            if (num2 < 16)
            {
                num2 = 16;
            }
            runtrack = new int[num];
            runtrackpos = num;
            runstack = new int[num2];
            runstackpos = num2;
            runcrawl = new int[32];
            runcrawlpos = 32;
        }

        private Match TidyMatch(bool quick)
        {
            if (!quick)
            {
                Match match = runmatch;
                runmatch = null;
                match.Tidy(runtextpos);
                return match;
            }
            return null;
        }

        protected void EnsureStorage()
        {
            if (runstackpos < runtrackcount * 4)
            {
                DoubleStack();
            }
            if (runtrackpos < runtrackcount * 4)
            {
                DoubleTrack();
            }
        }

        protected bool IsBoundary(int index, int startpos, int endpos)
        {
            return (index > startpos && RegexCharClass.IsWordChar(runtext[index - 1])) != (index < endpos && RegexCharClass.IsWordChar(runtext[index]));
        }

        protected bool IsECMABoundary(int index, int startpos, int endpos)
        {
            return (index > startpos && RegexCharClass.IsECMAWordChar(runtext[index - 1])) != (index < endpos && RegexCharClass.IsECMAWordChar(runtext[index]));
        }

        protected static bool CharInSet(char ch, string set, string category)
        {
            string set2 = RegexCharClass.ConvertOldStringsToClass(set, category);
            return RegexCharClass.CharInClass(ch, set2);
        }

        protected static bool CharInClass(char ch, string charClass)
        {
            return RegexCharClass.CharInClass(ch, charClass);
        }

        protected void DoubleTrack()
        {
            int[] destinationArray = new int[runtrack.Length * 2];
            Array.Copy(runtrack, 0, destinationArray, runtrack.Length, runtrack.Length);
            runtrackpos += runtrack.Length;
            runtrack = destinationArray;
        }

        protected void DoubleStack()
        {
            int[] destinationArray = new int[runstack.Length * 2];
            Array.Copy(runstack, 0, destinationArray, runstack.Length, runstack.Length);
            runstackpos += runstack.Length;
            runstack = destinationArray;
        }

        protected void DoubleCrawl()
        {
            int[] destinationArray = new int[runcrawl.Length * 2];
            Array.Copy(runcrawl, 0, destinationArray, runcrawl.Length, runcrawl.Length);
            runcrawlpos += runcrawl.Length;
            runcrawl = destinationArray;
        }

        protected void Crawl(int i)
        {
            if (runcrawlpos == 0)
            {
                DoubleCrawl();
            }
            runcrawl[--runcrawlpos] = i;
        }

        protected int Popcrawl()
        {
            return runcrawl[runcrawlpos++];
        }

        protected int Crawlpos()
        {
            return runcrawl.Length - runcrawlpos;
        }

        protected void Capture(int capnum, int start, int end)
        {
            if (end < start)
            {
                int num = end;
                end = start;
                start = num;
            }
            Crawl(capnum);
            runmatch.AddMatch(capnum, start, end - start);
        }

        protected void TransferCapture(int capnum, int uncapnum, int start, int end)
        {
            if (end < start)
            {
                int num = end;
                end = start;
                start = num;
            }
            int num2 = MatchIndex(uncapnum);
            int num3 = num2 + MatchLength(uncapnum);
            if (start >= num3)
            {
                end = start;
                start = num3;
            }
            else if (end <= num2)
            {
                start = num2;
            }
            else
            {
                if (end > num3)
                {
                    end = num3;
                }
                if (num2 > start)
                {
                    start = num2;
                }
            }
            Crawl(uncapnum);
            runmatch.BalanceMatch(uncapnum);
            if (capnum != -1)
            {
                Crawl(capnum);
                runmatch.AddMatch(capnum, start, end - start);
            }
        }

        protected void Uncapture()
        {
            int cap = Popcrawl();
            runmatch.RemoveMatch(cap);
        }

        protected bool IsMatched(int cap)
        {
            return runmatch.IsMatched(cap);
        }

        protected int MatchIndex(int cap)
        {
            return runmatch.MatchIndex(cap);
        }

        protected int MatchLength(int cap)
        {
            return runmatch.MatchLength(cap);
        }
    }
}