public class JakartaRegexpMatcher implements RegexpMatcher { private String pattern; /** * Set the regexp pattern from the String description. * @param pattern the pattern to match */ public void setPattern(String pattern) { this.pattern = pattern; } /** * Get a String representation of the regexp pattern * @return the pattern */ public String getPattern() { return pattern; } /** * Compile the pattern. * * @param options the ant regexp options * @return a compiled pattern * @exception BuildException if an error occurs */ protected RE getCompiledPattern(int options) throws BuildException { int cOptions = getCompilerOptions(options); try { RE reg = new RE(pattern); reg.setMatchFlags(cOptions); return reg; } catch (RESyntaxException e) { throw new BuildException(e); } } /** * Does the given argument match the pattern? * @param argument the string to match against * @return true if the pattern matches * @throws BuildException on error */ public boolean matches(String argument) throws BuildException { return matches(argument, MATCH_DEFAULT); } /** * Does the given argument match the pattern? * @param input the string to match against * @param options the regex options to use * @return true if the pattern matches * @throws BuildException on error */ public boolean matches(String input, int options) throws BuildException { return matches(input, getCompiledPattern(options)); } private boolean matches(String input, RE reg) { return reg.match(input); } /** * Returns a Vector of matched groups found in the argument * using default options. * * <p>Group 0 will be the full match, the rest are the * parenthesized subexpressions</p>. * * @param argument the string to match against * @return the vector of groups * @throws BuildException on error */ public Vector getGroups(String argument) throws BuildException { return getGroups(argument, MATCH_DEFAULT); } /** * Returns a Vector of matched groups found in the argument. * * <p>Group 0 will be the full match, the rest are the * parenthesized subexpressions</p>. * * @param input the string to match against * @param options the regex options to use * @return the vector of groups * @throws BuildException on error */ public Vector getGroups(String input, int options) throws BuildException { RE reg = getCompiledPattern(options); if (!matches(input, reg)) { return null; } Vector v = new Vector(); int cnt = reg.getParenCount(); for (int i = 0; i < cnt; i++) { String match = reg.getParen(i); // treat non-matching groups as empty matches if (match == null) { match = ""; } v.addElement(match); } return v; } /** * Convert the generic options to the regex compiler specific options. * @param options the generic options * @return the specific options */ protected int getCompilerOptions(int options) { int cOptions = RE.MATCH_NORMAL; if (RegexpUtil.hasFlag(options, MATCH_CASE_INSENSITIVE)) { cOptions |= RE.MATCH_CASEINDEPENDENT; } if (RegexpUtil.hasFlag(options, MATCH_MULTILINE)) { cOptions |= RE.MATCH_MULTILINE; } if (RegexpUtil.hasFlag(options, MATCH_SINGLELINE)) { cOptions |= RE.MATCH_SINGLELINE; } return cOptions;
public class Jdk14RegexpMatcher implements RegexpMatcher { private String pattern; /** Constructor for JakartaOroRegexp */ public Jdk14RegexpMatcher() { } /** * Set the regexp pattern from the String description. * @param pattern the pattern to match */ public void setPattern(String pattern) { this.pattern = pattern; } /** * Get a String representation of the regexp pattern * @return the pattern * @throws BuildException on error */ public String getPattern() { return pattern; } /** * Get a compiled representation of the regexp pattern * @param options the options * @return the compiled pattern * @throws BuildException on error */ protected Pattern getCompiledPattern(int options) throws BuildException { int cOptions = getCompilerOptions(options); try { Pattern p = Pattern.compile(this.pattern, cOptions); return p; } catch (PatternSyntaxException e) { throw new BuildException(e); } } /** * Does the given argument match the pattern using default options? * @param argument the string to match against * @return true if the pattern matches * @throws BuildException on error */ public boolean matches(String argument) throws BuildException { return matches(argument, MATCH_DEFAULT); } /** * Does the given argument match the pattern? * @param input the string to match against * @param options the regex options to use * @return true if the pattern matches * @throws BuildException on error */ public boolean matches(String input, int options) throws BuildException { try { Pattern p = getCompiledPattern(options); return p.matcher(input).find(); } catch (Exception e) { throw new BuildException(e); } } /** * Returns a Vector of matched groups found in the argument * using default options. * * <p>Group 0 will be the full match, the rest are the * parenthesized subexpressions</p>. * * @param argument the string to match against * @return the vector of groups * @throws BuildException on error */ public Vector getGroups(String argument) throws BuildException { return getGroups(argument, MATCH_DEFAULT); } /** * Returns a Vector of matched groups found in the argument. * * <p>Group 0 will be the full match, the rest are the * parenthesized subexpressions</p>. * * @param input the string to match against * @param options the regex options to use * @return the vector of groups * @throws BuildException on error */ public Vector getGroups(String input, int options) throws BuildException { Pattern p = getCompiledPattern(options); Matcher matcher = p.matcher(input); if (!matcher.find()) { return null; } Vector v = new Vector(); int cnt = matcher.groupCount(); for (int i = 0; i <= cnt; i++) { String match = matcher.group(i); // treat non-matching groups as empty matches if (match == null) { match = ""; } v.addElement(match); } return v; } /** * Convert the generic options to the regex compiler specific options. * @param options the generic options * @return the specific options */ protected int getCompilerOptions(int options) { // be strict about line separator int cOptions = Pattern.UNIX_LINES; if (RegexpUtil.hasFlag(options, MATCH_CASE_INSENSITIVE)) { cOptions |= Pattern.CASE_INSENSITIVE; } if (RegexpUtil.hasFlag(options, MATCH_MULTILINE)) { cOptions |= Pattern.MULTILINE; } if (RegexpUtil.hasFlag(options, MATCH_SINGLELINE)) { cOptions |= Pattern.DOTALL; } return cOptions;
Clone fragments detected by clone detection tool
File path: /apache-ant-1.7.0/src/org/apache/tools/ant/util/regexp/JakartaRegexpMatcher.java File path: /apache-ant-1.7.0/src/org/apache/tools/ant/util/regexp/Jdk14RegexpMatcher.java
Method name: Method name:
Number of AST nodes: 0 Number of AST nodes: 0
1
public class JakartaRegexpMatcher implements RegexpMatcher {
1
public class Jdk14RegexpMatcher implements RegexpMatcher {
2
    private String pattern;
2
    private String pattern;
3
    /** Constructor for JakartaOroRegexp */
4
    public Jdk14RegexpMatcher() {
5
    }
3
    /**
6
    /**
4
     * Set the regexp pattern from the String description.
7
     * Set the regexp pattern from the String description.
5
     * @param pattern the pattern to match
8
     * @param pattern the pattern to match
6
     */
9
     */
7
    public void setPattern(String pattern) {
10
    public void setPattern(String pattern) {
8
        this.pattern = pattern;
11
        this.pattern = pattern;
9
    }
12
    }
10
    /**
13
    /**
11
     * Get a String representation of the regexp pattern
14
     * Get a String representation of the regexp pattern
12
     * @return the pattern
15
     * @return the pattern
16
     * @throws BuildException on error
13
     */
17
     */
14
    public String getPattern() {
18
    public String getPattern() {
15
        return pattern;
19
        return pattern;
16
    }
20
    }
17
    /**
21
    /**
18
     * Compile the pattern.
22
     * 
19
     *
23
Get a compiled representation of the regexp pattern
20
     * @param options the ant regexp options
24
     * @param options the options
21
     * @return a compiled pattern
25
     * @return the compiled pattern
22
     * @exception BuildException if an error occurs
26
     * @throws BuildException on error
23
     */
27
     */
24
    protected RE getCompiledPattern(int options)
28
    protected Pattern getCompiledPattern(int options)
25
        throws BuildException {
29
        throws BuildException {
26
        int cOptions = getCompilerOptions(options);
30
        int cOptions = getCompilerOptions(options);
27
        try {
31
        try {
28
            RE reg = new RE(pattern);
32
            
29
            reg.setMatchFlags(cOptions);
33
Pattern p = Pattern.compile(this.pattern, cOptions);
30
            return reg;
34
            return p;
31
        } catch (RESyntaxException e) {
35
        } catch (PatternSyntaxException e) {
32
            throw new BuildException(e);
36
            throw new BuildException(e);
33
        }
37
        }
34
    }
38
    }
35
    /**
39
    /**
36
     * Does the given argument match the pattern?
40
     * Does the given argument match the pattern using default options?
37
     * @param argument the string to match against
41
     * @param argument the string to match against
38
     * @return true if the pattern matches
42
     * @return true if the pattern matches
39
     * @throws BuildException on error
43
     * @throws BuildException on error
40
     */
44
     */
41
    public boolean matches(String argument) throws BuildException {
45
    public boolean matches(String argument) throws BuildException {
42
        return matches(argument, MATCH_DEFAULT);
46
        return matches(argument, MATCH_DEFAULT);
43
    }
47
    }
44
    /**
48
    /**
45
     * Does the given argument match the pattern?
49
     * Does the given argument match the pattern?
46
     * @param input the string to match against
50
     * @param input the string to match against
47
     * @param options the regex options to use
51
     * @param options the regex options to use
48
     * @return true if the pattern matches
52
     * @return true if the pattern matches
49
     * @throws BuildException on error
53
     * @throws BuildException on error
50
     */
54
     */
51
    public boolean matches(String input, int options)
55
    public boolean matches(String input, int options)
52
        throws BuildException {
56
        throws BuildException {
53
        return matches(input,
57
        try {
54
 getCompiledPattern(options));
58
            Pattern p = getCompiledPattern(options);
55
    }
59
    
56
    private boolean matches(String input, RE reg) {
60
    
57
        return reg.match(input);
61
    return p.matcher(input).find();
62
        } catch (Exception e) {
63
            throw new BuildException(e);
64
        }
58
    }
65
    }
59
    /**
66
    /**
60
     * Returns a Vector of matched groups found in the argument
67
     * Returns a Vector of matched groups found in the argument
61
     * using default options.
68
     * using default options.
62
     *
69
     *
63
     * <p>Group 0 will be the full match, the rest are the
70
     * <p>Group 0 will be the full match, the rest are the
64
     * parenthesized subexpressions</p>.
71
     * parenthesized subexpressions</p>.
65
     *
72
     *
66
     * @param argument the string to match against
73
     * @param argument the string to match against
67
     * @return the vector of groups
74
     * @return the vector of groups
68
     * @throws BuildException on error
75
     * @throws BuildException on error
69
     */
76
     */
70
    public Vector getGroups(String argument) throws BuildException {
77
    public Vector getGroups(String argument) throws BuildException {
71
        return getGroups(argument, MATCH_DEFAULT);
78
        return getGroups(argument, MATCH_DEFAULT);
72
    }
79
    }
73
    /**
80
    /**
74
     * Returns a Vector of matched groups found in the argument.
81
     * Returns a Vector of matched groups found in the argument.
75
     *
82
     *
76
     * <p>Group 0 will be the full match, the rest are the
83
     * <p>Group 0 will be the full match, the rest are the
77
     * parenthesized subexpressions</p>.
84
     * parenthesized subexpressions</p>.
78
     *
85
     *
79
     * @param input the string to match against
86
     * @param input the string to match against
80
     * @param options the regex options to use
87
     * @param options the regex options to use
81
     * @return the vector of groups
88
     * @return the vector of groups
82
     * @throws BuildException on error
89
     * @throws BuildException on error
83
     */
90
     */
84
    public Vector getGroups(String input, int options)
91
    public Vector getGroups(String input, int options)
85
        throws BuildException {
92
        throws BuildException {
86
        RE reg = getCompiledPattern(options);
93
        Pattern p = getCompiledPattern(options);
87
        if (!matches(input, reg
94
        Matcher matcher = p.matcher(input);
88
)) {
95
        if (!matcher.find()) {
89
            return null;
96
            return null;
90
        }
97
        }
91
        Vector v = new Vector();
98
        Vector v = new Vector();
92
        int cnt = reg.getParenCount();
99
        int cnt = matcher.groupCount();
93
        for (int i = 0; i < cnt; i++) {
100
        for (int i = 0; i <= cnt; i++) {
94
            String match = reg.getParen(i);
101
            String match = matcher.group(i);
95
            // treat non-matching groups as empty matches
102
            // treat non-matching groups as empty matches
96
            if (match == null) {
103
            if (match == null) {
97
                match = "";
104
                match = "";
98
            }
105
            }
99
            v.addElement(match);
106
            v.addElement(match);
100
        }
107
        }
101
        return v;
108
        return v;
102
    }
109
    }
103
    /**
110
    /**
104
     * Convert the generic options to the regex compiler specific options.
111
     * Convert the generic options to the regex compiler specific options.
105
     * @param options the generic options
112
     * @param options the generic options
106
     * @return the specific options
113
     * @return the specific options
107
     */
114
     */
108
    protected int getCompilerOptions(int options) {
115
    protected int getCompilerOptions(int options) {
109
        int cOptions = RE.MATCH_NORMAL
116
        // be strict about line separator
110
;
117
        int cOptions = Pattern.UNIX_LINES;
111
        if (RegexpUtil.hasFlag(options, MATCH_CASE_INSENSITIVE)) {
118
        if (RegexpUtil.hasFlag(options, MATCH_CASE_INSENSITIVE)) {
112
            cOptions |= RE.MATCH_CASEINDEPENDENT;
119
            cOptions |= Pattern.CASE_INSENSITIVE;
113
        }
120
        }
114
        if (RegexpUtil.hasFlag(options, MATCH_MULTILINE)) {
121
        if (RegexpUtil.hasFlag(options, MATCH_MULTILINE)) {
115
            cOptions |= RE.MATCH_MULTILINE;
122
            cOptions |= Pattern.MULTILINE;
116
        }
123
        }
117
        if (RegexpUtil.hasFlag(options, MATCH_SINGLELINE)) {
124
        if (RegexpUtil.hasFlag(options, MATCH_SINGLELINE)) {
118
            cOptions |= RE.MATCH_SINGLELINE;
125
            cOptions |= Pattern.DOTALL;
119
        }
126
        }
120
        return cOptions;
127
        return cOptions;
121
    
128
    
Summary
Number of common nesting structure subtrees0
Number of refactorable cases0
Number of non-refactorable cases0
Time elapsed for finding largest common nesting structure subtrees (ms)0.0
Clones location
Number of node comparisons0