public void testRegexReplace() throws Exception {

		fDocument.set(

				"UnixWindowsMacInferred\n" +

				"Chars"

		);

		FindReplaceDocumentAdapter findReplaceDocumentAdapter= new FindReplaceDocumentAdapter(fDocument);

		regexReplace("Unix", "$0\\n", findReplaceDocumentAdapter);

		regexReplace("(Windows)", "$1\\r\\n", findReplaceDocumentAdapter);

		regexReplace("(M)ac", "\\0\\r", findReplaceDocumentAdapter);

		regexReplace("(Inferred)", "\\1\\R", findReplaceDocumentAdapter);

		regexReplace("Chars", "\\\\, \\xF6, \\u00F6, \\t, \\n, \\r, \\f, \\a, \\e, \\cF", findReplaceDocumentAdapter);

		String text= "Unix\nWindows\r\nMac\rInferred\n\n" +

			"\\, \u00F6, \u00F6, \t, \n, \r, \f, \u0007, \u001B, \u0006";

		assertEquals(text, fDocument.get());

	}

	public void testRegexReplace2() throws Exception {

		FindReplaceDocumentAdapter findReplaceDocumentAdapter= new FindReplaceDocumentAdapter(fDocument);

		fDocument.set("foo");

		regexReplace("foo", "\\00", findReplaceDocumentAdapter);

		assertEquals("foo0", fDocument.get());

		fDocument.set("foo");

		regexReplace("foo", "\\010", findReplaceDocumentAdapter);

		assertEquals("foo10", fDocument.get());

		fDocument.set("foo");

		regexReplace("foo", "$00", findReplaceDocumentAdapter);

		assertEquals("foo0", fDocument.get());

		fDocument.set("foo");

		regexReplace("foo", "$010", findReplaceDocumentAdapter);

		assertEquals("foo10", fDocument.get());

	}

	public void testRegexReplace3() throws Exception {

		FindReplaceDocumentAdapter findReplaceDocumentAdapter= new FindReplaceDocumentAdapter(fDocument);

		fDocument.set("foo");

		regexReplace("(f)oo", "\\10", findReplaceDocumentAdapter);

		assertEquals("f0", fDocument.get());

		fDocument.set("foo");

		regexReplace("(f)oo", "$10", findReplaceDocumentAdapter);

		assertEquals("f0", fDocument.get());

	}

	private void regexReplace(String find, String replace, FindReplaceDocumentAdapter findReplaceDocumentAdapter) throws BadLocationException {

		findReplaceDocumentAdapter.find(0, find, true, true, false, true); //$NON-NLS-1$

		IRegion r= findReplaceDocumentAdapter.replace(replace, true); //$NON-NLS-1$

		assertNotNull(r);

	}

  <table border="1" cellpadding="5" summary="supported constructs in the replace field">

    <tbody>

      <tr>

        <td>$i</td>

        <td>inserts

          <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/util/regex/Pattern.html#cg">capturing group</a>

          i.

        </td>

      </tr>

      <tr>

        <td>\i</td>

        <td>inserts

          <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/util/regex/Pattern.html#cg">capturing group</a>

          i (same as $i).

        </td>

      </tr>

      <tr> <td>\<i>x</i></td> <td>quotes character <i>x</i> (unless \<i>x</i> has a special meaning)</td> </tr>

      <tr> <td>\R</td> <td>inserts the default line delimiter of the document</td> </tr>

      <tr> <td>\x<i>hh</i></td> <td>inserts the hexadecimal character <i>hh</i></td> </tr>

      <tr> <td>\u<i>hhhh</i></td> <td>inserts the Unicode character <i>hhhh</i></td> </tr>

      <tr> <td>\n</td> <td>inserts a newline character (usually, you should use \R instead)</td> </tr>

      <tr> <td>\r</td> <td>inserts a carriage-return character (usually, you should use \R instead)</td> </tr>

      <tr> <td>\t</td> <td>inserts a tab character</td> </tr>

      <tr> <td>\f</td> <td>inserts a form-feed character</td> </tr>

      <tr> <td>\a</td> <td>inserts an alert (beep) character</td> </tr>

      <tr> <td>\e</td> <td>inserts an escape character</td> </tr>

      <tr> <td>\c<i>C</i></td> <td>inserts a the control character for <i>C</i></td> </tr>

    </tbody>

  </table>

	public static String displayString_bs_rnWU;

	public static String additionalInfo_bs_rnWU;

	public static String displayString_bs_rn;

	public static String additionalInfo_bs_rn;

			addBracketProposal("\\r?\\n", 5, RegExMessages.displayString_bs_rnWU, RegExMessages.additionalInfo_bs_rnWU); //$NON-NLS-1$

			addBracketProposal("(\\r\\n?|\\n)", 10, RegExMessages.displayString_bs_rn, RegExMessages.additionalInfo_bs_rn); //$NON-NLS-1$

displayString_replace_cap= \\i - Match of the capturing group i

additionalInfo_replace_cap= Match of the capturing group i.\n\n\

\\i is the string that has been saved as capturing group i.\n\

\\0 is the subsequence matched by the entire expression.\n\

\n\

Note: \\i is equivalent to $i 

					replaceText= interpretCharacterEscapes(replaceText);

	 * Interprets escaped characters in the given replace pattern.

	 * 

	 * @param replaceText the replace pattern

	 * @return a replace pattern with escaped characters substituted by the respective characters

	 */

	private String interpretCharacterEscapes(String replaceText) {

		int length= replaceText.length();

		boolean inEscape= false;

		StringBuffer buf= null;

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

			char ch= replaceText.charAt(i);

			if (inEscape) {

				switch (ch) {

					case 'r':

						buf= appendToBuffer('\r', buf, replaceText, i - 1);

						break;

					case 'n':

						buf= appendToBuffer('\n', buf, replaceText, i - 1);

						break;

					case 't':

						buf= appendToBuffer('\t', buf, replaceText, i - 1);

						break;

					case 'f':

						buf= appendToBuffer('\f', buf, replaceText, i - 1);

						break;

					case 'a':

						buf= appendToBuffer('\u0007', buf, replaceText, i - 1);

						break;

					case 'e':

						buf= appendToBuffer('\u001B', buf, replaceText, i - 1);

						break;

					case 'R': //see http://www.unicode.org/unicode/reports/tr18/#Line_Boundaries

						buf= appendToBuffer(TextUtilities.getDefaultLineDelimiter(fDocument), buf, replaceText, i - 1);

						break;

					/*

					 * \0 for octal is not supported in replace string, since it

					 * would conflict with capturing group \0, etc.

					 */

					case '0':

						buf= appendToBuffer('$', buf, replaceText, i - 1);

						buf.append(ch);

						/*

						 * Feature in java.util.regex.Matcher#replaceFirst(String):

						 * $00, $000, etc. are interpreted as $0 and

						 * $01, $001, etc. are interpreted as $1, etc. .

						 * If we support \0 as replacement pattern for capturing group 0,

						 * it would not be possible any more to write a replacement pattern

						 * that appends 0 to a capturing group (like $0\0).

						 * The fix is to consider \00 and $00 as $0\0, and

						 * \01 and $01 as $0\1, etc.

						 */

						if (i + 1 < length) {

							char nextCh= replaceText.charAt(i + 1);

							if ('0' <= nextCh && nextCh <= '9') {

								buf.append('\\');

								break;

							}

						}

						break;

					case '1':

					case '2':

					case '3':

					case '4':

					case '5':

					case '6':

					case '7':

					case '8':

					case '9':

						buf= appendToBuffer('$', buf, replaceText, i - 1);

						buf.append(ch);

						break;

					case 'c':

						if (i + 1 < length) {

							ch= replaceText.charAt(i + 1);

							buf= appendToBuffer((char) (ch ^ 64), buf, replaceText, i - 1);

							i++;

						} else {

							String msg= TextMessages.getFormattedString(

									"FindReplaceDocumentAdapter.illegalControlEscape", //$NON-NLS-1$

									"\\c"); //$NON-NLS-1$

							throw new PatternSyntaxException(msg, replaceText, i);

						}

						break;

					case 'x':

						if (i + 2 < length) {

							int parsedInt;

							try {

								parsedInt= Integer.parseInt(replaceText.substring(i + 1, i + 3), 16);

								if (parsedInt < 0)

									throw new NumberFormatException();

							} catch (NumberFormatException e) {

								String msg= TextMessages.getFormattedString(

										"FindReplaceDocumentAdapter.illegalHexEscape", //$NON-NLS-1$

										replaceText.substring(i - 1, i + 3));

								throw new PatternSyntaxException(msg, replaceText, i);

							}

							buf= appendToBuffer((char) parsedInt, buf, replaceText, i - 1);

							i+= 2;

						} else {

							String msg= TextMessages.getFormattedString(

									"FindReplaceDocumentAdapter.illegalHexEscape", //$NON-NLS-1$

									replaceText.substring(i - 1, length));

							throw new PatternSyntaxException(msg, replaceText, i);

						}

						break;

					case 'u':

						if (i + 4 < length) {

							int parsedInt;

							try {

								parsedInt= Integer.parseInt(replaceText.substring(i + 1, i + 5), 16);

								if (parsedInt < 0)

									throw new NumberFormatException();

							} catch (NumberFormatException e) {

								String msg= TextMessages.getFormattedString(

										"FindReplaceDocumentAdapter.illegalUnicodeEscape", //$NON-NLS-1$

										replaceText.substring(i - 1, i + 5));

								throw new PatternSyntaxException(msg, replaceText, i);

							}

							buf= appendToBuffer((char) parsedInt, buf, replaceText, i - 1);

							i+= 4;

						} else {

							String msg= TextMessages.getFormattedString(

									"FindReplaceDocumentAdapter.illegalUnicodeEscape", //$NON-NLS-1$

									replaceText.substring(i - 1, length));

							throw new PatternSyntaxException(msg, replaceText, i);

						}

						break;

					default:

						if (buf != null)

							buf.append('\\').append(ch);

						break;

				}

				inEscape= false;

			} else if (ch == '\\') {

				inEscape= true;

			} else if (ch == '$') {

				if (buf != null) {

					buf.append(ch);

				}

				// see explanation above in "Feature in java.util.regex.Matcher#replaceFirst(String)"

				if (i + 2 < length) {

					char ch1= replaceText.charAt(i + 1);

					char ch2= replaceText.charAt(i + 2);

					if (ch1 == '0' && '0' <= ch2 && ch2 <= '9') {

						i++; // consume the 0

						buf= appendToBuffer("0\\", buf, replaceText, i); //$NON-NLS-1$

					}

				} else

				break;

			} else if (buf != null) {

				buf.append(ch);

			}

		}

		if (buf != null) {

			if (inEscape) {

				// '\' as last character is invalid, but we still add it to get an error message

				buf.append('\\');

			}

			return buf.toString();

		}

		return replaceText;

	}

	/**

	 * Creates or reuses a string buffer and appends a string to the buffer.

	 * If <code>buf</code> is <code>null</code>, a new buffer is created

	 * from <code>completeText.substring(0, i)</code>.

	 * Callers should use the result as new buffer.

	 * 

	 * @param str string to append

	 * @param buf the existing buffer, or <code>null</code>

	 * @param completeText the complete text

	 * @param i the index into <code>completeText</code>

	 * 

	 * @return the buffer

	 */

	private StringBuffer appendToBuffer(String str, StringBuffer buf, String completeText, int i) {

		if (buf == null)

			buf= new StringBuffer(completeText.substring(0, i));

		buf.append(str);

		return buf;

	}

	/**

	 * Creates or reuses a string buffer and appends a character to the buffer.

	 * If <code>buf</code> is <code>null</code>, a new buffer is created

	 * from <code>completeText.substring(0, i)</code>.

	 * Callers should use the result as new buffer.

	 * 

	 * @param ch string to append

	 * @param buf the existing buffer, or <code>null</code>

	 * @param completeText the complete text

	 * @param i the index into <code>completeText</code>

	 * 

	 * @return the buffer

	 */

	private static StringBuffer appendToBuffer(char ch, StringBuffer buf, String completeText, int i) {

		if (buf == null)

			buf= new StringBuffer(completeText.substring(0, i));

		buf.append(ch);

		return buf;

	}

	/**

###############################################################################

# Copyright (c) 2007 IBM Corporation and others.

# All rights reserved. This program and the accompanying materials

# are made available under the terms of the Eclipse Public License v1.0

# which accompanies this distribution, and is available at

# http://www.eclipse.org/legal/epl-v10.html

#

# Contributors:

#     IBM Corporation - initial API and implementation

###############################################################################

FindReplaceDocumentAdapter.illegalControlEscape=Illegal control escape sequence {0}

FindReplaceDocumentAdapter.illegalHexEscape=Illegal hexadecimal escape sequence {0}

FindReplaceDocumentAdapter.illegalUnicodeEscape=Illegal Unicode escape sequence {0}

/*******************************************************************************

 * Copyright (c) 2007 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 * 

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.jface.text;

import java.util.MissingResourceException;

import java.util.ResourceBundle;

import com.ibm.icu.text.MessageFormat;

public class TextMessages {

	private static final String BUNDLE_NAME= "org.eclipse.jface.text.TextMessages"; //$NON-NLS-1$

	private static final ResourceBundle RESOURCE_BUNDLE= ResourceBundle.getBundle(BUNDLE_NAME);

	private TextMessages() {

	}

	public static String getString(String key) {

		try {

			return RESOURCE_BUNDLE.getString(key);

		} catch (MissingResourceException e) {

			return '!' + key + '!';

		}

	}

	public static String getFormattedString(String key, Object arg) {

		return getFormattedString(key, new Object[] { arg });

	}

	public static String getFormattedString(String key, Object[] args) {

		return MessageFormat.format(getString(key), args);

	}

}