|
92
|
1 /*******************************************************************************
|
|
|
2
|
|
|
3 @file URegex.d
|
|
|
4
|
|
|
5 Copyright (c) 2004 Kris Bell
|
|
|
6
|
|
|
7 This software is provided 'as-is', without any express or implied
|
|
|
8 warranty. In no event will the authors be held liable for damages
|
|
|
9 of any kind arising from the use of this software.
|
|
|
10
|
|
|
11 Permission is hereby granted to anyone to use this software for any
|
|
|
12 purpose, including commercial applications, and to alter it and/or
|
|
|
13 redistribute it freely, subject to the following restrictions:
|
|
|
14
|
|
|
15 1. The origin of this software must not be misrepresented; you must
|
|
|
16 not claim that you wrote the original software. If you use this
|
|
|
17 software in a product, an acknowledgment within documentation of
|
|
|
18 said product would be appreciated but is not required.
|
|
|
19
|
|
|
20 2. Altered source versions must be plainly marked as such, and must
|
|
|
21 not be misrepresented as being the original software.
|
|
|
22
|
|
|
23 3. This notice may not be removed or altered from any distribution
|
|
|
24 of the source.
|
|
|
25
|
|
|
26 4. Derivative works are permitted, but they must carry this notice
|
|
|
27 in full and credit the original source.
|
|
|
28
|
|
|
29
|
|
|
30 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
31
|
|
|
32
|
|
|
33 @version Initial version, November 2004
|
|
|
34 @author Kris
|
|
|
35
|
|
|
36 Note that this package and documentation is built around the ICU
|
|
|
37 project (http://oss.software.ibm.com/icu/). Below is the license
|
|
|
38 statement as specified by that software:
|
|
|
39
|
|
|
40
|
|
|
41 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
42
|
|
|
43
|
|
|
44 ICU License - ICU 1.8.1 and later
|
|
|
45
|
|
|
46 COPYRIGHT AND PERMISSION NOTICE
|
|
|
47
|
|
|
48 Copyright (c) 1995-2003 International Business Machines Corporation and
|
|
|
49 others.
|
|
|
50
|
|
|
51 All rights reserved.
|
|
|
52
|
|
|
53 Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
54 copy of this software and associated documentation files (the
|
|
|
55 "Software"), to deal in the Software without restriction, including
|
|
|
56 without limitation the rights to use, copy, modify, merge, publish,
|
|
|
57 distribute, and/or sell copies of the Software, and to permit persons
|
|
|
58 to whom the Software is furnished to do so, provided that the above
|
|
|
59 copyright notice(s) and this permission notice appear in all copies of
|
|
|
60 the Software and that both the above copyright notice(s) and this
|
|
|
61 permission notice appear in supporting documentation.
|
|
|
62
|
|
|
63 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
64 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
|
65 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
|
|
|
66 OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
|
|
67 HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
|
|
|
68 INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
|
|
|
69 FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
|
|
|
70 NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
|
|
|
71 WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
|
72
|
|
|
73 Except as contained in this notice, the name of a copyright holder
|
|
|
74 shall not be used in advertising or otherwise to promote the sale, use
|
|
|
75 or other dealings in this Software without prior written authorization
|
|
|
76 of the copyright holder.
|
|
|
77
|
|
|
78 ----------------------------------------------------------------------
|
|
|
79
|
|
|
80 All trademarks and registered trademarks mentioned herein are the
|
|
|
81 property of their respective owners.
|
|
|
82
|
|
|
83 *******************************************************************************/
|
|
|
84
|
|
|
85 module dwtx.dwtxhelper.mangoicu.URegex;
|
|
|
86
|
|
|
87 private import dwtx.dwtxhelper.mangoicu.ICU;
|
|
|
88
|
|
|
89 public import dwtx.dwtxhelper.mangoicu.ULocale,
|
|
|
90 dwtx.dwtxhelper.mangoicu.UString,
|
|
|
91 dwtx.dwtxhelper.mangoicu.UCollator,
|
|
|
92 dwtx.dwtxhelper.mangoicu.UBreakIterator;
|
|
|
93
|
|
|
94
|
|
|
95 /*******************************************************************************
|
|
|
96
|
|
|
97 Set of slices to return for group matching. See URegex.groups()
|
|
|
98
|
|
|
99 *******************************************************************************/
|
|
|
100
|
|
|
101 class Groups : ICU
|
|
|
102 {
|
|
|
103 public wchar[] g0,
|
|
|
104 g1,
|
|
|
105 g2,
|
|
|
106 g3,
|
|
|
107 g4,
|
|
|
108 g5,
|
|
|
109 g6,
|
|
|
110 g7,
|
|
|
111 g8,
|
|
|
112 g9;
|
|
|
113 }
|
|
|
114
|
|
|
115 /*******************************************************************************
|
|
|
116
|
|
|
117 Apis for an engine that provides regular-expression searching of
|
|
|
118 UTF16 strings.
|
|
|
119
|
|
|
120 See http://icu.sourceforge.net/apiref/icu4c/uregex_8h.html for full
|
|
|
121 details.
|
|
|
122
|
|
|
123 *******************************************************************************/
|
|
|
124
|
|
|
125 class URegex : Groups
|
|
|
126 {
|
|
|
127 private Handle handle;
|
|
|
128 private UStringView theText;
|
|
|
129
|
|
|
130 // Regex modes
|
|
|
131 public enum Flag
|
|
|
132 {
|
|
|
133 None = 0,
|
|
|
134
|
|
|
135 // Enable case insensitive matching
|
|
|
136 CaseInsensitive = 2,
|
|
|
137
|
|
|
138 // Allow white space and comments within patterns
|
|
|
139 Comments = 4,
|
|
|
140
|
|
|
141 // Control behavior of "$" and "^" If set, recognize
|
|
|
142 // line terminators within string, otherwise, match
|
|
|
143 // only at start and end of input string.
|
|
|
144 MultiLine = 8,
|
|
|
145
|
|
|
146 // If set, '.' matches line terminators, otherwise '.'
|
|
|
147 // matching stops at line end
|
|
|
148 DotAll = 32,
|
|
|
149
|
|
|
150 // Forces normalization of pattern and strings
|
|
|
151 CanonEq = 128,
|
|
|
152
|
|
|
153 // If set, uses the Unicode TR 29 definition of word
|
|
|
154 // boundaries. Warning: Unicode word boundaries are
|
|
|
155 // quite different from traditional regular expression
|
|
|
156 // word boundaries. See http://unicode.org/reports/tr29/#Word_Boundaries
|
|
|
157 UWord = 256,
|
|
|
158 }
|
|
|
159
|
|
|
160 /***********************************************************************
|
|
|
161
|
|
|
162 Compiles the regular expression in string form into an
|
|
|
163 internal representation using the specified match mode
|
|
|
164 flags. The resulting regular expression handle can then
|
|
|
165 be used to perform various matching operations.
|
|
|
166
|
|
|
167 ***********************************************************************/
|
|
|
168
|
|
|
169 this (wchar[] pattern, Flag flags=Flag.None, ParseError* pe=null)
|
|
|
170 {
|
|
|
171 UErrorCode e;
|
|
|
172
|
|
|
173 handle = uregex_open (pattern.ptr, pattern.length, flags, pe, e);
|
|
|
174 testError (e, "failed to open regex");
|
|
|
175 uregex_setText (handle, "", 0, e);
|
|
|
176 }
|
|
|
177
|
|
|
178 /***********************************************************************
|
|
|
179
|
|
|
180 Compiles the regular expression in string form into an
|
|
|
181 internal representation using the specified match mode
|
|
|
182 flags. The resulting regular expression handle can then
|
|
|
183 be used to perform various matching operations.
|
|
|
184
|
|
|
185 ***********************************************************************/
|
|
|
186
|
|
|
187 this (UStringView pattern, Flag flags=Flag.None, ParseError* pe=null)
|
|
|
188 {
|
|
|
189 this (pattern.get, flags, pe);
|
|
|
190 }
|
|
|
191
|
|
|
192 /***********************************************************************
|
|
|
193
|
|
|
194 Internal constructor; used for cloning
|
|
|
195
|
|
|
196 ***********************************************************************/
|
|
|
197
|
|
|
198 private this (Handle handle)
|
|
|
199 {
|
|
|
200 UErrorCode e;
|
|
|
201
|
|
|
202 this.handle = handle;
|
|
|
203 uregex_setText (handle, "", 0, e);
|
|
|
204 }
|
|
|
205
|
|
|
206 /***********************************************************************
|
|
|
207
|
|
|
208 Close the regular expression, recovering all resources (memory)
|
|
|
209 it was holding
|
|
|
210
|
|
|
211 ***********************************************************************/
|
|
|
212
|
|
|
213 ~this ()
|
|
|
214 {
|
|
|
215 uregex_close (handle);
|
|
|
216 }
|
|
|
217
|
|
|
218 /***********************************************************************
|
|
|
219
|
|
|
220 Cloning a regular expression is faster than opening a second
|
|
|
221 instance from the source form of the expression, and requires
|
|
|
222 less memory.
|
|
|
223
|
|
|
224 Note that the current input string and the position of any
|
|
|
225 matched text within it are not cloned; only the pattern itself
|
|
|
226 and and the match mode flags are copied.
|
|
|
227
|
|
|
228 Cloning can be particularly useful to threaded applications
|
|
|
229 that perform multiple match operations in parallel. Each
|
|
|
230 concurrent RE operation requires its own instance of a
|
|
|
231 URegularExpression.
|
|
|
232
|
|
|
233 ***********************************************************************/
|
|
|
234
|
|
|
235 URegex clone ()
|
|
|
236 {
|
|
|
237 UErrorCode e;
|
|
|
238
|
|
|
239 Handle h = uregex_clone (handle, e);
|
|
|
240 testError (e, "failed to clone regex");
|
|
|
241 return new URegex (h);
|
|
|
242 }
|
|
|
243
|
|
|
244 /***********************************************************************
|
|
|
245
|
|
|
246 Return a copy of the source form of the pattern for this
|
|
|
247 regular expression
|
|
|
248
|
|
|
249 ***********************************************************************/
|
|
|
250
|
|
|
251 UString getPattern ()
|
|
|
252 {
|
|
|
253 UErrorCode e;
|
|
|
254 uint len;
|
|
|
255
|
|
|
256 wchar* x = uregex_pattern (handle, len, e);
|
|
|
257 testError (e, "failed to extract regex pattern");
|
|
|
258 return new UString (x[0..len]);
|
|
|
259 }
|
|
|
260
|
|
|
261 /***********************************************************************
|
|
|
262
|
|
|
263 Get the match mode flags that were specified when compiling
|
|
|
264 this regular expression
|
|
|
265
|
|
|
266 ***********************************************************************/
|
|
|
267
|
|
|
268 Flag getFlags ()
|
|
|
269 {
|
|
|
270 UErrorCode e;
|
|
|
271
|
|
|
272 Flag f = cast(Flag) uregex_flags (handle, e);
|
|
|
273 testError (e, "failed to get regex flags");
|
|
|
274 return f;
|
|
|
275 }
|
|
|
276
|
|
|
277 /***********************************************************************
|
|
|
278
|
|
|
279 Set the subject text string upon which the regular expression
|
|
|
280 will look for matches.
|
|
|
281
|
|
|
282 This function may be called any number of times, allowing the
|
|
|
283 regular expression pattern to be applied to different strings.
|
|
|
284
|
|
|
285 Regular expression matching operations work directly on the
|
|
|
286 application's string data. No copy is made. The subject string
|
|
|
287 data must not be altered after calling this function until after
|
|
|
288 all regular expression operations involving this string data are
|
|
|
289 completed.
|
|
|
290
|
|
|
291 Zero length strings are permitted. In this case, no subsequent
|
|
|
292 match operation will dereference the text string pointer.
|
|
|
293
|
|
|
294 ***********************************************************************/
|
|
|
295
|
|
|
296 void setText (UStringView t)
|
|
|
297 {
|
|
|
298 UErrorCode e;
|
|
|
299
|
|
|
300 theText = t;
|
|
|
301 uregex_setText (handle, t.get.ptr, t.length, e);
|
|
|
302 testError (e, "failed to set regex text");
|
|
|
303 }
|
|
|
304
|
|
|
305 /***********************************************************************
|
|
|
306
|
|
|
307 Get the subject text that is currently associated with this
|
|
|
308 regular expression object. This simply returns whatever was
|
|
|
309 previously supplied via setText().
|
|
|
310
|
|
|
311 Note that this returns a read-only reference to the text.
|
|
|
312
|
|
|
313 ***********************************************************************/
|
|
|
314
|
|
|
315 UStringView getText ()
|
|
|
316 {
|
|
|
317 return theText;
|
|
|
318 }
|
|
|
319
|
|
|
320 /***********************************************************************
|
|
|
321
|
|
|
322 Return a set of slices representing the parenthesised groups.
|
|
|
323 This can be used in the following manner:
|
|
|
324
|
|
|
325 @code
|
|
|
326 wchar msg;
|
|
|
327
|
|
|
328 if (regex.next())
|
|
|
329 with (regex.groups())
|
|
|
330 msg ~= g1 ~ ":" ~ g2
|
|
|
331 @endcode
|
|
|
332
|
|
|
333 Note that g0 represents the entire match, whereas g1 through
|
|
|
334 g9 represent the parenthesised expressions.
|
|
|
335
|
|
|
336 ***********************************************************************/
|
|
|
337
|
|
|
338 Groups groups ()
|
|
|
339 {
|
|
|
340 wchar[]* p = &g0;
|
|
|
341 uint count = groupCount();
|
|
|
342 wchar[] content = theText.get();
|
|
|
343
|
|
|
344 if (count > 9)
|
|
|
345 count = 9;
|
|
|
346 for (uint i=0; i <= count; ++p, ++i)
|
|
|
347 *p = content [start(i)..end(i)];
|
|
|
348 return this;
|
|
|
349 }
|
|
|
350
|
|
|
351 /***********************************************************************
|
|
|
352
|
|
|
353 Extract the string for the specified matching expression or
|
|
|
354 subexpression. UString 's' is the destination for the match.
|
|
|
355
|
|
|
356 Group #0 is the complete string of matched text. Group #1 is
|
|
|
357 the text matched by the first set of capturing parentheses.
|
|
|
358
|
|
|
359 ***********************************************************************/
|
|
|
360
|
|
|
361 void group (UString s, uint index)
|
|
|
362 {
|
|
|
363 uint fmt (wchar* dst, uint length, inout UErrorCode e)
|
|
|
364 {
|
|
|
365 return uregex_group (handle, index, dst, length, e);
|
|
|
366 }
|
|
|
367
|
|
|
368 s.format (&fmt, "failed to extract regex group text");
|
|
|
369 }
|
|
|
370
|
|
|
371 /***********************************************************************
|
|
|
372
|
|
|
373 Get the number of capturing groups in this regular
|
|
|
374 expression's pattern
|
|
|
375
|
|
|
376 ***********************************************************************/
|
|
|
377
|
|
|
378 uint groupCount ()
|
|
|
379 {
|
|
|
380 UErrorCode e;
|
|
|
381
|
|
|
382 uint i = uregex_groupCount (handle, e);
|
|
|
383 testError (e, "failed to get regex group-count");
|
|
|
384 return i;
|
|
|
385 }
|
|
|
386
|
|
|
387 /***********************************************************************
|
|
|
388
|
|
|
389 Returns the index in the input string of the start of the
|
|
|
390 text matched by the specified capture group during the
|
|
|
391 previous match operation.
|
|
|
392
|
|
|
393 Return -1 if the capture group was not part of the last
|
|
|
394 match. Group #0 refers to the complete range of matched
|
|
|
395 text. Group #1 refers to the text matched by the first
|
|
|
396 set of capturing parentheses
|
|
|
397
|
|
|
398 ***********************************************************************/
|
|
|
399
|
|
|
400 uint start (uint index = 0)
|
|
|
401 {
|
|
|
402 UErrorCode e;
|
|
|
403
|
|
|
404 uint i = uregex_start (handle, index, e);
|
|
|
405 testError (e, "failed to get regex start");
|
|
|
406 return i;
|
|
|
407 }
|
|
|
408
|
|
|
409 /***********************************************************************
|
|
|
410
|
|
|
411 Returns the index in the input string of the position
|
|
|
412 following the end of the text matched by the specified
|
|
|
413 capture group.
|
|
|
414
|
|
|
415 Return -1 if the capture group was not part of the last
|
|
|
416 match. Group #0 refers to the complete range of matched
|
|
|
417 text. Group #1 refers to the text matched by the first
|
|
|
418 set of capturing parentheses.
|
|
|
419
|
|
|
420 ***********************************************************************/
|
|
|
421
|
|
|
422 uint end (uint index = 0)
|
|
|
423 {
|
|
|
424 UErrorCode e;
|
|
|
425
|
|
|
426 uint i = uregex_end (handle, index, e);
|
|
|
427 testError (e, "failed to get regex end");
|
|
|
428 return i;
|
|
|
429 }
|
|
|
430
|
|
|
431 /***********************************************************************
|
|
|
432
|
|
|
433 Reset any saved state from the previous match.
|
|
|
434
|
|
|
435 Has the effect of causing uregex_findNext to begin at the
|
|
|
436 specified index, and causing uregex_start(), uregex_end()
|
|
|
437 and uregex_group() to return an error indicating that there
|
|
|
438 is no match information available.
|
|
|
439
|
|
|
440 ***********************************************************************/
|
|
|
441
|
|
|
442 void reset (uint startIndex)
|
|
|
443 {
|
|
|
444 UErrorCode e;
|
|
|
445
|
|
|
446 uregex_reset (handle, startIndex, e);
|
|
|
447 testError (e, "failed to set regex next-index");
|
|
|
448 }
|
|
|
449
|
|
|
450 /***********************************************************************
|
|
|
451
|
|
|
452 Attempts to match the input string, beginning at startIndex,
|
|
|
453 against the pattern.
|
|
|
454
|
|
|
455 To succeed, the match must extend to the end of the input
|
|
|
456 string
|
|
|
457
|
|
|
458 ***********************************************************************/
|
|
|
459
|
|
|
460 bool match (uint startIndex)
|
|
|
461 {
|
|
|
462 UErrorCode e;
|
|
|
463
|
|
|
464 bool b = uregex_matches (handle, startIndex, e);
|
|
|
465 testError (e, "failed while matching regex");
|
|
|
466 return b;
|
|
|
467 }
|
|
|
468
|
|
|
469 /***********************************************************************
|
|
|
470
|
|
|
471 Attempts to match the input string, starting from the
|
|
|
472 specified index, against the pattern.
|
|
|
473
|
|
|
474 The match may be of any length, and is not required to
|
|
|
475 extend to the end of the input string. Contrast with match()
|
|
|
476
|
|
|
477 ***********************************************************************/
|
|
|
478
|
|
|
479 bool probe (uint startIndex)
|
|
|
480 {
|
|
|
481 UErrorCode e;
|
|
|
482
|
|
|
483 bool b = uregex_lookingAt (handle, startIndex, e);
|
|
|
484 testError (e, "failed while looking at regex");
|
|
|
485 return b;
|
|
|
486 }
|
|
|
487
|
|
|
488 /***********************************************************************
|
|
|
489
|
|
|
490 Returns whether the text matches the search pattern, starting
|
|
|
491 from the current position.
|
|
|
492
|
|
|
493 If startIndex is specified, the current position is moved to
|
|
|
494 the specified location before the seach is initiated.
|
|
|
495
|
|
|
496 ***********************************************************************/
|
|
|
497
|
|
|
498 bool next (uint startIndex = uint.max)
|
|
|
499 {
|
|
|
500 UErrorCode e;
|
|
|
501 bool b;
|
|
|
502
|
|
|
503 b = (startIndex == uint.max) ? uregex_findNext (handle, e) :
|
|
|
504 uregex_find (handle, startIndex, e);
|
|
|
505
|
|
|
506 testError (e, "failed on next regex");
|
|
|
507 return b;
|
|
|
508 }
|
|
|
509
|
|
|
510 /***********************************************************************
|
|
|
511
|
|
|
512 Replaces every substring of the input that matches the pattern
|
|
|
513 with the given replacement string.
|
|
|
514
|
|
|
515 This is a convenience function that provides a complete
|
|
|
516 find-and-replace-all operation.
|
|
|
517
|
|
|
518 This method scans the input string looking for matches of
|
|
|
519 the pattern. Input that is not part of any match is copied
|
|
|
520 unchanged to the destination buffer. Matched regions are
|
|
|
521 replaced in the output buffer by the replacement string.
|
|
|
522 The replacement string may contain references to capture
|
|
|
523 groups; these take the form of $1, $2, etc.
|
|
|
524
|
|
|
525 The provided 'result' will contain the results, and should
|
|
|
526 be set with a length sufficient to house the entire result.
|
|
|
527 Upon completion, the 'result' is shortened appropriately
|
|
|
528 and the total extent (length) of the operation is returned.
|
|
|
529 Set the initital length of 'result' using the UString method
|
|
|
530 truncate().
|
|
|
531
|
|
|
532 The returned extent should be checked to ensure it is not
|
|
|
533 longer than the length of 'result'. If it is longer, then
|
|
|
534 the result has been truncated.
|
|
|
535
|
|
|
536 ***********************************************************************/
|
|
|
537
|
|
|
538 uint replaceAll (UStringView replace, UString result)
|
|
|
539 {
|
|
|
540 UErrorCode e;
|
|
|
541
|
|
|
542 uint len = uregex_replaceAll (handle, replace.get.ptr, replace.length, result.get.ptr, result.length, e);
|
|
|
543 testError (e, "failed during regex replace");
|
|
|
544 result.truncate (len);
|
|
|
545 return len;
|
|
|
546 }
|
|
|
547
|
|
|
548 /***********************************************************************
|
|
|
549
|
|
|
550 Replaces the first substring of the input that matches the
|
|
|
551 pattern with the given replacement string.
|
|
|
552
|
|
|
553 This is a convenience function that provides a complete
|
|
|
554 find-and-replace operation.
|
|
|
555
|
|
|
556 This method scans the input string looking for a match of
|
|
|
557 the pattern. All input that is not part of the match is
|
|
|
558 copied unchanged to the destination buffer. The matched
|
|
|
559 region is replaced in the output buffer by the replacement
|
|
|
560 string. The replacement string may contain references to
|
|
|
561 capture groups; these take the form of $1, $2, etc
|
|
|
562
|
|
|
563 The provided 'result' will contain the results, and should
|
|
|
564 be set with a length sufficient to house the entire result.
|
|
|
565 Upon completion, the 'result' is shortened appropriately
|
|
|
566 and the total extent (length) of the operation is returned.
|
|
|
567 Set the initital length of 'result' using the UString method
|
|
|
568 truncate().
|
|
|
569
|
|
|
570 The returned extent should be checked to ensure it is not
|
|
|
571 longer than the length of 'result'. If it is longer, then
|
|
|
572 the result has been truncated.
|
|
|
573
|
|
|
574 ***********************************************************************/
|
|
|
575
|
|
|
576 uint replaceFirst (UStringView replace, UString result)
|
|
|
577 {
|
|
|
578 UErrorCode e;
|
|
|
579
|
|
|
580 uint len = uregex_replaceFirst (handle, replace.get.ptr, replace.length, result.get.ptr, result.length, e);
|
|
|
581 testError (e, "failed during regex replace");
|
|
|
582 result.truncate (len);
|
|
|
583 return len;
|
|
|
584 }
|
|
|
585
|
|
|
586 /***********************************************************************
|
|
|
587
|
|
|
588 Split the text up into slices (fields), where each slice
|
|
|
589 represents the text situated between each pattern matched
|
|
|
590 within the text. The pattern is expected to represent one
|
|
|
591 or more slice delimiters.
|
|
|
592
|
|
|
593 ***********************************************************************/
|
|
|
594
|
|
|
595 uint split (wchar[][] fields)
|
|
|
596 {
|
|
|
597 UErrorCode e;
|
|
|
598 uint pos,
|
|
|
599 count;
|
|
|
600 wchar[] content = theText.get;
|
|
|
601
|
|
|
602 while (count < fields.length)
|
|
|
603 if (uregex_findNext (handle, e) && e == e.OK)
|
|
|
604 {
|
|
|
605 uint i = start();
|
|
|
606 fields[count] = content[pos..i];
|
|
|
607 pos = end ();
|
|
|
608
|
|
|
609 // ignore leading delimiter
|
|
|
610 if (i)
|
|
|
611 ++count;
|
|
|
612 }
|
|
|
613 else
|
|
|
614 break;
|
|
|
615
|
|
|
616 testError (e, "failed during split");
|
|
|
617 return count;
|
|
|
618 }
|
|
|
619
|
|
|
620
|
|
|
621 /***********************************************************************
|
|
|
622
|
|
|
623 Bind the ICU functions from a shared library. This is
|
|
|
624 complicated by the issues regarding D and DLLs on the
|
|
|
625 Windows platform
|
|
|
626
|
|
|
627 ***********************************************************************/
|
|
|
628
|
|
|
629 private static void* library;
|
|
|
630
|
|
|
631 /***********************************************************************
|
|
|
632
|
|
|
633 ***********************************************************************/
|
|
|
634
|
|
|
635 private static extern (C)
|
|
|
636 {
|
|
|
637 Handle function (wchar*, uint, uint, ParseError*, inout UErrorCode) uregex_open;
|
|
|
638 void function (Handle) uregex_close;
|
|
|
639 Handle function (Handle, inout UErrorCode) uregex_clone;
|
|
|
640 wchar* function (Handle, inout uint, inout UErrorCode) uregex_pattern;
|
|
|
641 uint function (Handle, inout UErrorCode) uregex_flags;
|
|
|
642 void function (Handle, wchar*, uint, inout UErrorCode) uregex_setText;
|
|
|
643 wchar* function (Handle, inout uint, inout UErrorCode) uregex_getText;
|
|
|
644 uint function (Handle, uint, wchar*, uint, inout UErrorCode) uregex_group;
|
|
|
645 uint function (Handle, inout UErrorCode) uregex_groupCount;
|
|
|
646 uint function (Handle, uint, inout UErrorCode) uregex_start;
|
|
|
647 uint function (Handle, uint, inout UErrorCode) uregex_end;
|
|
|
648 void function (Handle, uint, inout UErrorCode) uregex_reset;
|
|
|
649 bool function (Handle, uint, inout UErrorCode) uregex_matches;
|
|
|
650 bool function (Handle, uint, inout UErrorCode) uregex_lookingAt;
|
|
|
651 bool function (Handle, uint, inout UErrorCode) uregex_find;
|
|
|
652 bool function (Handle, inout UErrorCode) uregex_findNext;
|
|
|
653 uint function (Handle, wchar*, uint, wchar*, uint, inout UErrorCode) uregex_replaceAll;
|
|
|
654 uint function (Handle, wchar*, uint, wchar*, uint, inout UErrorCode) uregex_replaceFirst;
|
|
|
655 }
|
|
|
656
|
|
|
657 /***********************************************************************
|
|
|
658
|
|
|
659 ***********************************************************************/
|
|
|
660
|
|
|
661 static FunctionLoader.Bind[] targets =
|
|
|
662 [
|
|
|
663 {cast(void**) &uregex_open, "uregex_open"},
|
|
|
664 {cast(void**) &uregex_close, "uregex_close"},
|
|
|
665 {cast(void**) &uregex_clone, "uregex_clone"},
|
|
|
666 {cast(void**) &uregex_pattern, "uregex_pattern"},
|
|
|
667 {cast(void**) &uregex_flags, "uregex_flags"},
|
|
|
668 {cast(void**) &uregex_setText, "uregex_setText"},
|
|
|
669 {cast(void**) &uregex_getText, "uregex_getText"},
|
|
|
670 {cast(void**) &uregex_group, "uregex_group"},
|
|
|
671 {cast(void**) &uregex_groupCount, "uregex_groupCount"},
|
|
|
672 {cast(void**) &uregex_start, "uregex_start"},
|
|
|
673 {cast(void**) &uregex_end, "uregex_end"},
|
|
|
674 {cast(void**) &uregex_reset, "uregex_reset"},
|
|
|
675 {cast(void**) &uregex_matches, "uregex_matches"},
|
|
|
676 {cast(void**) &uregex_lookingAt, "uregex_lookingAt"},
|
|
|
677 {cast(void**) &uregex_find, "uregex_find"},
|
|
|
678 {cast(void**) &uregex_findNext, "uregex_findNext"},
|
|
|
679 {cast(void**) &uregex_replaceAll, "uregex_replaceAll"},
|
|
|
680 {cast(void**) &uregex_replaceFirst, "uregex_replaceFirst"},
|
|
|
681 ];
|
|
|
682
|
|
|
683 /***********************************************************************
|
|
|
684
|
|
|
685 ***********************************************************************/
|
|
|
686
|
|
|
687 static this ()
|
|
|
688 {
|
|
|
689 library = FunctionLoader.bind (icuin, targets);
|
|
|
690 }
|
|
|
691
|
|
|
692 /***********************************************************************
|
|
|
693
|
|
|
694 ***********************************************************************/
|
|
|
695
|
|
|
696 static ~this ()
|
|
|
697 {
|
|
|
698 FunctionLoader.unbind (library);
|
|
|
699 }
|
|
|
700 }
|
