Beispiel #1
0
        /// <summary>
        /// Convert infix regexp re to postfix notation.
        /// Insert . as explicit concatenation operator.
        /// </summary>
        /// <param name="re">input re</param>
        /// <returns>postfix re</returns>
        private static string re2post(string re)
        {
            int    nalt  = 0;
            int    natom = 0;
            string buf   = "";
            var    dst   = new StringBuilder();
            var    paren = new List <paren>();
            var    p     = new paren();

            paren.Add(p);

            foreach (var r in re)
            {
                switch (r)
                {
                case '(':
                    if (natom > 1)
                    {
                        --natom;
                        dst.Append('.');
                    }
                    p.nalt  = nalt;
                    p.natom = natom;
                    p       = new paren();
                    paren.Add(p);
                    nalt  = 0;
                    natom = 0;
                    break;

                case '|':
                    if (natom == 0)
                    {
                        throw new Exception("unexpected |");
                    }
                    while (--natom > 0)
                    {
                        dst.Append('.');
                    }
                    nalt++;
                    break;

                case ')':
                    if (p.Equals(paren[0]))
                    {
                        throw new Exception("something bad");
                    }
                    if (natom == 0)
                    {
                        throw new Exception("unexpected )");
                    }
                    while (--natom > 0)
                    {
                        dst.Append('.');
                    }
                    for (; nalt > 0; nalt--)
                    {
                        dst.Append('|');
                    }
                    paren.Remove(p);
                    p     = paren.Last();
                    nalt  = p.nalt;
                    natom = p.natom;
                    natom++;
                    break;

                case '*':
                case '+':
                case '?':
                    if (natom == 0)
                    {
                        throw new Exception("unexpected " + r);
                    }
                    dst.Append(r);
                    break;

                default:
                    if (natom > 1)
                    {
                        --natom;
                        dst.Append('.');
                    }
                    dst.Append(r);
                    natom++;
                    break;
                }
            }

            if (p.Equals(paren.Last()) != true)
            {
                throw new Exception("unbalanced parens");
            }
            while (--natom > 0)
            {
                dst.Append('.');
            }
            for (; nalt > 0; nalt--)
            {
                dst.Append('|');
            }

            return(dst.ToString());
        }
Beispiel #2
0
 => new OptionalRule(paren(delimit(r.r1, r.r2)));