import java.io.FileInputStream;

import java.io.BufferedReader;

import java.io.FileReader;

import org.apache.tools.ant.types.RegularExpression;

import org.apache.tools.ant.util.FileUtils;

 * Selector that filters files based on a regular expression.

 * Selector that filters files based on whether they contain a

 * particular pattern expressed with a regular expression.

 * The input file(s) must be able to be properly processed by

 * a Reader instance. That is, it must be text only, no binary.

 *

 * The syntax of the regular expression depends on the implemtation that

 * you choose to use. The system property <code>ant.regexp.regexpimpl</code>

 * will be the classname of the implementation that will be used (the default

 * is <code>org.apache.tools.ant.util.regexp.JakartaOroRegexp</code> and

 * requires the Jakarta Oro Package).

 *

 * <pre>

 * For jdk  <= 1.3, there are two available implementations:

 *   org.apache.tools.ant.util.regexp.JakartaOroRegexp (the default)

 *        Requires  the jakarta-oro package

 *

 *   org.apache.tools.ant.util.regexp.JakartaRegexpRegexp

 *        Requires the jakarta-regexp package

 * @author <a href="mailto:jvandermeer2@comcast.net">Jay van der Meer</a>

 * For jdk >= 1.4 an additional implementation is available:

 * @since Ant 1.6

 *   org.apache.tools.ant.util.regexp.Jdk14RegexpRegexp

 *        Requires the jdk 1.4 built in regular expression package.

 *

 *   Attributes:

 *

 *     pattern --> The Regular expression to search for

 *     flags   --> The options to give to the search. For more information, consult the Perl5 syntax.

 *                 i = Case insensitive match

 *                 m = Multiline.  Treat the string as multiple lines of input, using

 *                     "^" and "$" as the start or end of any line, respectively, rather

 *                     than start or end of string.

 *                 m = Singleline.  Treat the string as a single line of input, using

 *                     "." to match any character, including a newline, which normally,

 *                     it would not match.

 *

 *     byline  --> Should files be processed a single line at a time (default is false)

 *                 "true" indicates to perform search on a line by line basis

 *                 "false" indicates to perform search on the whole file at once.

 *

 *

 * @author Thorsten Möller - Thorsten.Moeller@jexam.de

 * 

 * $Revision: $; $Author: $; $Date: $

public class ContainsRegexpSelector extends BaseExtendSelector {

public class ContainsRegexpSelector extends BaseExtendSelector

{

    private String userProvidedExpression = null;

	private boolean byline;

    private RegularExpression myRegExp = null;

	private String flags;

    private Regexp myExpression = null;

	private Regexp regexp = null;

    /** Key to used for parameterized custom selector */

	private static final RegexpFactory factory = new RegexpFactory();

    public static final String EXPRESSION_KEY = "expression";

	public static final String PATTERN_KEY = "pattern";

    /**

	public static final String FLAGS_KEY = "flags";

     * Creates a new <code>ContainsRegexpSelector</code> instance.

	public static final String BYLINE_KEY = "byline";

     */

    public ContainsRegexpSelector() {

	public ContainsRegexpSelector()

    }

	{

		this.regexp = factory.newRegexp();

    /**

	}

     * @return a string describing this object

     */

	public String toString()

    public String toString() {

	{

        StringBuffer buf = new StringBuffer(

		StringBuffer buf = new StringBuffer("{containsRegexpSelector pattern: ");

                "{containsregexpselector expression: ");

		buf.append(regexp.getPattern());

        buf.append(userProvidedExpression);

		buf.append(" byline: ");

        buf.append("}");

		buf.append(Boolean.toString(byline));

        return buf.toString();

		buf.append(" flags: ");

    }

		buf.append(flags);

		buf.append("}");

    /**

		return buf.toString();

     * The regular expression used to search the file.

	}

     *

     * @param theexpression this must match a line in the file to be selected.

	/**

     */

	 * Process the file(s) one line at a time.

    public void setExpression(String theexpression) {

	 * This is useful if you want to only search for the first occurence of a regular expression on

        this.userProvidedExpression = theexpression;

	 * each line, which is not easy to do when processing the file as a whole.

    }

	 * Defaults to <i>false</i>.</td>

	 */

    /**

	public void setByLine(String byline)

     * When using this as a custom selector, this method will be called.

	{

     * It translates each parameter into the appropriate setXXX() call.

		Boolean res = Boolean.valueOf(byline);

     *

		if (res == null)

     * @param parameters the complete set of parameters for this selector

		{

     */

			res = Boolean.FALSE;

    public void setParameters(Parameter[] parameters) {

		}

        super.setParameters(parameters);

		this.byline = res.booleanValue();

        if (parameters != null) {

	}

            for (int i = 0; i < parameters.length; i++) {

                String paramname = parameters[i].getName();

	/**

                if (EXPRESSION_KEY.equalsIgnoreCase(paramname)) {

	 * The flags to use when matching the regular expression.  For more

                    setExpression(parameters[i].getValue());

	 * information, consult the Perl5 syntax.

                } else {

	 * <ul>

                    setError("Invalid parameter " + paramname);

	 *  <li>i : Case Insensitive.  Do not consider case in the match

                }

	 *  <li>m : Multiline.  Treat the string as multiple lines of input, 

            }

	 *         using "^" and "$" as the start or end of any line, respectively, rather than start or end of string.

        }

	 *  <li>s : Singleline.  Treat the string as a single line of input, using

    }

	 *        "." to match any character, including a newline, which normally, it would not match.

	 *</ul>

    /**

	 */

     * Checks that an expression was specified.

	public void setFlags(String flags)

     *

	{

     */

		this.flags = flags;

    public void verifySettings() {

	}

        if (userProvidedExpression == null) {

            setError("The expression attribute is required");

	/**

        }

	 * The pattern to search for within a file.

    }

	 *

	 * @param regexp the string that a file must contain to be selected.

    /**

	 */

     * Tests a regular expression against each line of text in the file.

	public void setRegexp(String pattern)

     *

	{

     * @param basedir the base directory the scan is being done from

		this.regexp.setPattern(pattern);

     * @param filename is the name of the file to check

	}

     * @param file is a java.io.File object the selector can use

     * @return whether the file should be selected or not

	/**

     */

	 * When using this as a custom selector, this method will be called.

    public boolean isSelected(File basedir, String filename, File file) {

	 * It translates each parameter into the appropriate setXXX() call.

        String teststr = null;

	 *

        BufferedReader in = null;

	 * @param parameters the complete set of parameters for this selector

	 */

        // throw BuildException on error

	public void setParameters(Parameter[] parameters)

	{

        validate();

		super.setParameters(parameters);

		if (parameters != null)

        if (file.isDirectory()) {

		{

            return true;

			for (int i = 0; i < parameters.length; i++)

        }

			{

				String paramname = parameters[i].getName();

        if (myRegExp == null) {

				if (PATTERN_KEY.equalsIgnoreCase(paramname))

            myRegExp = new RegularExpression();

				{

            myRegExp.setPattern(userProvidedExpression);

					setRegexp(parameters[i].getValue());

            myExpression = myRegExp.getRegexp(getProject());

				}

        }

				else if (BYLINE_KEY.equalsIgnoreCase(paramname))

				{

        try {

					setByLine(parameters[i].getValue());

            in = new BufferedReader(new InputStreamReader(

				}

                    new FileInputStream(file)));

				else if (FLAGS_KEY.equalsIgnoreCase(paramname))

				{

            teststr = in.readLine();

					setFlags(parameters[i].getValue());

				}

            while (teststr != null) {

				else

				{

                if (myExpression.matches(teststr)) {

					setError("Invalid parameter " + paramname);

                    return true;

				}

                }

			}

                teststr = in.readLine();

		}

            }

	}

            return false;

	/**

        } catch (IOException ioe) {

	 * Checks to make sure all settings are kosher. In this case, it

            throw new BuildException("Could not read file " + filename);

	 * means that the pattern attribute has been set.

        } finally {

	 *

            if (in != null) {

	 */

                try {

	public void verifySettings()

                    in.close();

	{

                } catch (Exception e) {

		if (regexp == null)

                    throw new BuildException("Could not close file "

		{

                                             + filename);

			setError("The pattern attribute is required");

                }

		}

            }

	}

        }

    }

	/**

	 * The heart of the matter. This is where the selector gets to decide

	 * on the inclusion of a file in a particular fileset.

	 *

	 * @param basedir the base directory the scan is being done from

	 * @param filename is the name of the file to check

	 * @param file is a java.io.File object the selector can use

	 * @return whether the file should be selected or not

	 */

	public boolean isSelected(File basedir, String filename, File file)

	{

		// throw BuildException on error

		validate();

		if (file.isDirectory())

		{

			return true;

		}

		int options = 0;

		//		if (flags.indexOf('g') != -1)	options |= Regexp.REPLACE_ALL;

		if (flags.indexOf('i') != -1)

			options |= Regexp.MATCH_CASE_INSENSITIVE;

		if (flags.indexOf('m') != -1)

			options |= Regexp.MATCH_MULTILINE;

		if (flags.indexOf('s') != -1)

			options |= Regexp.MATCH_SINGLELINE;

		FileReader r = null;

		try

		{

			r = new FileReader(file);

			BufferedReader br = new BufferedReader(r);

			log(

				"Searching pattern '"

					+ regexp.getPattern()

					+ "' in '"

					+ file.getPath()

					+ "'"

					+ (byline ? " by line" : "")

					+ (flags.length() > 0 ? " with flags: '" + flags + "'" : "")

					+ ".",

				Project.MSG_VERBOSE);

			if (byline)

			{

				StringBuffer linebuf = new StringBuffer();

				String line = null;

				int c;

				boolean hasCR = false;

				do

				{

					c = br.read();

					if (c == '\r')

					{

						if (hasCR)

						{

							// second CR -> EOL + possibly empty line

							line = linebuf.toString();

							if (regexp.matches(line, options))

							{

								return true;

							}

							linebuf.setLength(0);

							// hasCR is still true (for the second one)

						}

						else

						{

							// first CR in this line

							hasCR = true;

						}

					}

					else if (c == '\n')

					{

						// LF -> EOL

						line = linebuf.toString();

						if (regexp.matches(line, options))

						{

							return true;

						}

						if (hasCR)

						{

							hasCR = false;

						}

						linebuf.setLength(0);

					}

					else

					{ // any other char

						if ((hasCR) || (c < 0))

						{

							// Mac-style linebreak or EOF (or both)

							line = linebuf.toString();

							if (regexp.matches(line, options))

							{

								return true;

							}

							if (hasCR)

							{

								hasCR = false;

							}

							linebuf.setLength(0);

						}

						if (c >= 0)

						{

							linebuf.append((char) c);

						}

					}

				}

				while (c >= 0);

			}

			else

			{

				String buf = FileUtils.readFully(br);

				if (regexp.matches(buf, options))

				{

					return true;

				}

			}

			r.close();

			r = null;

		}

		catch (IOException ioe)

		{

			throw new BuildException("Could not read file " + filename);

		}

		finally

		{

			try

			{

				if (r != null)

				{

					r.close();

				}

			}

			catch (Exception e)

			{

				throw new BuildException("Could not close file " + filename);

			}

		}

		return false;

	}