| ############################################################################### |
| # Copyright (c) 2000, 2005 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 |
| ############################################################################### |
| |
| ## Content Assist for regular expressions ## |
| ## Copied from org.eclipse.ui.texteditor.RegExMessages.properties. |
| ## Needed by org.eclipse.mylyn.internal.team.ui.preferences.workaround.RegExMessages. |
| ## TODO Ask platform guys to open this API |
| # 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 and categories, e.g.:\n\ |
| \ BasicLatin\n\ |
| \ Latin-1Supplement\n\ |
| \ Greek\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 and categories, e.g.:\n\ |
| \ BasicLatin\n\ |
| \ Latin-1Supplement\n\ |
| \ Greek\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). |
| displayString_cr= CR - The carriage return character |
| additionalInfo_cr= The carriage return character (\\r or \\x0D in the find expression). |
| displayString_nl= Newline - The newline character |
| additionalInfo_nl= The newline character (\\n or \\x0A in the find expression). |