bool IsValidDINCode(jsString code)
    {
        var pattern_noIdChar = new RegExp("[A-NP-Z1-9]{1}[0-9]{12}");

        var pattern = new RegExp(@Html.RawHasQuote(BarcodeBLL.DINIdChar) + "[A-NP-Z1-9]{1}[0-9]{14}");

        return pattern_noIdChar.test(code) || pattern.test(code);
    }

    bool IsValidProductCode(jsString code)
    {
        if (code.length != @BarcodeBLL.productLength) return false;

        var pattern = @Html.RawHasQuote(BarcodeBLL.productIdChar) + "[A-DE-Z1-9]{1}[0-9]{4}[A-Za-z0-9]{1}[A-Z0-9]{1}[a-z0-9]{1}";
        var regx = new RegExp(pattern);
        return regx.test(code);
    }

    bool IsValidDeleteCode(jsString code)
    {
        if (code.length != @BarcodeBLL.deleteLength) return false;

        var pattern = new RegExp(@Html.RawHasQuote(BarcodeBLL.deleteIdChar) + "[0-9]");

        return pattern.test(code);
    }

        public void StringMatchesBothRegexAutomaton(string pattern1, string pattern2, string matchingString)
        {
            var automaton1 = new RegExp(pattern1).ToAutomaton();
            var automaton2 = new RegExp(pattern2).ToAutomaton();

            var intersection = automaton1.Intersection(automaton2);

            Assert.True(intersection.Run(matchingString));
        }

        protected void btnHighLight_Click(object sender, EventArgs e)
        {
            string _error = string.Empty;

            // 检查用户输入的数据.
            if (CheckControlValue(this.ddlLanguage.SelectedValue,
                this.tbCode.Text, out _error))
            {
                // 初始化根据匹配选项用来保存不同语言代码
                // 及其相关正则表达式的散列表变量.
                Hashtable _htb = CodeManager.Init();

                // 初始化合适的集合对象.
                RegExp _rg = new RegExp();
                _rg = (RegExp)_htb[this.ddlLanguage.SelectedValue];
                this.lbResult.Visible = true;
                if (this.ddlLanguage.SelectedValue != "html")
                {
                    // 在标签控件中显示高亮的代码.
                    this.lbResult.Text = CodeManager.Encode(
                        CodeManager.HighlightCode(
                        Server.HtmlEncode(this.tbCode.Text)
                        .Replace(""", "\""),
                        this.ddlLanguage.SelectedValue, _rg)
                        );
                }
                else
                {
                    // 在标签控件中显示高亮的代码.
                    this.lbResult.Text = CodeManager.Encode(
                        CodeManager.HighlightHTMLCode(this.tbCode.Text, _htb)
                        );
                }
            }
            else
            {
                this.lbError.Visible = true;
                this.lbError.Text = _error;
            }
        }

        public virtual void TestGetRandomAcceptedString()
        {
            int ITER1 = AtLeast(100);
            int ITER2 = AtLeast(100);
            for (int i = 0; i < ITER1; i++)
            {
                RegExp re = new RegExp(AutomatonTestUtil.RandomRegexp(Random()), RegExp.NONE);
                Automaton a = re.ToAutomaton();
                Assert.IsFalse(BasicOperations.IsEmpty(a));

                AutomatonTestUtil.RandomAcceptedStrings rx = new AutomatonTestUtil.RandomAcceptedStrings(a);
                for (int j = 0; j < ITER2; j++)
                {
                    int[] acc = null;
                    try
                    {
                        acc = rx.GetRandomAcceptedString(Random());
                        string s = UnicodeUtil.NewString(acc, 0, acc.Length);
                        Assert.IsTrue(BasicOperations.Run(a, s));
                    }
                    catch (Exception t)
                    {
                        Console.WriteLine("regexp: " + re);
                        if (acc != null)
                        {
                            Console.WriteLine("fail acc re=" + re + " count=" + acc.Length);
                            for (int k = 0; k < acc.Length; k++)
                            {
                                Console.WriteLine("  " + acc[k].ToString("x"));
                            }
                        }
                        throw t;
                    }
                }
            }
        }

        private static RegExp MakeConcatenation(RegExp exp1, RegExp exp2)
        {
            if ((exp1.kind == Kind.RegexpChar || exp1.kind == Kind.RegexpString)
                && (exp2.kind == Kind.RegexpChar || exp2.kind == Kind.RegexpString))
            {
                return RegExp.MakeString(exp1, exp2);
            }

            var r = new RegExp();
            r.kind = Kind.RegexpConcatenation;
            if (exp1.kind == Kind.RegexpConcatenation
                && (exp1.exp2.kind == Kind.RegexpChar || exp1.exp2.kind == Kind.RegexpString)
                && (exp2.kind == Kind.RegexpChar || exp2.kind == Kind.RegexpString))
            {
                r.exp1 = exp1.exp1;
                r.exp2 = RegExp.MakeString(exp1.exp2, exp2);
            }
            else if ((exp1.kind == Kind.RegexpChar || exp1.kind == Kind.RegexpString)
                     && exp2.kind == Kind.RegexpConcatenation
                     && (exp2.exp1.kind == Kind.RegexpChar || exp2.exp1.kind == Kind.RegexpString))
            {
                r.exp1 = RegExp.MakeString(exp1, exp2.exp1);
                r.exp2 = exp2.exp2;
            }
            else
            {
                r.exp1 = exp1;
                r.exp2 = exp2;
            }

            return r;
        }

 private static RegExp MakeComplement(RegExp exp)
 {
     var r = new RegExp();
     r.kind = Kind.RegexpComplement;
     r.exp1 = exp;
     return r;
 }

 private static RegExp MakeCharRange(char from, char to)
 {
     var r = new RegExp();
     r.kind = Kind.RegexpCharRange;
     r.from = from;
     r.to = to;
     return r;
 }

 private static RegExp MakeChar(char @char)
 {
     var r = new RegExp();
     r.kind = Kind.RegexpChar;
     r.c = @char;
     return r;
 }

 internal static RegExp MakeInterval(int min, int max, int digits)
 {
     RegExp r = new RegExp();
     r.kind = Kind.REGEXP_INTERVAL;
     r.Min = min;
     r.Max = max;
     r.Digits = digits;
     return r;
 }

 private static RegExp MakeOptional(RegExp exp)
 {
     var r = new RegExp();
     r.kind = Kind.RegexpOptional;
     r.exp1 = exp;
     return r;
 }

 private static RegExp MakeRepeat(RegExp exp, int min, int max)
 {
     var r = new RegExp();
     r.kind = Kind.RegexpRepeatMinMax;
     r.exp1 = exp;
     r.min = min;
     r.max = max;
     return r;
 }

 public EcString[] Match(EcString pattern)
 {
     var r = new RegExp(pattern.value);
     return r.Match(this.value).Select(match => new EcString(match)).ToArray();
 }

        public void TestSpecialCase()
        {
            RegExp re = new RegExp(".?");
            Automaton automaton = re.ToAutomaton();
            CharacterRunAutomaton cra = new CharacterRunAutomaton(automaton);
            ByteRunAutomaton bra = new ByteRunAutomaton(automaton);
            // make sure character dfa accepts empty string
            Assert.IsTrue(cra.IsAccept(cra.InitialState));
            Assert.IsTrue(cra.Run(""));
            Assert.IsTrue(cra.Run(new char[0], 0, 0));

            // make sure byte dfa accepts empty string
            Assert.IsTrue(bra.IsAccept(bra.InitialState));
            Assert.IsTrue(bra.Run(new byte[0], 0, 0));
        }

        public void TestSpecialCase3()
        {
            RegExp re = new RegExp("(\\鯺)*(.)*\\Ӕ");
            string input = "\u5cfd\ufffd\ub2f7\u0033\ue304\u51d7\u3692\udb50\udfb3\u0576\udae2\udc62\u0053\u0449\u04d4";
            Automaton automaton = re.ToAutomaton();
            CharacterRunAutomaton cra = new CharacterRunAutomaton(automaton);
            ByteRunAutomaton bra = new ByteRunAutomaton(automaton);

            Assert.IsTrue(cra.Run(input));

            var bytes = input.GetBytes(Encoding.UTF8);
            Assert.IsTrue(bra.Run(bytes, 0, bytes.Length));
        }

        public void TestSpecialCase2()
        {
            RegExp re = new RegExp(".+\u0775");
            string input = "\ufadc\ufffd\ub80b\uda5a\udc68\uf234\u0056\uda5b\udcc1\ufffd\ufffd\u0775";
            Automaton automaton = re.ToAutomaton();
            CharacterRunAutomaton cra = new CharacterRunAutomaton(automaton);
            ByteRunAutomaton bra = new ByteRunAutomaton(automaton);

            Assert.IsTrue(cra.Run(input));

            var bytes = input.GetBytes(Encoding.UTF8);
            Assert.IsTrue(bra.Run(bytes, 0, bytes.Length)); // this one fails!
        }

 internal RepetitionAtLeastOneRegExp(RegExp expression, Greediness greediness = Greediness.GreedyQuantification)
     : base(expression, greediness)
 {
 }

 private static RegExp MakeEmpty()
 {
     var r = new RegExp();
     r.kind = Kind.RegexpEmpty;
     return r;
 }

        private static RegExp MakeString(RegExp exp1, RegExp exp2)
        {
            var sb = new StringBuilder();
            if (exp1.kind == Kind.RegexpString)
            {
                sb.Append(exp1.s);
            }
            else
            {
                sb.Append(exp1.c);
            }

            if (exp2.kind == Kind.RegexpString)
            {
                sb.Append(exp2.s);
            }
            else
            {
                sb.Append(exp2.c);
            }

            return RegExp.MakeString(sb.ToString());
        }