|
129
|
1 ###############################################################################
|
|
|
2 # Copyright (c) 2008 IBM Corporation and others.
|
|
|
3 # All rights reserved. This program and the accompanying materials
|
|
|
4 # are made available under the terms of the Eclipse Public License v1.0
|
|
|
5 # which accompanies this distribution, and is available at
|
|
|
6 # http://www.eclipse.org/legal/epl-v10.html
|
|
|
7 #
|
|
|
8 # Contributors:
|
|
|
9 # IBM Corporation - initial API and implementation
|
|
|
10 # Cagatay Calli <ccalli@gmail.com> - [find/replace] retain caps when replacing - https://bugs.eclipse.org/bugs/show_bug.cgi?id=28949
|
|
|
11 # Cagatay Calli <ccalli@gmail.com> - [find/replace] define & fix behavior of retain caps with other escapes and text before \C - https://bugs.eclipse.org/bugs/show_bug.cgi?id=217061
|
|
|
12 ###############################################################################
|
|
|
13
|
|
|
14 ## Content Assist for regular expressions ##
|
|
|
15 # use \\\u0075 for a backslash-u
|
|
|
16 displayString_bs_bs= \\\\ - Backslash
|
|
|
17 additionalInfo_bs_bs= Backslash
|
|
|
18 displayString_bs_0= \\0nnn - Octal character code
|
|
|
19 additionalInfo_bs_0= Octal character code\n\nExamples:\n\\011 (tabulator)\n\\0112 (character J)
|
|
|
20 displayString_bs_x= \\xhh - Hex character code
|
|
|
21 additionalInfo_bs_x= Hexadecimal character code\n\nExamples:\n\\x09 (tabulator)\n\\x4A or \\x4a (character J)
|
|
|
22 displayString_bs_u= \\\u0075hhhh - Hex code for Unicode character
|
|
|
23 additionalInfo_bs_u= Hexadecimal code for Unicode character\n\nExamples:\n\\\u0075004A (character J)\n\\\u007503B2 (lowercase Greek letter beta: \u03B2)
|
|
|
24 displayString_bs_t= \\t - Tab
|
|
|
25 additionalInfo_bs_t= Tabulator (\\x09, decimal: 9)
|
|
|
26 displayString_bs_R= \\R - Line delimiter (platform independent)
|
|
|
27 additionalInfo_bs_R= Line delimiter (platform independent)\n\n\
|
|
|
28 This pattern matches any form of line delimiter, i.e.\n\
|
|
|
29 - Windows (\\r\\n)\n\
|
|
|
30 - Unix (\\n)\n\
|
|
|
31 - Mac OS 9 (\\r)\n\n\
|
|
|
32 Note that this pattern does not work inside [].
|
|
|
33 displayString_bs_n= \\n - Newline
|
|
|
34 additionalInfo_bs_n= Newline (\\x0A, decimal: 10)\n\n\
|
|
|
35 WARNING: \\n only finds newline characters. \
|
|
|
36 This can lead to unexpected results when the actual document uses different line delimiters.\n\n\
|
|
|
37 RECOMMENDATION: use \\R to find a line delimiter.
|
|
|
38 displayString_bs_r= \\r - CR
|
|
|
39 additionalInfo_bs_r= Carriage Return (\\x0D, decimal: 13)\n\n\
|
|
|
40 WARNING: \\r only finds carriage return characters. \
|
|
|
41 This can lead to unexpected results when the actual document uses different line delimiters.\n\n\
|
|
|
42 RECOMMENDATION: use \\R to find a line delimiter.
|
|
|
43 displayString_bs_f= \\f - FF
|
|
|
44 additionalInfo_bs_f= Form Feed (\\x0C, decimal: 12)
|
|
|
45 displayString_bs_a= \\a - Beep
|
|
|
46 additionalInfo_bs_a= Beep, Bell, Alert (\\x07, decimal: 7)
|
|
|
47 displayString_bs_e= \\e - Esc
|
|
|
48 additionalInfo_bs_e= Escape (\\x1B, decimal: 27)
|
|
|
49 displayString_bs_c= \\cC - Control character
|
|
|
50 additionalInfo_bs_c= Control character for C\n\nExample:\n\\cC (Ctrl+C, \\x03, decimal: 3)
|
|
|
51
|
|
|
52 displayString_dot= . - Any character
|
|
|
53 additionalInfo_dot= The dot matches any character except line terminators.\n\n\
|
|
|
54 To make the dot match line terminators as well, \n\
|
|
|
55 start the expression with the embedded flag expression \n\
|
|
|
56 "(?s)" (without quotes).
|
|
|
57 displayString_bs_d= \\d - A digit
|
|
|
58 additionalInfo_bs_d= A digit: [0-9]
|
|
|
59 displayString_bs_D= \\D - Not a digit
|
|
|
60 additionalInfo_bs_D= Not a digit: [^0-9]
|
|
|
61 displayString_bs_s= \\s - A whitespace
|
|
|
62 additionalInfo_bs_s= A whitespace: [ \\t\\n\\x0B\\f\\r]
|
|
|
63 displayString_bs_S= \\S - Not a whitespace
|
|
|
64 additionalInfo_bs_S= Not a whitespace: [^\\s]
|
|
|
65 displayString_bs_w= \\w - An alphanumeric (word character)
|
|
|
66 additionalInfo_bs_w= An alphanumeric (a word character): [a-zA-Z_0-9]
|
|
|
67 displayString_bs_W= \\W - Not an alphanumeric
|
|
|
68 additionalInfo_bs_W= Not an alphanumeric (not a word character): [^\\w]
|
|
|
69
|
|
|
70 displayString_start= ^ - Line start
|
|
|
71 additionalInfo_start= Line start (positional match)\n\nExample:\n\
|
|
|
72 The expression "^Eclipse" matches the term "Eclipse"\n\
|
|
|
73 only on the second line of text\n\
|
|
|
74 "The Eclipse Project\n\
|
|
|
75 Eclipse Platform".
|
|
|
76 displayString_end= $ - Line end
|
|
|
77 additionalInfo_end= Line end (positional match)\n\nExample:\n\
|
|
|
78 The expression "Eclipse$" matches the term "Eclipse"\n\
|
|
|
79 only on the second line of text\n\
|
|
|
80 "- Install the Eclipse Platform\n\
|
|
|
81 - Run Eclipse".
|
|
|
82 displayString_bs_b= \\b- Word beginning or end
|
|
|
83 additionalInfo_bs_b= Word beginning or end (positional match)\n\nExample:\n\
|
|
|
84 The expression "s\\b" matches only the last "s" of "glasses" in text\n\
|
|
|
85 "I lost my glasses."
|
|
|
86 displayString_bs_B= \\B - Not a word beginning or end
|
|
|
87 additionalInfo_bs_B= Not a word beginning or end (positional match)\n\nExample:\n\
|
|
|
88 The expression "\\BS" matches only "S" of "printString" in text\n\
|
|
|
89 "void print(String printString)".
|
|
|
90 displayString_bs_A= \\A - Start of input
|
|
|
91 additionalInfo_bs_A= Start of input (positional match)\n\nExample:\n\
|
|
|
92 The expression "\\ABC" matches only "BC" of "BCD" in text\n\
|
|
|
93 "BCD ABC\n\
|
|
|
94 BCDEF".
|
|
|
95 displayString_bs_G= \\G - Previous match's end
|
|
|
96 additionalInfo_bs_G= Previous match's end (positional match)\n\nExample:\n\
|
|
|
97 The expression "\\Ga" matches the first and then the second "a" in text\n\
|
|
|
98 "aardvark" (when starting from the beginning).
|
|
|
99 displayString_bs_Z= \\Z - End of input, does not consider last line terminator
|
|
|
100 additionalInfo_bs_Z= End of input, does not consider last line terminator (positional match)\n\n\
|
|
|
101 The expression matches at the end of the file, except for when the\n\
|
|
|
102 file ends in a line terminator, in which case it matches before that\n\
|
|
|
103 line terminator.\n\nExample:\n\
|
|
|
104 The expression "ing\\Z" matches "ing" in text\n\
|
|
|
105 "testing", as well as in text\n\
|
|
|
106 "testing\n\
|
|
|
107 ", but doesn't match in text\n\
|
|
|
108 "testing\n\
|
|
|
109 \n\
|
|
|
110 "
|
|
|
111 displayString_bs_z= \\z - End of input
|
|
|
112 additionalInfo_bs_z= End of input (positional match)\n\nExample:\n\
|
|
|
113 The expression "ing\\z" matches "ing" in text\n\
|
|
|
114 "testing", but doesn't match in text\n\
|
|
|
115 "testing\n\
|
|
|
116 "
|
|
|
117
|
|
|
118 ### repetition quantifiers ###
|
|
|
119 displayString_quest= ? - Greedy match 0 or 1 times
|
|
|
120 additionalInfo_quest= Greedy match 0 or 1 times.\n\n\
|
|
|
121 First tries to match the preceding token.\n\
|
|
|
122 Falls back to not matching if this choice made a full match impossible.\n\nExample:\n\
|
|
|
123 The expression "fo?" matches "f", "fo", and "fo" in text\n\
|
|
|
124 "f fo foo".
|
|
|
125 displayString_star= * - Greedy match 0 or more times
|
|
|
126 additionalInfo_star= Greedy match 0 or more times.\n\n\
|
|
|
127 First tries to match the preceding token as many times as possible.\n\
|
|
|
128 Falls back to matching it less often if this choice made a full match impossible.\n\nExamples:\n\
|
|
|
129 - The expression "fo*" matches "f", "fo", and "foo" in text\n\
|
|
|
130 "f fo foo".\n\
|
|
|
131 - The expression "fo*o\\d" matches all three words in text\n\
|
|
|
132 "fo1 foo2 fooo3".\n\
|
|
|
133 - The expression "<.*>" matches the whole text\n\
|
|
|
134 "<p><b>bold</b>".
|
|
|
135 displayString_plus= + - Greedy match 1 or more times
|
|
|
136 additionalInfo_plus= Greedy match 1 or more times\n\n\
|
|
|
137 First tries to match the preceding token as many times as possible.\n\
|
|
|
138 Falls back to matching it less often if this choice made a full match impossible.\n\nExamples:\n\
|
|
|
139 - The expression "fo+" matches "fo" and "foo" in text\n\
|
|
|
140 "f fo foo".\n\
|
|
|
141 - The expression "fo+o\\d" matches "foo2" and "fooo3" in text\n\
|
|
|
142 "fo1 foo2 fooo3".\n\
|
|
|
143 - The expression "<.+>" matches the whole text\n\
|
|
|
144 "<p><b>bold</b>", but does not match anywhere in "<>".
|
|
|
145 displayString_exact= {n} - Greedy match exactly n times
|
|
|
146 additionalInfo_exact= Greedy match exactly n times.\n\nExamples:\n\
|
|
|
147 - The expression "\\\\0[0-3][0-7]{2}" matches all three-digit octal character tokens.\n\
|
|
|
148 - The expression "\\b\\w{4}\\b" matches all four-letter-words\n\
|
|
|
149 such as "Java", "cool", or "food" (but not "dog").
|
|
|
150 displayString_least= {n,} - Greedy match >= n times
|
|
|
151 additionalInfo_least= Greedy match >= n times.\n\n\
|
|
|
152 First tries to match the preceding token as many times as possible.\n\
|
|
|
153 Falls back to matching it less often (but at least n times),\n\
|
|
|
154 if this choice made a full match impossible.\n\nExamples:\n\
|
|
|
155 - The expression "fo{2,}" matches "foo" and "fooo" in text\n\
|
|
|
156 "f fo foo fooo".\n\
|
|
|
157 - The expression "fo{2,}o\\d" matches "fooo3" and "foooo4" in text\n\
|
|
|
158 "fo1 foo2 fooo3 foooo4".\n\
|
|
|
159 - The expression "10{3,}[^0]" matches all powers of ten that are larger than one thousand.\n\n\
|
|
|
160 Note: The expressions "{0,}" and "*" are equivalent;\n\
|
|
|
161 likewise, "{1,}" is equivalent to "+".
|
|
|
162 displayString_count= {n,m} - Greedy match >= n times but <= m times
|
|
|
163 additionalInfo_count= Greedy match >= n times but <= m times.\n\n\
|
|
|
164 First tries to match the preceding token m times.\n\
|
|
|
165 Falls back to matching it less often (but at least n times),\n\
|
|
|
166 if this choice made a full match impossible.\n\nExamples:\n\
|
|
|
167 - The expression "fo{1,2}" matches "fo", "foo", and "foo" in text\n\
|
|
|
168 "f fo foo fooo".\n\
|
|
|
169 - The expression "fo{1,2}o\\d" matches "foo2" and "fooo3" in text\n\
|
|
|
170 "fo1 foo2 fooo3 foooo4".\n\
|
|
|
171 - The expression "^.{70,80}$" matches all the lines that contain\n\
|
|
|
172 between 70 and 80 characters (inclusive).
|
|
|
173
|
|
|
174 displayString_questLazy= ?? - Lazy match 0 or 1 times
|
|
|
175 additionalInfo_questLazy= Lazy match 0 or 1 times.\n\n\
|
|
|
176 First tries to not match the preceding token.\n\
|
|
|
177 Falls back to matching it if this choice made a full match impossible.\n\nExample:\n\
|
|
|
178 The expression "fo??" matches "f", "f", and "f" in text\n\
|
|
|
179 "f fo foo".
|
|
|
180 displayString_starLazy= *? - Lazy match 0 or more times
|
|
|
181 additionalInfo_starLazy= Lazy match 0 or more times.\n\n\
|
|
|
182 First tries to not match the preceding token.\n\
|
|
|
183 Falls back to matching it more often if this choice made a full match impossible.\n\nExamples:\n\
|
|
|
184 - The expression "fo*?" matches "f", "f", and "f" in text\n\
|
|
|
185 "f fo foo".\n\
|
|
|
186 - The expression "fo*?o\\d" matches all three words in text\n\
|
|
|
187 "fo1 foo2 fooo3".\n\
|
|
|
188 - The expression "<.*?>" matches "<p>", "<b>", and "</b>" in text\n\
|
|
|
189 "<p><b>bold</b>". Note: a more performant expression for finding\n\
|
|
|
190 xml tags is "<[^>]*>", which avoids backtracking.
|
|
|
191 displayString_plusLazy= +? - Lazy match 1 or more times
|
|
|
192 additionalInfo_plusLazy= Lazy match 1 or more times\n\n\
|
|
|
193 First tries to match the preceding token once.\n\
|
|
|
194 Falls back to matching it more often if this choice made a full match impossible.\n\nExamples:\n\
|
|
|
195 - The expression "fo+?" matches "fo" and "fo" in text\n\
|
|
|
196 "f fo foo".\n\
|
|
|
197 - The expression "fo+?o\\d" matches "foo2" and "fooo3" in text\n\
|
|
|
198 "fo1 foo2 fooo3".\n\
|
|
|
199 - The expression "<.+?>" matches "<p>", "<b>", and "</b>" in text\n\
|
|
|
200 "<p><b>bold</b>". Note: a more performant expression for finding\n\
|
|
|
201 xml tags is "<[^>]*>", which avoids backtracking.
|
|
|
202 displayString_exactLazy= {n}? - Lazy match exactly n times
|
|
|
203 additionalInfo_exactLazy= Lazy match exactly n times.\n\n\
|
|
|
204 This expression is equivalent to the expression\n\
|
|
|
205 {n} - Greedy match exactly n times.
|
|
|
206 displayString_leastLazy= {n,}? - Lazy match >= n times
|
|
|
207 additionalInfo_leastLazy= Lazy match >= n times.\n\n\
|
|
|
208 First tries to match the preceding token n times. Falls back to\n\
|
|
|
209 matching it more often, if this choice made a full match impossible.\n\nExamples:\n\
|
|
|
210 - The expression "fo{2,}?" matches "foo" and "foo" in text\n\
|
|
|
211 "f fo foo fooo".\n\
|
|
|
212 - The expression "fo{2,}?o\\d" matches "fooo3" and "foooo4" in text\n\
|
|
|
213 "fo1 foo2 fooo3 foooo4".\n\
|
|
|
214 - The expression "10{3,}?[^0]" matches all powers of ten that are larger than one thousand.\n\n\
|
|
|
215 Note: The expressions "{0,}?" and "*?" are equivalent;\n\
|
|
|
216 likewise, "{1,}?" is equivalent to "+?".
|
|
|
217 displayString_countLazy= {n,m}? - Lazy match >= n times but <= m times
|
|
|
218 additionalInfo_countLazy= Lazy match >= n times but <= m times.\n\n\
|
|
|
219 First tries to match the preceding token n times.\n\
|
|
|
220 Falls back to matching it more often (but at most m times),\n\
|
|
|
221 if this choice made a full match impossible.\n\nExamples:\n\
|
|
|
222 - The expression "fo{1,2}?" matches "fo", "fo", and "fo" in text\n\
|
|
|
223 "f fo foo fooo".\n\
|
|
|
224 - The expression "fo{1,2}?o\\d" matches "foo2" and "fooo3" in text\n\
|
|
|
225 "fo1 foo2 fooo3 foooo4".\n\
|
|
|
226
|
|
|
227 displayString_questPoss= ?+ - Possessive match 0 or 1 times (no backtracking)
|
|
|
228 additionalInfo_questPoss= Possessive match 0 or 1 times.\n\n\
|
|
|
229 Matches the preceding token if possible. Never backtracks,\n\
|
|
|
230 even if this choice renders a full match impossible.\n\nExample:\n\
|
|
|
231 The expression "fo?+o\\d" matches the first, but not the second line in text\n\
|
|
|
232 "foo1\n\
|
|
|
233 fo1".
|
|
|
234 displayString_starPoss= *+ Possessive match 0 or more times (no backtracking)
|
|
|
235 additionalInfo_starPoss= Possessive match 0 or more times.\n\n\
|
|
|
236 Tries to match the preceding token as many times as possible. Never backtracks,\n\
|
|
|
237 even if this choice renders a full match impossible.\n\nExamples:\n\
|
|
|
238 - The expression "fo*+" matches "f", "fo" and "foo" in text\n\
|
|
|
239 "f fo foo".\n\
|
|
|
240 - The expression "fo*+o\\d" matches nowhere in text\n\
|
|
|
241 "fo1 foo2 fooo3".\n\
|
|
|
242 - The expression "<.*+>" matches nowhere in text\n\
|
|
|
243 "<p><b>bold</b>".
|
|
|
244 displayString_plusPoss= ++ - Possessive match 1 or more times (no backtracking)
|
|
|
245 additionalInfo_plusPoss= Possessive match 1 or more times.\n\n\
|
|
|
246 Tries to match the preceding token as many times as possible. Never backtracks,\n\
|
|
|
247 even if this choice renders a full match impossible.\n\nExamples:\n\
|
|
|
248 - The expression "fo++" matches "fo" and "foo" in text\n\
|
|
|
249 "f fo foo".\n\
|
|
|
250 - The expression "fo++o\\d" matches nowhere in text\n\
|
|
|
251 "fo1 foo2 fooo3".\n\
|
|
|
252 - The expression "<.++>" matches nowhere in text\n\
|
|
|
253 "<p><b>bold</b>".
|
|
|
254
|
|
|
255 displayString_exactPoss= {n}+ - Possessive match exactly n times (no backtracking)
|
|
|
256 additionalInfo_exactPoss= Possessive match exactly n times.\n\n\
|
|
|
257 This expression is equivalent to the expression\n\
|
|
|
258 {n} - Greedy match exactly n times.
|
|
|
259 displayString_leastPoss= {n,}+ - Possessive match >= n times (no backtracking)
|
|
|
260 additionalInfo_leastPoss= Possessive match >= n times.\n\n\
|
|
|
261 Tries to match the preceding token as many times as possible, but at least n times.\n\
|
|
|
262 Never backtracks, even if this choice renders a full match impossible.\n\nExamples:\n\
|
|
|
263 - The expression "fo{2,}+" matches "foo" and "fooo" in text\n\
|
|
|
264 "f fo foo fooo".\n\
|
|
|
265 - The expression "fo{2,}?o\\d" matches nowhere in text\n\
|
|
|
266 "fo1 foo2 fooo3 foooo4".\n\
|
|
|
267 Note: The expressions "{0,}?" and "*?" are equivalent;\n\
|
|
|
268 likewise, "{1,}?" is equivalent to "+?".
|
|
|
269
|
|
|
270 displayString_countPoss= {n,m}+ - Possessive match >= n times but <= m times (no backtracking)
|
|
|
271 additionalInfo_countPoss= Possessive match >= n times but <= m times.\n\n\
|
|
|
272 Tries to match the preceding token as many times as possible, \n\
|
|
|
273 at least n times and at most m times.\n\
|
|
|
274 Never backtracks, even if this choice renders a full match impossible.\n\nExamples:\n\
|
|
|
275 - The expression "fo{1,2}+" matches "fo", "foo", and "foo" in text\n\
|
|
|
276 "f fo foo fooo".\n\
|
|
|
277 - The expression "fo{1,2}+o\\d" matches only "fooo3" in text\n\
|
|
|
278 "fo1 foo2 fooo3 foooo4".\n\
|
|
|
279 - The expression "^.{70,80}+$" matches all the lines that contain\n\
|
|
|
280 between 70 and 80 characters (inclusive).
|
|
|
281
|
|
|
282 displayString_alt= U|V - Alternation: U or V
|
|
|
283 additionalInfo_alt= Alternation.\n\n\
|
|
|
284 First tries to match subexpression U. Falls back and tries to match V if U didn't match.\n\nExamples:\n\
|
|
|
285 - The expression "A|B" applied to text "BA" first matches "B", then "A".\n\
|
|
|
286 - The expression "AB|BC|CD" applied to text "ABC BC DAB" matches, in sequence:\n\
|
|
|
287 "AB" in the first word, the second word "BC", "AB" at the very end.
|
|
|
288 displayString_group= (Expr) - Mark Expr as capturing group
|
|
|
289 additionalInfo_group= Mark Expr as capturing group.\n\n\
|
|
|
290 Capturing groups are numbered by counting their opening parentheses from left to right.\n\
|
|
|
291 In the expression "((A)(B(C)))", for example, there are four such groups:\n\
|
|
|
292 1 ((A)(B(C)))\n\
|
|
|
293 2 (A)\n\
|
|
|
294 3 (B(C))\n\
|
|
|
295 4 (C)\n\
|
|
|
296 \n\
|
|
|
297 Group zero always stands for the entire expression. During a match,\n\
|
|
|
298 each subsequence of the input sequence that matches such a group is saved.\n\
|
|
|
299 The captured subsequence i may be used later in the expression, via a back reference "\\i",\n\
|
|
|
300 and may also be used in the replace string via "$i".\n\
|
|
|
301 \n\
|
|
|
302 Note: Groups beginning with (? are pure, non-capturing groups that\n\
|
|
|
303 do not capture text and do not count towards the group total.
|
|
|
304
|
|
|
305 displayString_bs_i= \\i - Match of the capturing group i
|
|
|
306 additionalInfo_bs_i= Match of the capturing group i.\n\n\
|
|
|
307 \\i matches the subsequence that has already been saved as capturing group i.\n\
|
|
|
308 \\0 is not a valid group number in the regular expression.\n\nExample:\n\
|
|
|
309 The expression "(\\d+)\\+\\1" matches "10+10" in text "9+10+10+11".\n\
|
|
|
310 \n\
|
|
|
311 Note: in the replace string, $i stands for the capturing group i.
|
|
|
312
|
|
|
313 displayString_bs= \\ - Quote next character
|
|
|
314 additionalInfo_bs= Quote next character\n\nExample:\n\
|
|
|
315 The expression "\\{\\n\\}" matches the text "{n}".
|
|
|
316
|
|
|
317 displayString_bs_Q= \\Q - Start quoting
|
|
|
318 additionalInfo_bs_Q= Start quoting\n\n\
|
|
|
319 All characters between \\Q and the next \\E are taken literally and are not interpreted.\n\nExample:\n\
|
|
|
320 The expression "\\Qnew int[] {42}\\E;" matches text "new int[] {42}".
|
|
|
321 displayString_bs_E= \\E - End quoting
|
|
|
322 additionalInfo_bs_E= End quoting\n\n\
|
|
|
323 All characters between \\Q and the next \\E are taken literally and are not interpreted.\n\nExample:\n\
|
|
|
324 The expression "\\Qnew int[] {42}\\E;" matches text "new int[] {42}".
|
|
|
325
|
|
|
326 displayString_set= [ecl] - Character set
|
|
|
327 additionalInfo_set= Character set\n\n\
|
|
|
328 Matches a single character out of the set.\n\nExample:\n\
|
|
|
329 The expression "[ecl]" matches "c" and "l" in text "cold".
|
|
|
330 displayString_setExcl= [^ecl] - Excluded character set
|
|
|
331 additionalInfo_setExcl= Excluded character set\n\n\
|
|
|
332 Matches a single character that is not one of the excluded characters.\n\nExamples:\n\
|
|
|
333 The expression "[^ecl]" matches "o" and "d" in text "cold".\n\
|
|
|
334 The expression "[a-z&&[^ecl]]" matches any character from a to z, excluding e, c, and l.
|
|
|
335 displayString_setRange= [c-l] - Character range
|
|
|
336 additionalInfo_setRange= Character range\n\n\
|
|
|
337 Matches a single character out of the range from 'c' to 'l'.\n\nExamples:\n\
|
|
|
338 The expression "[c-l]" matches "c", "l", and "d" in text "cold".\n\
|
|
|
339 The expression "[a-z&&[^ecl]]" matches any character from a to z, excluding e, c, and l.
|
|
|
340 displayString_setInter= && - Intersection of character sets
|
|
|
341 additionalInfo_setInter= Intersection of character sets\n\n\
|
|
|
342 Matches a character that is in both of the given sets.\n\nExample:\n\
|
|
|
343 The expression "[a-z&&[^ecl]]" matches any character from a to z, excluding e, c, and l.
|
|
|
344
|
|
|
345 displayString_posix= \\p{Class} - POSIX or Unicode character class
|
|
|
346 additionalInfo_posix= POSIX or Unicode character class\n\n\
|
|
|
347 Matches a character from the given character class 'Class'.\n\
|
|
|
348 Valid classes are:\n\
|
|
|
349 \n\
|
|
|
350 - POSIX character classes (US-ASCII only):\n\
|
|
|
351 \ Lower, Upper, ASCII, Alpha, Digit, Alnum, Punct,\n\
|
|
|
352 \ Graph, Print, Blank, Cntrl, XDigit, and Space.\n\
|
|
|
353 \n\
|
|
|
354 - Unicode blocks (with the prefix 'In'), e.g.:\n\
|
|
|
355 \ InBasicLatin\n\
|
|
|
356 \ InLatin-1Supplement\n\
|
|
|
357 \ InGreek\n\
|
|
|
358 \n\
|
|
|
359 - Unicode categories, e.g.:\n\
|
|
|
360 \ Lu: Uppercase Letter\n\
|
|
|
361 \ Ll: Lowercase Letter\n\
|
|
|
362 \ L: Letter\n\
|
|
|
363 \ N: Number\n\
|
|
|
364 \ Z: Separator\n\
|
|
|
365 \ LD: Letter or Digit\n\
|
|
|
366 \ L1: Latin-1
|
|
|
367
|
|
|
368 displayString_posixNot= \\P{Class} - Excluded POSIX or Unicode character class
|
|
|
369 additionalInfo_posixNot= Excluded POSIX or Unicode character class\n\n\
|
|
|
370 Negation of character set \\p{Class}. Example:\n\
|
|
|
371 \\P{ASCII} is equivalent to [^\\p{ASCII}] and matches all non-ASCII characters.\n\n\
|
|
|
372 Valid classes are:\n\
|
|
|
373 \n\
|
|
|
374 - POSIX character classes (US-ASCII only):\n\
|
|
|
375 \ Lower, Upper, ASCII, Alpha, Digit, Alnum, Punct,\n\
|
|
|
376 \ Graph, Print, Blank, Cntrl, XDigit, and Space.\n\
|
|
|
377 \n\
|
|
|
378 - Unicode blocks (with the prefix 'In'), e.g.:\n\
|
|
|
379 \ InBasicLatin\n\
|
|
|
380 \ InLatin-1Supplement\n\
|
|
|
381 \ InGreek\n\
|
|
|
382 \n\
|
|
|
383 - Unicode categories, e.g.:\n\
|
|
|
384 \ Lu: Uppercase Letter\n\
|
|
|
385 \ Ll: Lowercase Letter\n\
|
|
|
386 \ L: Letter\n\
|
|
|
387 \ N: Number\n\
|
|
|
388 \ Z: Separator\n\
|
|
|
389 \ LD: Letter or Digit\n\
|
|
|
390 \ L1: Latin-1
|
|
|
391
|
|
|
392
|
|
|
393 #Flags:
|
|
|
394 displayString_flag= (?ismd-ismd) - Turn flags on or off
|
|
|
395 additionalInfo_flag= Turn flags on and off for the rest of the matching process.\n\n\
|
|
|
396 Flags before the dash are turned on; those after the dash are turned off.\n\
|
|
|
397 The following flags are supported:\n\
|
|
|
398 - i: case-insensitive matching\n\
|
|
|
399 \n\
|
|
|
400 - s: single-line, or dotall matching mode:\n\
|
|
|
401 \ The expression . matches any character, including a line terminator.\n\
|
|
|
402 \n\
|
|
|
403 - m: multiline matching mode:\n\
|
|
|
404 \ The expressions ^ and $ match just after or just before,\n\
|
|
|
405 \ respectively, a line terminator or the end of the input sequence.\n\
|
|
|
406 \ When multiline matching is turned off, these expressions only\n\
|
|
|
407 \ match at the beginning and the end of the entire input sequence.\n\
|
|
|
408 \ This flag is ON by default.\n\
|
|
|
409 \n\
|
|
|
410 - d: Unix lines matching mode:\n\
|
|
|
411 \ Only the '\\n' line terminator\n\
|
|
|
412 \ is recognized in the behavior of ., ^, and $
|
|
|
413 # - u: unicode-aware case folding:\n\
|
|
|
414 # Case-insensitive matching, when enabled, is done in a manner consistent\n\
|
|
|
415 # with the Unicode Standard. By default, case-insensitive matching\n\
|
|
|
416 # assumes that only characters in the US-ASCII charset are being matched.
|
|
|
417 # - c: canonical equivalence\n\
|
|
|
418 # Two characters will be considered to match if, and only if, their full\n\
|
|
|
419 # canonical decompositions match. The expression "a\\\u0075030A", for example,\n\
|
|
|
420 # will match the string "a\u030A" when this flag is specified.\n\
|
|
|
421 # By default, matching does not take canonical equivalence into account.
|
|
|
422 # - x: comments mode\n\
|
|
|
423 # Whitespace is ignored, and embedded comments starting with\n\
|
|
|
424 # # are ignored until the end of a line.\n\
|
|
|
425
|
|
|
426 displayString_flagExpr= (?ismd-ismd:Expr) - Turn flags on or off in Expr
|
|
|
427 additionalInfo_flagExpr= Turn flags on and off in Expr.\n\n\
|
|
|
428 Flags before the dash are turned on; those after the dash are turned off.\n\
|
|
|
429 The following flags are supported:\n\
|
|
|
430 - i: case-insensitive matching\n\
|
|
|
431 \n\
|
|
|
432 - s: single-line, or dotall matching mode:\n\
|
|
|
433 \ The expression . matches any character, including a line terminator.\n\
|
|
|
434 \n\
|
|
|
435 - m: multiline matching mode:\n\
|
|
|
436 \ The expressions ^ and $ match just after or just before,\n\
|
|
|
437 \ respectively, a line terminator or the end of the input sequence.\n\
|
|
|
438 \ When multiline matching is turned off, these expressions only\n\
|
|
|
439 \ match at the beginning and the end of the entire input sequence.\n\
|
|
|
440 \ This flag is ON by default.\n\
|
|
|
441 \n\
|
|
|
442 - d: Unix lines matching mode:\n\
|
|
|
443 \ Only the '\\n' line terminator\n\
|
|
|
444 \ is recognized in the behavior of ., ^, and $
|
|
|
445
|
|
|
446
|
|
|
447 #Noncapturing groups:
|
|
|
448 displayString_nonCap= (?:Expr) - Non-capturing group
|
|
|
449 additionalInfo_nonCap= Non-capturing group of regular expression Expr.\n\n\
|
|
|
450 The group is not saved in a back reference.\n\nExample:\n\
|
|
|
451 The expression "(?:\\w+) (\\d+)" matches "bug 42" in text "It's bug 42.".\n\
|
|
|
452 A back reference "$1" in the replace string will be replaced by "42".
|
|
|
453
|
|
|
454 displayString_atomicCap= (?>Expr) - Non-capturing atomic group
|
|
|
455 additionalInfo_atomicCap= Non-capturing atomic group of regular expression Expr.\n\n\
|
|
|
456 Matches the regular expression Expr once, but does not backtrack into the expression\n\
|
|
|
457 again if the first match did not prove to be successful later on.\n\
|
|
|
458 The group is not saved in a back reference.
|
|
|
459
|
|
|
460 #Lookaround:
|
|
|
461 displayString_posLookahead= (?=Expr) - Zero-width positive lookahead
|
|
|
462 additionalInfo_posLookahead= Expr, via zero-width positive lookahead.\n\n\
|
|
|
463 Matches a position (zero-width: does not consume the matched characters),\n\
|
|
|
464 where the next characters (-> lookahead)\n\
|
|
|
465 do match (-> positive) the embedded expression Expr.\n\nExamples:\n\
|
|
|
466 - The expression "var(?==)" matches only the first "var" in text "var=17; other=var;".\n\
|
|
|
467 - The expression "\\b(?=\\w{7}\\b)\\w*clip\\w*\\b" matches any\n\
|
|
|
468 seven-letter-word that contains "clip". It matches "Eclipse", but not "paperclip".
|
|
|
469
|
|
|
470 displayString_negLookahead= (?!Expr) - Zero-width negative lookahead
|
|
|
471 additionalInfo_negLookahead= Expr, via zero-width negative lookahead.\n\n\
|
|
|
472 Matches a position (zero-width: does not consume the matched characters),\n\
|
|
|
473 where the next characters (-> lookahead)\n\
|
|
|
474 do not match (-> negative) the embedded expression Expr.\n\nExamples:\n\
|
|
|
475 - The expression "var(?!=)" matches only the second "var" in text "var=17; other=var;".\n\
|
|
|
476 - The expression "\\b(?!\\w{5,7}\\b)\\w*clip\\w*\\b" matches any\n\
|
|
|
477 word that contains "clip" and consists of less than 5 or more than 7 characters.\n\
|
|
|
478 It matches "clip" and "paperclip", but not "Eclipse".
|
|
|
479
|
|
|
480 displayString_posLookbehind= (?<=Expr) - Zero-width positive lookbehind
|
|
|
481 additionalInfo_posLookbehind= Expr, via zero-width positive lookbehind.\n\n\
|
|
|
482 Matches a position (zero-width: does not consume the matched characters),\n\
|
|
|
483 where the previous characters (-> lookbehind)\n\
|
|
|
484 do match (-> positive) the embedded expression Expr.\n\nExample:\n\
|
|
|
485 - The expression "\\w{5,}+(?<=as)\\b" matches "alias" and "bananas",\n\
|
|
|
486 but does not match "peas", "apples", or "Alaska".
|
|
|
487
|
|
|
488 displayString_negLookbehind= (?<!Expr) - Zero-width negative lookbehind
|
|
|
489 additionalInfo_negLookbehind= Expr, via zero-width negative lookbehind.\n\n\
|
|
|
490 Matches a position (zero-width: does not consume the matched characters),\n\
|
|
|
491 where the previous characters (-> lookbehind)\n\
|
|
|
492 do not match (-> negative) the embedded expression Expr.\n\nExample:\n\
|
|
|
493 - The expression "\\w{5,}+(?<!as)\\b" matches "Eclipse" and "apples",\n\
|
|
|
494 but does not match "peas" or "bananas".
|
|
|
495
|
|
|
496 #Replace string:
|
|
|
497 displayString_dollar= $i - Match of the capturing group i
|
|
|
498 additionalInfo_dollar= Match of the capturing group i.\n\n\
|
|
|
499 $i is the string that has been saved as capturing group i.\n\
|
|
|
500 $0 is the subsequence matched by the entire expression.\n\
|
|
|
501 \n\
|
|
|
502 Note: in the find expression, \\i stands for the capturing group i.
|
|
|
503 displayString_replace_cap= \\i - Match of the capturing group i
|
|
|
504 additionalInfo_replace_cap= Match of the capturing group i.\n\n\
|
|
|
505 \\i is the string that has been saved as capturing group i.\n\
|
|
|
506 \\0 is the subsequence matched by the entire expression.\n\
|
|
|
507 \n\
|
|
|
508 Note: \\i is equivalent to $i
|
|
|
509 displayString_replace_bs= \\ - Quote next character
|
|
|
510 additionalInfo_replace_bs= Quote next character\n\nExamples:\n\
|
|
|
511 "\\$" will be replaced by "$".\n\
|
|
|
512 "\\q" will be replaced by "q".\n\
|
|
|
513 "\\\\" will be replaced by "\\".
|
|
|
514 displayString_replace_bs_n= \\n - Newline
|
|
|
515 additionalInfo_replace_bs_n= Newline (\\x0A, decimal: 10)\n\n\
|
|
|
516 Note that \\n always inserts the newline character,\n\
|
|
|
517 even if the document uses different line delimiters.\n\n\
|
|
|
518 To insert the document line delimiter, use \\R.
|
|
|
519 displayString_replace_bs_r= \\r - CR
|
|
|
520 additionalInfo_replace_bs_r= Carriage Return (\\x0D, decimal: 13)\n\n\
|
|
|
521 Note that \\r always inserts the carriage return character,\n\
|
|
|
522 even if the document uses different line delimiters.\n\n\
|
|
|
523 To insert the document line delimiter, use \\R.
|
|
|
524 displayString_replace_bs_R= \\R - Line delimiter
|
|
|
525 additionalInfo_replace_bs_R= Line delimiter\n\n\
|
|
|
526 Inserts the default line delimiter of the document.
|
|
|
527 displayString_replace_bs_C=\\C - Retain case
|
|
|
528 additionalInfo_replace_bs_C=\\C - Retain casing of match (all lower case, all upper case, capitalized)\n\
|
|
|
529 when replacing expression after \\C.\n\nExamples:\n\
|
|
|
530 Find: "foo" Replace: "my\\Cbar\\CFar"\n\
|
|
|
531 "foo" will be replaced by "mybarfar".\n\
|
|
|
532 "FOO" will be replaced by "myBARFAR".\n\
|
|
|
533 "Foo" will be replaced by "myBarFar".\n\n\
|
|
|
534 Note that the content of a group ($i, \\i) is currently inserted unmodified.
|
|
|
535
|
