001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: *
017: */
018:
019: package org.apache.tools.ant.util.regexp;
020:
021: import java.util.Vector;
022: import java.util.regex.Matcher;
023: import java.util.regex.Pattern;
024: import java.util.regex.PatternSyntaxException;
025: import org.apache.tools.ant.BuildException;
026:
027: /**
028: * Implementation of RegexpMatcher for the built-in regexp matcher of
029: * JDK 1.4. UNIX_LINES option is enabled as a default.
030: *
031: */
032: public class Jdk14RegexpMatcher implements RegexpMatcher {
033:
034: private String pattern;
035:
036: /** Constructor for JakartaOroRegexp */
037: public Jdk14RegexpMatcher() {
038: }
039:
040: /**
041: * Set the regexp pattern from the String description.
042: * @param pattern the pattern to match
043: */
044: public void setPattern(String pattern) {
045: this .pattern = pattern;
046: }
047:
048: /**
049: * Get a String representation of the regexp pattern
050: * @return the pattern
051: * @throws BuildException on error
052: */
053: public String getPattern() {
054: return pattern;
055: }
056:
057: /**
058: * Get a compiled representation of the regexp pattern
059: * @param options the options
060: * @return the compiled pattern
061: * @throws BuildException on error
062: */
063: protected Pattern getCompiledPattern(int options)
064: throws BuildException {
065: int cOptions = getCompilerOptions(options);
066: try {
067: Pattern p = Pattern.compile(this .pattern, cOptions);
068: return p;
069: } catch (PatternSyntaxException e) {
070: throw new BuildException(e);
071: }
072: }
073:
074: /**
075: * Does the given argument match the pattern using default options?
076: * @param argument the string to match against
077: * @return true if the pattern matches
078: * @throws BuildException on error
079: */
080: public boolean matches(String argument) throws BuildException {
081: return matches(argument, MATCH_DEFAULT);
082: }
083:
084: /**
085: * Does the given argument match the pattern?
086: * @param input the string to match against
087: * @param options the regex options to use
088: * @return true if the pattern matches
089: * @throws BuildException on error
090: */
091: public boolean matches(String input, int options)
092: throws BuildException {
093: try {
094: Pattern p = getCompiledPattern(options);
095: return p.matcher(input).find();
096: } catch (Exception e) {
097: throw new BuildException(e);
098: }
099: }
100:
101: /**
102: * Returns a Vector of matched groups found in the argument
103: * using default options.
104: *
105: * <p>Group 0 will be the full match, the rest are the
106: * parenthesized subexpressions</p>.
107: *
108: * @param argument the string to match against
109: * @return the vector of groups
110: * @throws BuildException on error
111: */
112: public Vector getGroups(String argument) throws BuildException {
113: return getGroups(argument, MATCH_DEFAULT);
114: }
115:
116: /**
117: * Returns a Vector of matched groups found in the argument.
118: *
119: * <p>Group 0 will be the full match, the rest are the
120: * parenthesized subexpressions</p>.
121: *
122: * @param input the string to match against
123: * @param options the regex options to use
124: * @return the vector of groups
125: * @throws BuildException on error
126: */
127: public Vector getGroups(String input, int options)
128: throws BuildException {
129: Pattern p = getCompiledPattern(options);
130: Matcher matcher = p.matcher(input);
131: if (!matcher.find()) {
132: return null;
133: }
134: Vector v = new Vector();
135: int cnt = matcher.groupCount();
136: for (int i = 0; i <= cnt; i++) {
137: String match = matcher.group(i);
138: // treat non-matching groups as empty matches
139: if (match == null) {
140: match = "";
141: }
142: v.addElement(match);
143: }
144: return v;
145: }
146:
147: /**
148: * Convert the generic options to the regex compiler specific options.
149: * @param options the generic options
150: * @return the specific options
151: */
152: protected int getCompilerOptions(int options) {
153: // be strict about line separator
154: int cOptions = Pattern.UNIX_LINES;
155:
156: if (RegexpUtil.hasFlag(options, MATCH_CASE_INSENSITIVE)) {
157: cOptions |= Pattern.CASE_INSENSITIVE;
158: }
159: if (RegexpUtil.hasFlag(options, MATCH_MULTILINE)) {
160: cOptions |= Pattern.MULTILINE;
161: }
162: if (RegexpUtil.hasFlag(options, MATCH_SINGLELINE)) {
163: cOptions |= Pattern.DOTALL;
164: }
165:
166: return cOptions;
167: }
168:
169: }
|