###############################################################################
# Copyright (c) 2000, 2008 IBM Corporation, Nokia 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
###############################################################################

## Content Assist for regular expressions ##
# use \\\u0075 for a backslash-u
displayString_bs_bs= \\\\ - Backslash
additionalInfo_bs_bs= Backslash
displayString_bs_0= \\0nnn - Octal character code
additionalInfo_bs_0= Octal character code\n\nExamples:\n\\011 (tabulator)\n\\0112 (character J)
displayString_bs_x= \\xhh - Hex character code
additionalInfo_bs_x= Hexadecimal character code\n\nExamples:\n\\x09 (tabulator)\n\\x4A or \\x4a (character J)
displayString_bs_u= \\\u0075hhhh - Hex code for Unicode character
additionalInfo_bs_u= Hexadecimal code for Unicode character\n\nExamples:\n\\\u0075004A (character J)\n\\\u007503B2 (lowercase Greek letter beta: \u03B2)
displayString_bs_t= \\t - Tab
additionalInfo_bs_t= Tabulator (\\x09, decimal: 9)
displayString_bs_n= \\n - Newline
additionalInfo_bs_n= Newline (\\x0A, decimal: 10)
displayString_bs_r= \\r - CR
additionalInfo_bs_r= Carriage Return (\\x0D, decimal: 13)
displayString_bs_f= \\f - FF
additionalInfo_bs_f= Form Feed (\\x0C, decimal: 12)
displayString_bs_a= \\a - Beep
additionalInfo_bs_a= Beep, Bell, Alert (\\x07, decimal: 7)
displayString_bs_e= \\e - Esc
additionalInfo_bs_e= Escape (\\x1B, decimal: 27)
displayString_bs_c= \\c - Control character
additionalInfo_bs_c= Control character\n\nExample:\n\\cC (Ctrl+C)

displayString_dot= . - Any character
additionalInfo_dot= The dot matches any character except line terminators.\n\n\
To make the dot match line terminators as well, \n\
start the expression with the embedded flag expression \n\
"(?s)" (without quotes).
displayString_bs_d= \\d - A digit
additionalInfo_bs_d= A digit: [0-9]
displayString_bs_D= \\D - Not a digit
additionalInfo_bs_D= Not a digit: [^0-9]
displayString_bs_s= \\s - A whitespace
additionalInfo_bs_s= A whitespace: [ \\t\\n\\x0B\\f\\r]
displayString_bs_S= \\S - Not a whitespace
additionalInfo_bs_S= Not a whitespace: [^\\s]
displayString_bs_w= \\w - An alphanumeric (word character)
additionalInfo_bs_w= An alphanumeric (a word character): [a-zA-Z_0-9]
displayString_bs_W= \\W - Not an alphanumeric
additionalInfo_bs_W= Not an alphanumeric (not a word character): [^\\w]

displayString_start= ^ - Line start
additionalInfo_start= Line start (positional match)\n\nExample:\n\
The expression "^Eclipse" matches the term "Eclipse"\n\
only on the second line of text\n\
"The Eclipse Project\n\
Eclipse Platform".
displayString_end= $ - Line end
additionalInfo_end= Line end (positional match)\n\nExample:\n\
The expression "Eclipse$" matches the term "Eclipse"\n\
only on the second line of text\n\
"- Install the Eclipse Platform\n\
- Run Eclipse".
displayString_bs_b= \\b- Word beginning or end
additionalInfo_bs_b= Word beginning or end (positional match)\n\nExample:\n\
The expression "s\\b" matches only the last "s" of "glasses" in text\n\
"I lost my glasses."
displayString_bs_B= \\B - Not a word beginning or end
additionalInfo_bs_B= Not a word beginning or end (positional match)\n\nExample:\n\
The expression "\\BS" matches only "S" of "printString" in text\n\
"void print(String printString)".
displayString_bs_A= \\A - Start of input
additionalInfo_bs_A= Start of input (positional match)\n\nExample:\n\
The expression "\\ABC" matches only "BC" of "BCD" in text\n\
"BCD ABC\n\
BCDEF".
displayString_bs_G= \\G - Previous match's end
additionalInfo_bs_G= Previous match's end (positional match)\n\nExample:\n\
The expression "\\Ga" matches the first and then the second "a" in text\n\
"aardvark" (when starting from the beginning).
displayString_bs_Z= \\Z - End of input, does not consider last line terminator
additionalInfo_bs_Z= End of input, does not consider last line terminator (positional match)\n\n\
The expression matches at the end of the file, except for when the\n\
file ends in a line terminator, in which case it matches before that\n\
line terminator.\n\nExample:\n\
The expression "ing\\Z" matches "ing" in text\n\
"testing", as well as in text\n\
"testing\n\
", but doesn't match in text\n\
"testing\n\
\n\
"
displayString_bs_z= \\z - End of input
additionalInfo_bs_z= End of input (positional match)\n\nExample:\n\
The expression "ing\\z" matches "ing" in text\n\
"testing", but doesn't match in text\n\
"testing\n\
"

### repetition quantifiers ###
displayString_quest= ? - Greedy match 0 or 1 times
additionalInfo_quest= Greedy match 0 or 1 times.\n\n\
First tries to match the preceding token.\n\
Falls back to not matching if this choice made a full match impossible.\n\nExample:\n\
The expression "fo?" matches "f", "fo", and "fo" in text\n\
"f fo foo".
displayString_star= * - Greedy match 0 or more times
additionalInfo_star= Greedy match 0 or more times.\n\n\
First tries to match the preceding token as many times as possible.\n\
Falls back to matching it less often if this choice made a full match impossible.\n\nExamples:\n\
- The expression "fo*" matches "f", "fo", and "foo" in text\n\
"f fo foo".\n\
- The expression "fo*o\\d" matches all three words in text\n\
"fo1 foo2 fooo3".\n\
- The expression "<.*>" matches the whole text\n\
"<p><b>bold</b>".
displayString_plus= + - Greedy match 1 or more times
additionalInfo_plus= Greedy match 1 or more times\n\n\
First tries to match the preceding token as many times as possible.\n\
Falls back to matching it less often if this choice made a full match impossible.\n\nExamples:\n\
- The expression "fo+" matches "fo" and "foo" in text\n\
"f fo foo".\n\
- The expression "fo+o\\d" matches "foo2" and "fooo3" in text\n\
"fo1 foo2 fooo3".\n\
- The expression "<.+>" matches the whole text\n\
"<p><b>bold</b>", but does not match anywhere in "<>".
displayString_exact= {n} - Greedy match exactly n times
additionalInfo_exact= Greedy match exactly n times.\n\nExamples:\n\
- The expression "\\\\0[0-3][0-7]{2}" matches all three-digit octal character tokens.\n\
- The expression "\\b\\w{4}\\b" matches all four-letter-words\n\
such as "Java", "cool", or "food" (but not "dog").
displayString_least= {n,} - Greedy match >= n times
additionalInfo_least= Greedy match >= n times.\n\n\
First tries to match the preceding token as many times as possible.\n\
Falls back to matching it less often (but at least n times),\n\
if this choice made a full match impossible.\n\nExamples:\n\
- The expression "fo{2,}" matches "foo" and "fooo" in text\n\
"f fo foo fooo".\n\
- The expression "fo{2,}o\\d" matches "fooo3" and "foooo4" in text\n\
"fo1 foo2 fooo3 foooo4".\n\
- The expression "10{3,}[^0]" matches all powers of ten that are larger than one thousand.\n\n\
Note: The expressions "{0,}" and "*" are equivalent;\n\
likewise, "{1,}" is equivalent to "+".
displayString_count= {n,m} - Greedy match >= n times but <= m times
additionalInfo_count= Greedy match >= n times but <= m times.\n\n\
First tries to match the preceding token m times.\n\
Falls back to matching it less often (but at least n times),\n\
if this choice made a full match impossible.\n\nExamples:\n\
- The expression "fo{1,2}" matches "fo", "foo", and "foo" in text\n\
"f fo foo fooo".\n\
- The expression "fo{1,2}o\\d" matches "foo2" and "fooo3" in text\n\
"fo1 foo2 fooo3 foooo4".\n\
- The expression "^.{70,80}$" matches all the lines that contain\n\
between 70 and 80 characters (inclusive).

displayString_questLazy= ?? - Lazy match 0 or 1 times
additionalInfo_questLazy= Lazy match 0 or 1 times.\n\n\
First tries to not match the preceding token.\n\
Falls back to matching it if this choice made a full match impossible.\n\nExample:\n\
The expression "fo??" matches "f", "f", and "f" in text\n\
"f fo foo".
displayString_starLazy= *? - Lazy match 0 or more times
additionalInfo_starLazy= Lazy match 0 or more times.\n\n\
First tries to not match the preceding token.\n\
Falls back to matching it more often if this choice made a full match impossible.\n\nExamples:\n\
- The expression "fo*?" matches "f", "f", and "f" in text\n\
"f fo foo".\n\
- The expression "fo*?o\\d" matches all three words in text\n\
"fo1 foo2 fooo3".\n\
- The expression "<.*?>" matches "<p>", "<b>", and "</b>" in text\n\
"<p><b>bold</b>". Note: a more performant expression for finding\n\
xml tags is "<[^>]*>", which avoids backtracking.
displayString_plusLazy= +? - Lazy match 1 or more times
additionalInfo_plusLazy= Lazy match 1 or more times\n\n\
First tries to match the preceding token once.\n\
Falls back to matching it more often if this choice made a full match impossible.\n\nExamples:\n\
- The expression "fo+?" matches "fo" and "fo" in text\n\
"f fo foo".\n\
- The expression "fo+?o\\d" matches "foo2" and "fooo3" in text\n\
"fo1 foo2 fooo3".\n\
- The expression "<.+?>" matches "<p>", "<b>", and "</b>" in text\n\
"<p><b>bold</b>". Note: a more performant expression for finding\n\
xml tags is "<[^>]*>", which avoids backtracking.
displayString_exactLazy= {n}? - Lazy match exactly n times
additionalInfo_exactLazy= Lazy match exactly n times.\n\n\
This expression is equivalent to the expression\n\
{n} - Greedy match exactly n times.
displayString_leastLazy= {n,}? - Lazy match >= n times
additionalInfo_leastLazy= Lazy match >= n times.\n\n\
First tries to match the preceding token n times. Falls back to\n\
matching it more often, if this choice made a full match impossible.\n\nExamples:\n\
- The expression "fo{2,}?" matches "foo" and "foo" in text\n\
"f fo foo fooo".\n\
- The expression "fo{2,}?o\\d" matches "fooo3" and "foooo4" in text\n\
"fo1 foo2 fooo3 foooo4".\n\
- The expression "10{3,}?[^0]" matches all powers of ten that are larger than one thousand.\n\n\
Note: The expressions "{0,}?" and "*?" are equivalent;\n\
likewise, "{1,}?" is equivalent to "+?".
displayString_countLazy= {n,m}? - Lazy match >= n times but <= m times
additionalInfo_countLazy= Lazy match >= n times but <= m times.\n\n\
First tries to match the preceding token n times.\n\
Falls back to matching it more often (but at most m times),\n\
if this choice made a full match impossible.\n\nExamples:\n\
- The expression "fo{1,2}?" matches "fo", "fo", and "fo" in text\n\
"f fo foo fooo".\n\
- The expression "fo{1,2}?o\\d" matches "foo2" and "fooo3" in text\n\
"fo1 foo2 fooo3 foooo4".\n\

displayString_questPoss= ?+ - Possessive match 0 or 1 times (no backtracking)
additionalInfo_questPoss= Possessive match 0 or 1 times.\n\n\
Matches the preceding token if possible. Never backtracks,\n\
even if this choice renders a full match impossible.\n\nExample:\n\
The expression "fo?+o\\d" matches the first, but not the second line in text\n\
"fo1\n\
foo1".
displayString_starPoss= *+ Possessive match 0 or more times (no backtracking)
additionalInfo_starPoss= Possessive match 0 or more times.\n\n\
Tries to match the preceding token as many times as possible. Never backtracks,\n\
even if this choice renders a full match impossible.\n\nExamples:\n\
- The expression "fo*+" matches "f", "fo" and "foo" in text\n\
"f fo foo".\n\
- The expression "fo*+o\\d" matches nowhere in text\n\
"fo1 foo2 fooo3".\n\
- The expression "<.*+>" matches nowhere in text\n\
"<p><b>bold</b>".
displayString_plusPoss= ++ - Possessive match 1 or more times (no backtracking)
additionalInfo_plusPoss= Possessive match 1 or more times.\n\n\
Tries to match the preceding token as many times as possible. Never backtracks,\n\
even if this choice renders a full match impossible.\n\nExamples:\n\
- The expression "fo++" matches "fo" and "foo" in text\n\
"f fo foo".\n\
- The expression "fo++o\\d" matches nowhere in text\n\
"fo1 foo2 fooo3".\n\
- The expression "<.++>" matches nowhere in text\n\
"<p><b>bold</b>".

displayString_exactPoss= {n}+ - Possessive match exactly n times (no backtracking)
additionalInfo_exactPoss= Possessive match exactly n times.\n\n\
This expression is equivalent to the expression\n\
{n} - Greedy match exactly n times.
displayString_leastPoss= {n,}+ - Possessive match >= n times (no backtracking)
additionalInfo_leastPoss= Possessive match >= n times.\n\n\
Tries to match the preceding token as many times as possible, but at least n times.\n\
Never backtracks, even if this choice renders a full match impossible.\n\nExamples:\n\
- The expression "fo{2,}+" matches "foo" and "fooo" in text\n\
"f fo foo fooo".\n\
- The expression "fo{2,}?o\\d" matches nowhere in text\n\
"fo1 foo2 fooo3 foooo4".\n\
Note: The expressions "{0,}?" and "*?" are equivalent;\n\
likewise, "{1,}?" is equivalent to "+?".

displayString_countPoss= {n,m}+ - Possessive match >= n times but <= m times (no backtracking)
additionalInfo_countPoss= Possessive match >= n times but <= m times.\n\n\
Tries to match the preceding token as many times as possible, \n\
at least n times and at most m times.\n\
Never backtracks, even if this choice renders a full match impossible.\n\nExamples:\n\
- The expression "fo{1,2}+" matches "fo", "foo", and "foo" in text\n\
"f fo foo fooo".\n\
- The expression "fo{1,2}+o\\d" matches only "fooo3" in text\n\
"fo1 foo2 fooo3 foooo4".\n\
- The expression "^.{70,80}+$" matches all the lines that contain\n\
between 70 and 80 characters (inclusive).

displayString_alt= U|V - Alternation: U or V
additionalInfo_alt= Alternation.\n\n\
First tries to match subexpression U. Falls back and tries to match V if U didn't match.\n\nExamples:\n\
- The expression "A|B" applied to text "BA" first matches "B", then "A".\n\
- The expression "AB|BC|CD" applied to text "ABC BC DAB" matches, in sequence:\n\
"AB" in the first word, the second word "BC", "AB" at the very end.
displayString_group= (Expr) - Mark Expr as capturing group
additionalInfo_group= Mark Expr as capturing group.\n\n\
Capturing groups are numbered by counting their opening parentheses from left to right.\n\
In the expression "((A)(B(C)))", for example, there are four such groups:\n\
1   ((A)(B(C)))\n\
2   (A)\n\
3   (B(C))\n\
4   (C)\n\
\n\
Group zero always stands for the entire expression. During a match,\n\
each subsequence of the input sequence that matches such a group is saved.\n\
The captured subsequence i may be used later in the expression, via a back reference "\\i",\n\
and may also be used in the replace string via "$i".\n\
\n\
Note: Groups beginning with (? are pure, non-capturing groups that\n\
do not capture text and do not count towards the group total.

displayString_bs_i= \\i - Match of the capturing group i
additionalInfo_bs_i= Match of the capturing group i.\n\n\
\\i matches the subsequence that has already been saved as capturing group i.\n\
\\0 is not a valid group number in the regular expression.\n\nExample:\n\
The expression "(\\d+)\\+\\1" matches "10+10" in text "9+10+10+11".\n\
\n\
Note: in the replace string, $i stands for the capturing group i. 

displayString_bs= \\ - Quote next character
additionalInfo_bs= Quote next character\n\nExample:\n\
The expression "\\{\\n\\}" matches the text "{n}".

displayString_bs_Q= \\Q - Start quoting
additionalInfo_bs_Q= Start quoting\n\n\
All characters between \\Q and the next \\E are taken literally and are not interpreted.\n\nExample:\n\
The expression "\\Qnew int[] {42}\\E;" matches text "new int[] {42}".
displayString_bs_E= \\E - End quoting
additionalInfo_bs_E= End quoting\n\n\
All characters between \\Q and the next \\E are taken literally and are not interpreted.\n\nExample:\n\
The expression "\\Qnew int[] {42}\\E;" matches text "new int[] {42}".

displayString_set= [ecl] - Character set
additionalInfo_set= Character set\n\n\
Matches a single character out of the set.\n\nExample:\n\
The expression "[ecl]" matches "c" and "l" in text "cold".
displayString_setExcl= [^ecl] - Excluded character set
additionalInfo_setExcl= Excluded character set\n\n\
Matches a single character that is not one of the excluded characters.\n\nExamples:\n\
The expression "[^ecl]" matches "o" and "d" in text "cold".\n\
The expression "[a-z&&[^ecl]]" matches any character from a to z, excluding e, c, and l.
displayString_setRange= [c-l] - Character range
additionalInfo_setRange= Character range\n\n\
Matches a single character out of the range from 'c' to 'l'.\n\nExamples:\n\
The expression "[c-l]" matches "c", "l", and "d" in text "cold".\n\
The expression "[a-z&&[^ecl]]" matches any character from a to z, excluding e, c, and l.
displayString_setInter= && - Intersection of character sets
additionalInfo_setInter= Intersection of character sets\n\n\
Matches a character that is in both of the given sets.\n\nExample:\n\
The expression "[a-z&&[^ecl]]" matches any character from a to z, excluding e, c, and l.

displayString_posix= \\p{Class} - POSIX or Unicode character class
additionalInfo_posix= POSIX or Unicode character class\n\n\
Matches a character from the given character class 'Class'.\n\
Valid classes are:\n\
\n\
- POSIX character classes (US-ASCII only):\n\
\    Lower, Upper, ASCII, Alpha, Digit, Alnum, Punct,\n\
\    Graph, Print, Blank, Cntrl, XDigit, and Space.\n\
\n\
- Unicode blocks (with the prefix 'In'), e.g.:\n\
\    InBasicLatin\n\
\    InLatin-1Supplement\n\
\    InGreek\n\
\n\
- Unicode categories, e.g.:\n\
\    Lu: Uppercase Letter\n\
\    Ll: Lowercase Letter\n\
\    L:  Letter\n\
\    N:  Number\n\
\    Z:  Separator\n\
\    LD: Letter or Digit\n\
\    L1: Latin-1

displayString_posixNot= \\P{Class} - Excluded POSIX or Unicode character class
additionalInfo_posixNot= Excluded POSIX or Unicode character class\n\n\
Negation of character set \\p{Class}. Example:\n\
\\P{ASCII} is equivalent to [^\\p{ASCII}] and matches all non-ASCII characters.\n\n\
Valid classes are:\n\
\n\
- POSIX character classes (US-ASCII only):\n\
\    Lower, Upper, ASCII, Alpha, Digit, Alnum, Punct,\n\
\    Graph, Print, Blank, Cntrl, XDigit, and Space.\n\
\n\
- Unicode blocks (with the prefix 'In'), e.g.:\n\
\    InBasicLatin\n\
\    InLatin-1Supplement\n\
\    InGreek\n\
\n\
- Unicode categories, e.g.:\n\
\    Lu: Uppercase Letter\n\
\    Ll: Lowercase Letter\n\
\    L:  Letter\n\
\    N:  Number\n\
\    Z:  Separator\n\
\    LD: Letter or Digit\n\
\    L1: Latin-1


#Flags:
displayString_flag= (?ismd-ismd) - Turn flags on or off
additionalInfo_flag= Turn flags on and off for the rest of the matching process.\n\n\
Flags before the dash are turned on; those after the dash are turned off.\n\
The following flags are supported:\n\
- i: case-insensitive matching\n\
\n\
- s: single-line, or dotall matching mode:\n\
\        The expression . matches any character, including a line terminator.\n\
\n\
- m: multiline matching mode:\n\
\        The expressions ^ and $ match just after or just before,\n\
\        respectively, a line terminator or the end of the input sequence.\n\
\        By default these expressions only match at the beginning and the\n\
\        end of the entire input sequence.\n\
\n\
- d: Unix lines matching mode:\n\
\        Only the '\\n' line terminator\n\
\        is recognized in the behavior of ., ^, and $
# - u: unicode-aware case folding:\n\
#        Case-insensitive matching, when enabled, is done in a manner consistent\n\
#        with the Unicode Standard. By default, case-insensitive matching\n\
#        assumes that only characters in the US-ASCII charset are being matched.
# - c: canonical equivalence\n\
#        Two characters will be considered to match if, and only if, their full\n\
#        canonical decompositions match. The expression "a\\\u0075030A", for example,\n\
#        will match the string "a\u030A" when this flag is specified.\n\
#        By default, matching does not take canonical equivalence into account.
# - x: comments mode\n\
#        Whitespace is ignored, and embedded comments starting with\n\
#        # are ignored until the end of a line.\n\

displayString_flagExpr= (?ismd-ismd:Expr) - Turn flags on or off in Expr
additionalInfo_flagExpr= Turn flags on and off in Expr.\n\n\
Flags before the dash are turned on; those after the dash are turned off.\n\
The following flags are supported:\n\
- i: case-insensitive matching\n\
\n\
- s: single-line, or dotall matching mode:\n\
\        The expression . matches any character, including a line terminator.\n\
\n\
- m: multiline matching mode:\n\
\        The expressions ^ and $ match just after or just before,\n\
\        respectively, a line terminator or the end of the input sequence.\n\
\        By default these expressions only match at the beginning and the\n\
\        end of the entire input sequence.\n\
\n\
- d: Unix lines matching mode:\n\
\        Only the '\\n' line terminator\n\
\        is recognized in the behavior of ., ^, and $


#Noncapturing groups:
displayString_nonCap= (?:Expr) - Non-capturing group
additionalInfo_nonCap= Non-capturing group of regular expression Expr.\n\n\
The group is not saved in a back reference.\n\nExample:\n\
The expression "(?:\\w+) (\\d+)" matches "bug 42" in text "It's bug 42.".\n\
A back reference "$1" in the replace string will be replaced by "42".

displayString_atomicCap= (?>Expr) - Non-capturing atomic group
additionalInfo_atomicCap= Non-capturing atomic group of regular expression Expr.\n\n\
Matches the regular expression Expr once, but does not backtrack into the expression\n\
again if the first match did not prove to be successful later on.\n\
The group is not saved in a back reference.

#Lookaround:
displayString_posLookahead= (?=Expr) - Zero-width positive lookahead
additionalInfo_posLookahead= Expr, via zero-width positive lookahead.\n\n\
Matches a position (zero-width: does not consume the matched characters),\n\
where the next characters (-> lookahead)\n\
do match (-> positive) the embedded expression Expr.\n\nExamples:\n\
- The expression "var(?==)" matches only the first "var" in text "var=17; other=var;".\n\
- The expression "\\b(?=\\w{7}\\b)\\w*clip\\w*\\b" matches any\n\
seven-letter-word that contains "clip". It matches "Eclipse", but not "paperclip".

displayString_negLookahead= (?!Expr) - Zero-width negative lookahead
additionalInfo_negLookahead= Expr, via zero-width negative lookahead.\n\n\
Matches a position (zero-width: does not consume the matched characters),\n\
where the next characters (-> lookahead)\n\
do not match (-> negative) the embedded expression Expr.\n\nExamples:\n\
- The expression "var(?!=)" matches only the second "var" in text "var=17; other=var;".\n\
- The expression "\\b(?!\\w{5,7}\\b)\\w*clip\\w*\\b" matches any\n\
word that contains "clip" and consists of less than 5 or more than 7 characters.\n\
It matches "clip" and "paperclip", but not "Eclipse".

displayString_posLookbehind= (?<=Expr) - Zero-width positive lookbehind
additionalInfo_posLookbehind= Expr, via zero-width positive lookbehind.\n\n\
Matches a position (zero-width: does not consume the matched characters),\n\
where the previous characters (-> lookbehind)\n\
do match (-> positive) the embedded expression Expr.\n\nExample:\n\
- The expression "\\w{5,}+(?<=as)\\b" matches "alias" and "bananas",\n\
but does not match "peas", "apples", or "Alaska".

displayString_negLookbehind= (?<!Expr) - Zero-width negative lookbehind
additionalInfo_negLookbehind= Expr, via zero-width negative lookbehind.\n\n\
Matches a position (zero-width: does not consume the matched characters),\n\
where the previous characters (-> lookbehind)\n\
do not match (-> negative) the embedded expression Expr.\n\nExample:\n\
- The expression "\\w{5,}+(?<!as)\\b" matches "Eclipse" and "apples",\n\
but does not match "peas" or "bananas".

#Replace string:
displayString_dollar= $i - Match of the capturing group i
additionalInfo_dollar= 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: in the find expression, \\i stands for the capturing group i. 
displayString_replace_bs= \\ - Quote next character
additionalInfo_replace_bs= Quote next character\n\nExamples:\n\
"\\$" will be replaced by "$".\n\
"\\a" will be replaced by "a".\n\
"\\\\" will be replaced by "\\".
displayString_tab= Tab - The tabulator character
additionalInfo_tab= The tabulator character (\\t in the find expression).
