//public static void Test_Regex(string sRegex, string sInput)
        //{
        //    Test_Regex(sRegex, sInput, RegexOptions.Compiled | RegexOptions.IgnoreCase);
        //}

        public static void Test(string regexPattern, string text, RegexOptions options = RegexOptions.Compiled | RegexOptions.IgnoreCase)
        {
            Regex regex = new Regex(regexPattern, options);
            Trace.WriteLine("Regex     : {0}", regexPattern);
            Trace.WriteLine("Input     : {0}", text);
            Match match = regex.Match(text);
            //string s;
            //if (match.Success) s = "found"; else s = "not found";
            //Trace.WriteLine("Result    : {0}", s);
            if (!match.Success)
                Trace.WriteLine("Result    : not found");
            int n = 1;
            while (match.Success)
            {
                Trace.WriteLine("Result    : found no {0}", n++);
                for (int i = 0; i < match.Groups.Count; i++)
                {
                    Trace.WriteLine("Groups[{0}] : \"{1}\"", i, match.Groups[i].Value);
                    if (match.Groups[i].Captures.Count > 1)
                    {
                        for (int j = 0; j < match.Groups[i].Captures.Count; j++)
                        {
                            Trace.WriteLine(" Capture[{0}] : \"{1}\"", j, match.Groups[i].Captures[j]);
                        }
                    }
                }
                match = match.NextMatch();
            }
        }

        /// <summary>
        ///     Gets whether a <see cref="Regex" /> with the specified pattern finds a match in the specified input
        ///     <see cref="String" />.
        /// </summary>
        /// <exception cref="ArgumentNullException">The input can not be null.</exception>
        /// <exception cref="ArgumentNullException">The pattern can not be null.</exception>
        /// <exception cref="ArgumentNullException">The timeout can not be null.</exception>
        /// <param name="input">The <see cref="String" /> to search for a match.</param>
        /// <param name="pattern">The regular expression pattern used by the <see cref="Regex" />.</param>
        /// <param name="options">The regular expression options used by the <see cref="Regex" />.</param>
        /// <param name="timeOut">The timeout for the match operation.</param>
        /// <returns>A value of true if the regular expression finds a match, otherwise false.</returns>
        public static Boolean IsMatch( this String input, String pattern, RegexOptions options, TimeSpan timeOut )
        {
            input.ThrowIfNull( nameof( input ) );
            pattern.ThrowIfNull( nameof( pattern ) );

            return Regex.IsMatch( input, pattern, options, timeOut );
        }

        /*
         * This static call constructs a RegexTree from a regular expression
         * pattern string and an option string.
         *
         * The method creates, drives, and drops a parser instance.
         */
        internal static RegexTree Parse(string re, RegexOptions op)
        {
            int end;
            var pcreOptions = TrimPcreRegexOption(re, out end);
            var pattern = TrimDelimiters(re, end);

            RegexParser p;
            RegexNode root;
            string[] capnamelist;

            p = new RegexParser((op & RegexOptions.CultureInvariant) != 0 ? CultureInfo.InvariantCulture : CultureInfo.CurrentCulture);

            p._options = op;

            p.SetPattern(pattern);
            p.CountCaptures();
            p.Reset(op);
            root = p.ScanRegex();

            if (p._capnamelist == null)
                capnamelist = null;
            else
                capnamelist = p._capnamelist.ToArray();

            return new RegexTree(root, p._caps, p._capnumlist, p._captop, p._capnames, capnamelist, op);
        }

 private RegexAttribute(string pattern, RegexOptions options, bool optionsSpecified, Type compiledRegexType)
 {
     this.pattern = pattern;
     this.options = options;
     this.optionsSpecified = optionsSpecified;
     this.compiledRegexType = compiledRegexType;
 }

        /// <summary>
        /// Primary constructor.
        /// </summary>
        /// <param name="pattern">The regular expression pattern to match
        /// against.</param>
        public MustNotMatchRegexAttribute(string pattern)
        {
            Pattern = pattern;
            _options = RegexOptions.None;

            _regEx = new Regex(pattern, _options);
        }

 /// <devdoc>
 ///    <para>
 ///       [To be supplied]
 ///    </para>
 /// </devdoc>
 public RegexCompilationInfo(String pattern, RegexOptions options, String name, String fullnamespace, bool ispublic) {
     Pattern = pattern;
     Name = name;
     Namespace = fullnamespace;
     this.options = options;
     isPublic = ispublic;
 }

 public DynamicRegexArticleComparer(string comparator, RegexOptions options)
 {
     Comparator = comparator;
     Options = (options & ~RegexOptions.Compiled);
     // Create a regex to try it out. Throws an exception if there's a regex error
     new Regex(Tools.ApplyKeyWords("a", comparator), options);
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="StringRules"/> class.
        /// </summary>
        /// <param name="minLength">The minimum string length allowed.</param>
        /// <param name="maxLength">The maximum string length allowed.</param>
        /// <param name="allowedChars">The set of allowed characters.</param>
        /// <param name="regexOptions">The additional regex options to use.</param>
        /// <param name="customerFilters">An optional collection of custom <see cref="Regex"/> patterns that describe
        /// additional restrictions.</param>
        /// <exception cref="ArgumentOutOfRangeException"><paramref name="minLength"/> is less than 0.</exception>
        /// <exception cref="ArgumentOutOfRangeException"><paramref name="maxLength"/> is less than
        /// <paramref name="minLength"/>.</exception>
        /// <exception cref="ArgumentOutOfRangeException"><paramref name="minLength"/> is greater than
        /// <see cref="ushort.MaxValue"/>.</exception>
        /// <exception cref="ArgumentOutOfRangeException"><paramref name="maxLength"/> is greater than
        /// <see cref="ushort.MaxValue"/>.</exception>
        /// <exception cref="ArgumentOutOfRangeException"><paramref name="allowedChars"/> contains no defined groups.</exception>
        /// <exception cref="ArgumentException">At least one character group must be allowed.</exception>
        public StringRules(int minLength, int maxLength, CharType allowedChars, RegexOptions regexOptions = RegexOptions.None,
                           IEnumerable<Regex> customerFilters = null)
        {
            if (minLength < 0)
                throw new ArgumentOutOfRangeException("minLength");
            if (maxLength < minLength)
                throw new ArgumentOutOfRangeException("maxLength");
            if (minLength > ushort.MaxValue)
                throw new ArgumentOutOfRangeException("minLength");
            if (maxLength > ushort.MaxValue)
                throw new ArgumentOutOfRangeException("maxLength");
            if ((int)allowedChars == 0)
                throw new ArgumentException("At least one character group must be allowed.", "allowedChars");

            _minLength = (ushort)minLength;
            _maxLength = (ushort)maxLength;
            _allowedChars = allowedChars;

            var regexStr = BuildRegexString(minLength, maxLength, allowedChars);

            _regex = new Regex(regexStr, RegexOptions.Compiled | regexOptions);

            if (customerFilters != null)
                _customFilters = customerFilters.ToCompact();
        }

 /// <summary>
 /// Проверка, что строка соответствует заданному шаблону
 /// </summary>
 /// <param name="testString">Проверяемая строка</param>
 /// <param name="template">Шаблон</param>
 /// <param name="options">Параметры сравнения</param>
 /// <param name="errorMessageFormatString">Текст ошибки</param>
 /// <param name="errorMessageArgs">Параметры для сообщения об ошибке</param>
 public static void IsMatch(string testString, string template, RegexOptions options, string errorMessageFormatString, params object[] errorMessageArgs)
 {
     if (testString == null || !Regex.IsMatch(testString, template, options))
     {
         Throw(errorMessageFormatString, errorMessageArgs);
     }
 }

 internal RegexNode(int type, RegexOptions options, int m, int n)
 {
     this._type = type;
     this._options = options;
     this._m = m;
     this._n = n;
 }

 public Regex(string pattern, RegexOptions options)
 {
     this.refsInitialized = false;
     if (pattern == null)
     {
         throw new ArgumentNullException();
     }
     if ((options < RegexOptions.None) || ((((int) options) >> 9) != 0))
     {
         throw new ArgumentOutOfRangeException();
     }
     if (((options & RegexOptions.ECMAScript) != RegexOptions.None) && ((options & ~(RegexOptions.CultureInvariant | RegexOptions.ECMAScript | RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.IgnoreCase)) != RegexOptions.None))
     {
         throw new ArgumentOutOfRangeException();
     }
     string text1 = options + ":" + pattern;
     this.pattern = pattern;
     this.roptions = options;
     RegexTree t = RegexParser.Parse(pattern, this.roptions);
     this.capnames = t._capnames;
     this.capslist = t._capslist;
     this.code = RegexWriter.Write(t);
     this.caps = this.code._caps;
     this.capsize = this.code._capsize;
 }

		public GrepSink (IMiniStreamSink dest, string[] regexes, RegexOptions options) {
			this.dest = dest;

			this.regexes = new Regex[regexes.Length];
			for (int i = 0; i < regexes.Length; i++)
				this.regexes[i] = new Regex (regexes[i], options);
		}

 internal Type FactoryTypeFromCode(RegexCode code, RegexOptions options, string typeprefix)
 {
     base._code = code;
     base._codes = code._codes;
     base._strings = code._strings;
     base._fcPrefix = code._fcPrefix;
     base._bmPrefix = code._bmPrefix;
     base._anchors = code._anchors;
     base._trackcount = code._trackcount;
     base._options = options;
     string str3 = Interlocked.Increment(ref _typeCount).ToString(CultureInfo.InvariantCulture);
     string typename = typeprefix + "Runner" + str3;
     string str2 = typeprefix + "Factory" + str3;
     this.DefineType(typename, false, typeof(RegexRunner));
     this.DefineMethod("Go", null);
     base.GenerateGo();
     this.BakeMethod();
     this.DefineMethod("FindFirstChar", typeof(bool));
     base.GenerateFindFirstChar();
     this.BakeMethod();
     this.DefineMethod("InitTrackCount", null);
     base.GenerateInitTrackCount();
     this.BakeMethod();
     Type newtype = this.BakeType();
     this.DefineType(str2, false, typeof(RegexRunnerFactory));
     this.DefineMethod("CreateInstance", typeof(RegexRunner));
     this.GenerateCreateInstance(newtype);
     this.BakeMethod();
     return this.BakeType();
 }

		public RegexTrial (string pattern, RegexOptions options, string input, string expected)
		{
			this.pattern = pattern;
			this.options = options;
			this.input = input;
			this.expected = expected;
		}

 private static string GetValueFromText(string text, string regex, RegexOptions option = RegexOptions.None)
 {
     MatchCollection mat = Regex.Matches(text, regex, option);
     if (mat.Count > 0)
         return mat[0].Groups["token"].ToString().Trim(trimChars: new char[] { ' ' });
     return string.Empty;
 }

 protected RegexRouteConstraintBase(string pattern, RegexOptions options)
 {
     Pattern = pattern;
     // shouldn't these be included in the derrived classes by default: RegexOptions.CultureInvariant | RegexOptions.IgnoreCase?
     Options = options;  //no need to tell user that it is 'compiled' option...so do not include in public options
     CompiledExpression = new Regex(pattern, options | RegexOptions.Compiled);
 }

		public string Reformat (RegexOptions options,
			string reformattedPattern,
			PatternGrouping patternGrouping) {
			if (!HasConstruct (reformattedPattern, options)) {
				return reformattedPattern;
			}

			if (patternGrouping.GroupCount >= 0 && patternGrouping.SameGroupsFlag) {
				return null;
			}

			Matcher m = JavaUtils.Matcher (reformattedPattern, NUMBER_BACK_REFERENCE_PATTERN);
			if (m.find ()) {
				reformattedPattern = ReplaceGroupNumber (m, reformattedPattern, patternGrouping, options);
				if (reformattedPattern == null)
					return null;
			}

			m = JavaUtils.Matcher(reformattedPattern, NAME_1_BACK_REFERENCE_PATTERN);
			if (m.find ()) {
				reformattedPattern = ReplaceGroupName (m, reformattedPattern, patternGrouping, options);
				if (reformattedPattern == null)
					return null;
			}

			m = JavaUtils.Matcher(reformattedPattern, NAME_2_BACK_REFERENCE_PATTERN);
			if (m.find ()) {
				reformattedPattern = ReplaceGroupName (m, reformattedPattern, patternGrouping, options);
				if (reformattedPattern == null)
					return null;
			}

			return reformattedPattern;
		}

 public RegEx(string pattern, string name, bool expectedMatch = true,
     RegexOptions options = RegexOptions.Compiled)
     : base(pattern, options)
 {
     Name = name;
     ExpectedMatch = expectedMatch;
 }

 private ParamCollection Parse(ref string s, string pattern, bool remove, string tag, RegexOptions options)
 {
     ParamCollection cmd = new ParamCollection(Name);
     Regex rex = new Regex(pattern, options);
     Match m1 = rex.Match(s);
     while (m1.Success)
     {
         string param = m1.Groups[PARAM].Value;
         string arg = m1.Groups[ARGS].Value;
         if (param != null)
         {
             param = param.TrimEnd(' ');
             ArgCollection prm = cmd.Add(param, new ArgCollection(param, tag));
             if (arg != null)
             {
                 arg = arg.TrimEnd(' ');
                 if (!string.IsNullOrEmpty(arg))
                 {
                     prm.Add(arg);
                 }
             }
         }
         if (remove)
         {
             s = s.Remove(m1.Index, m1.Length).Trim();
             m1 = rex.Match(s);
         }
         else
         {
             m1 = rex.Match(s, m1.Index + m1.Length);
         }
     }
     return cmd;
 }

 public void Split(string pattern, string input, RegexOptions options, int count, int start, string[] expected)
 {
     bool isDefaultStart = RegexHelpers.IsDefaultStart(input, options, start);
     bool isDefaultCount = RegexHelpers.IsDefaultStart(input, options, count);
     if (options == RegexOptions.None)
     {
         // Use Split(string), Split(string, string), Split(string, int) or Split(string, int, int)
         if (isDefaultStart && isDefaultCount)
         {
             // Use Split(string) or Split(string, string)
             Assert.Equal(expected, new Regex(pattern).Split(input));
             Assert.Equal(expected, Regex.Split(input, pattern));
         }
         if (isDefaultStart)
         {
             // Use Split(string, int)
             Assert.Equal(expected, new Regex(pattern).Split(input, count));
         }
         // Use Split(string, int, int)
         Assert.Equal(expected, new Regex(pattern).Split(input, count, start));
     }
     if (isDefaultStart && isDefaultCount)
     {
         // Use Split(string, string, RegexOptions)
         Assert.Equal(expected, Regex.Split(input, pattern, options));
     }
     if (isDefaultStart)
     {
         // Use Split(string, int)
         Assert.Equal(expected, new Regex(pattern, options).Split(input, count));
     }
     // Use Split(string, int, int, int)
     Assert.Equal(expected, new Regex(pattern, options).Split(input, count, start));
 }