int compCount() 
{
        return this.compCount + 1;
}

 public static Pattern compile(String pattern) 
{
        return compile(pattern, 0);
}

Compiles a regular expression, creating a new Pattern instance in the process. This is actually a convenience method that calls #compile(String, int) with a {@code flags} value of zero.

 public static Pattern compile(String pattern,
    int flags) throws PatternSyntaxException 
{
    	
    	if ((flags != 0) &&
    	   	((flags | flagsBitMask) != flagsBitMask)) {
    	    throw new IllegalArgumentException(Messages.getString("regex.1C"));
    	}
        AbstractSet.counter = 1;
        return new Pattern().compileImpl(pattern, flags);
}

Compiles a regular expression, creating a new {@code Pattern} instance in the process. Allows to set some flags that modify the behavior of the {@code Pattern}.

 int consCount() 
{
        return this.consCount + 1;
}

 public int flags() 
{
        return this.flags;
}

Returns the flags that have been set for this {@code Pattern}.

 static char getSupplement(char ch) 
{
        char res = ch;
        if (ch  >= 'a' && ch < = 'z') {
            res -= 32;
        } else if (ch  >= 'A' && ch < = 'Z') {
            res += 32;
        }
        return res;
}

Returns supplementary character. At this time only for ASCII chars.

 int groupCount() 
{
        return globalGroupIndex;
}

return number of groups found at compile time

 public Matcher matcher(CharSequence input) 
{
        return new Matcher(this, input);
}

Returns a Matcher for the {@code Pattern} and a given input. The {@code Matcher} can be used to match the {@code Pattern} against the whole input, find occurrences of the {@code Pattern} in the input, or replace parts of the input.

 public static boolean matches(String regex,
    CharSequence input) 
{
        return Pattern.compile(regex).matcher(input).matches();
}

Tries to match a given regular expression against a given input. This is actually nothing but a convenience method that compiles the regular expression into a {@code Pattern}, builds a Matcher for it, and then does the match. If the same regular expression is used for multiple operations, it is recommended to compile it into a {@code Pattern} explicitly and request a reusable {@code Matcher}.

 public String pattern() 
{
        return lexemes.toString();
}

Returns the regular expression that was compiled into this {@code Pattern}.

 public static String quote(String s) 
{
        StringBuilder sb = new StringBuilder().append("\\Q"); //$NON-NLS-1$
        int apos = 0;
        int k;
        while ((k = s.indexOf("\\E", apos))  >= 0) { //$NON-NLS-1$
            sb.append(s.substring(apos, k + 2)).append("\\\\E\\Q"); //$NON-NLS-1$
            apos = k + 2;
        }
        return sb.append(s.substring(apos)).append("\\E").toString(); //$NON-NLS-1$
}

Quotes a given string using "\Q" and "\E", so that all other meta-characters lose their special meaning. If the string is used for a {@code Pattern} afterwards, it can only be matched literally.

 public String[] split(CharSequence input) 
{
        return split(input, 0);
}

Splits a given input around occurrences of a regular expression. This is a convenience method that is equivalent to calling the method #split(java.lang.CharSequence, int) with a limit of 0.

 public String[] split(CharSequence inputSeq,
    int limit) 
{
        ArrayList res = new ArrayList();
        Matcher mat = matcher(inputSeq);
        int index = 0;
        int curPos = 0;       
        if (inputSeq.length() == 0) {
            return new String [] {""}; //$NON-NLS-1$
        } else {
            while (mat.find() && (index + 1 <  limit || limit < = 0)) {
                  res.add(inputSeq.subSequence(curPos, mat.start()).toString());
                  curPos = mat.end();
                  index++;
            }
            res.add(inputSeq.subSequence(curPos, inputSeq.length()).toString());
            index++;
            /*
             * discard trailing empty strings
             */
            if (limit == 0) {
                while (--index  >= 0 && res.get(index).toString().length() == 0) {
                       res.remove(index);
                }
            }
        }
        return (String[]) res.toArray(new String[index  >= 0 ? index : 0]);
}

Splits the given input sequence around occurrences of the {@code Pattern}. The function first determines all occurrences of the {@code Pattern} inside the input sequence. It then builds an array of the "remaining" strings before, in-between, and after these occurrences. An additional parameter determines the maximal number of entries in the resulting array and the handling of trailing empty strings.

 public String toString() 
{
        return this.pattern();
}