예제 #1
0
 /// <summary>
 /// Internal use only.
 /// Construct a matcher for a pre-compiled regular expression from program
 /// (bytecode) data. Internal use only
 /// </summary>
 /// <param name="program">Compiled regular expression program</param>
 internal Regex(RegexProgram program)
     : this(program, RegexOptions.None)
 {
 }
예제 #2
0
        /// <summary>
        /// Compiles a regular expression pattern into a program runnable by the pattern matcher class 'RE'.
        /// </summary>
        /// <param name="pattern">Regular expression pattern to compile</param>
        /// <returns></returns>
        internal RegexProgram Compile(String pattern)
        {
            //Check if the pattersn is already compiled
            if (Regex.CacheSize > 0 && Regex.Cache.Contains(pattern))
            {
                foreach (RegexProgram regexProgram in Regex.Cache.ToArray())
                    if (regexProgram.Pattern.Equals(pattern)) return regexProgram;
                throw new Exception("Cache Error RegexCompiler.cs Compile Method");
            }
            else
            {
                //Maintain CacheSize Requirement
                if (Regex.CacheSize > 0 && Regex.Cache.Count >= Regex.CacheSize) Regex.Cache.Pop();

                // Initialize variables for compilation
                this.pattern = pattern;                         // Save pattern in instance variable
                len = pattern.Length;                         // Precompute pattern Length for speed
                idx = 0;                                        // Set parsing index to the first character
                lenInstruction = 0;                             // Set emitted instruction count to zero
                parens = 1;                                     // Set paren level to 1 (the implicit outer parens)

                // Initialize pass by reference flags value
                int[] flags = { NODE_TOPLEVEL };

                // Parse expression
                Expression(flags);

                // Should be at end of input
                if (idx != len)
                {
                    if (pattern[idx] == OpCode.Close) SyntaxError("Unmatched close paren");
                    SyntaxError("Unexpected input remains");
                }

                //Compile the result

                char[] ins = new char[lenInstruction];
                System.Array.Copy(instruction, 0, ins, 0, lenInstruction);
                //ins.CopyTo(instruction, 0);

                RegexProgram result = new RegexProgram(parens, ins, pattern);

                //If caching is enabled add the pattern to the cache
                //Should probably check for the Compiled Flag before putting it in
                if (Regex.CacheSize > 0 && !Regex.Cache.Contains(pattern))
                {
                    Regex.Cache.Push(result);
                }

                return result;
            }
        }
예제 #3
0
 /// <summary>
 /// Internal use only.
 /// Construct a matcher for a pre-compiled regular expression from program
 /// bytecode) data.  Permits special flags to be passed in to modify matching
 /// behaviour.
 /// RegexOptions.Normal              // Normal (case-sensitive) matching
 /// RegexOptions.CaseIndependant     // Case folded comparisons
 /// RegexOptions.Multiline           // Newline matches as BOL/EOL
 /// </summary>
 /// <param name="program">Compiled regular expression program (see RECompiler)</param>
 /// <param name="matchFlags">One or more of the MatchOptions</param>
 internal Regex(RegexProgram program, RegexOptions matchFlags)
 {
     Program = program;
     Options = matchFlags;
 }