Escape() 공개 정적인 메소드

Make an escaped string from a character.
public static Escape ( char c, bool useNumericRepresentationOnly = false ) : string
c char given character
useNumericRepresentationOnly bool if true then use numeric hexadecimal escaping of all characters
리턴 string
예제 #1
0
        private static string ToCharacterClassInterval(uint m, uint n)
        {
            if (m == 0 && n == 0xFFFF)
            {
                return(".");
            }

            if (m == n)
            {
                return(StringUtility.Escape((char)m));
            }

            string res = StringUtility.Escape((char)m);

            if (n > m + 1)
            {
                res += "-";
            }
            res += StringUtility.Escape((char)n);
            return(res);
        }
예제 #2
0
        //public static RegexToAutomatonConverterCharSet Create(BitWidth encoding)
        //{
        //    var solver = new CharSetSolver(encoding);
        //    return new RegexToAutomatonConverterCharSet(solver);
        //}

        /// <summary>
        /// Describe the bdd as a regex character set
        /// </summary>
        new public string Describe(BDD label)
        {
            string res;

            //if (description.TryGetValue(label, out res))
            //{
            //    string res1 = res.Replace(@"\p{Nd}", @"\d").Replace(@"\P{Nd}", @"\D");
            //    return res1;
            //}
            if (this.categorizer.CategoryCondition(8) == label)
            {
                return(@"\d");
            }
            if (this.Solver.MkNot(this.categorizer.CategoryCondition(8)) == label)
            {
                return(@"\D");
            }
            if (this.categorizer.WordLetterCondition == label)
            {
                return(@"\w");
            }
            if (this.Solver.MkNot(this.categorizer.WordLetterCondition) == label)
            {
                return(@"\W");
            }
            if (this.categorizer.WhiteSpaceCondition == label)
            {
                return(@"\s");
            }
            if (this.Solver.MkNot(this.categorizer.WhiteSpaceCondition) == label)
            {
                return(@"\S");
            }
            for (int i = 0; i < this.categorizer.UnicodeCategoryStandardAbbreviations.Length; i++)
            {
                if (this.categorizer.CategoryCondition(i) == label)
                {
                    return(@"\P{" + this.categorizer.UnicodeCategoryStandardAbbreviations[i] + "}");
                }
            }

            var ranges = bddBuilder.ToRanges(label);

            if (ranges.Length == 1 && ranges[0].Item1 == ranges[0].Item2)
            {
                string res1 = StringUtility.Escape((char)ranges[0].Item1);
                description[label] = res1;
                return(res1);
            }

            res = "[";
            for (int i = 0; i < ranges.Length; i++)
            {
                var range = ranges[i];
                if (range.Item1 == range.Item2)
                {
                    res += StringUtility.EscapeWithNumericSpace((char)range.Item1);
                }
                else if (range.Item1 == range.Item2 - 1)
                {
                    res += StringUtility.EscapeWithNumericSpace((char)range.Item1);
                    res += StringUtility.EscapeWithNumericSpace((char)range.Item2);
                }
                else
                {
                    res += StringUtility.EscapeWithNumericSpace((char)range.Item1);
                    res += "-";
                    res += StringUtility.EscapeWithNumericSpace((char)range.Item2);
                }
            }
            res += "]";
            description[label] = res;
            return(res);
        }
예제 #3
0
        internal static string ToRegexCharSet(BDD label, IUnicodeCategoryTheory <BDD> categorizer, CharSetSolver solver)
        {
            if (categorizer.CategoryCondition(8) == label)
            {
                return(@"\d");
            }
            if (solver.MkNot(categorizer.CategoryCondition(8)) == label)
            {
                return(@"\D");
            }
            if (categorizer.WordLetterCondition == label)
            {
                return(@"\w");
            }
            if (solver.MkNot(categorizer.WordLetterCondition) == label)
            {
                return(@"\W");
            }
            if (categorizer.WhiteSpaceCondition == label)
            {
                return(@"\s");
            }
            if (solver.MkNot(categorizer.WhiteSpaceCondition) == label)
            {
                return(@"\S");
            }
            for (int i = 0; i < categorizer.UnicodeCategoryStandardAbbreviations.Length; i++)
            {
                if (categorizer.CategoryCondition(i) == label)
                {
                    return(@"\P{" + categorizer.UnicodeCategoryStandardAbbreviations[i] + "}");
                }
            }

            var ranges = solver.ToRanges(label);

            if (ranges.Length == 1 && ranges[0].Item1 == ranges[0].Item2)
            {
                return(StringUtility.Escape((char)ranges[0].Item1));
            }

            var res = new StringBuilder("[");

            for (int i = 0; i < ranges.Length; i++)
            {
                var range = ranges[i];
                if (range.Item1 == range.Item2)
                {
                    res.Append(StringUtility.EscapeWithNumericSpace((char)range.Item1));
                }
                else if (range.Item1 == range.Item2 - 1)
                {
                    res.Append(StringUtility.EscapeWithNumericSpace((char)range.Item1));
                    res.Append(StringUtility.EscapeWithNumericSpace((char)range.Item2));
                }
                else
                {
                    res.Append(StringUtility.EscapeWithNumericSpace((char)range.Item1));
                    res.Append("-");
                    res.Append(StringUtility.EscapeWithNumericSpace((char)range.Item2));
                }
            }
            res.Append("]");
            return(res.ToString());
        }