The Tor Browser / file comparison

comparison: intl/icu/source/i18n/uregex.cpp

intl/icu/source/i18n/uregex.cpp

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:3f5b75c80c34
1 /*
2 *******************************************************************************
3 * Copyright (C) 2004-2013, International Business Machines
4 * Corporation and others. All Rights Reserved.
5 *******************************************************************************
6 * file name: uregex.cpp
7 */
8
9 #include "unicode/utypes.h"
10
11 #if !UCONFIG_NO_REGULAR_EXPRESSIONS
12
13 #include "unicode/regex.h"
14 #include "unicode/uregex.h"
15 #include "unicode/unistr.h"
16 #include "unicode/ustring.h"
17 #include "unicode/uchar.h"
18 #include "unicode/uobject.h"
19 #include "unicode/utf16.h"
20 #include "umutex.h"
21 #include "uassert.h"
22 #include "cmemory.h"
23
24 #include "regextxt.h"
25
26 #include <stdio.h>
27
28 U_NAMESPACE_BEGIN
29
30 #define REMAINING_CAPACITY(idx,len) ((((len)-(idx))>0)?((len)-(idx)):0)
31
32 struct RegularExpression: public UMemory {
33 public:
34 RegularExpression();
35 ~RegularExpression();
36 int32_t fMagic;
37 RegexPattern *fPat;
38 u_atomic_int32_t *fPatRefCount;
39 UChar *fPatString;
40 int32_t fPatStringLen;
41 RegexMatcher *fMatcher;
42 const UChar *fText; // Text from setText()
43 int32_t fTextLength; // Length provided by user with setText(), which
44 // may be -1.
45 UBool fOwnsText;
46 };
47
48 static const int32_t REXP_MAGIC = 0x72657870; // "rexp" in ASCII
49
50 RegularExpression::RegularExpression() {
51 fMagic = REXP_MAGIC;
52 fPat = NULL;
53 fPatRefCount = NULL;
54 fPatString = NULL;
55 fPatStringLen = 0;
56 fMatcher = NULL;
57 fText = NULL;
58 fTextLength = 0;
59 fOwnsText = FALSE;
60 }
61
62 RegularExpression::~RegularExpression() {
63 delete fMatcher;
64 fMatcher = NULL;
65 if (fPatRefCount!=NULL && umtx_atomic_dec(fPatRefCount)==0) {
66 delete fPat;
67 uprv_free(fPatString);
68 uprv_free((void *)fPatRefCount);
69 }
70 if (fOwnsText && fText!=NULL) {
71 uprv_free((void *)fText);
72 }
73 fMagic = 0;
74 }
75
76 U_NAMESPACE_END
77
78 U_NAMESPACE_USE
79
80 //----------------------------------------------------------------------------------------
81 //
82 // validateRE Do boilerplate style checks on API function parameters.
83 // Return TRUE if they look OK.
84 //----------------------------------------------------------------------------------------
85 static UBool validateRE(const RegularExpression *re, UBool requiresText, UErrorCode *status) {
86 if (U_FAILURE(*status)) {
87 return FALSE;
88 }
89 if (re == NULL || re->fMagic != REXP_MAGIC) {
90 *status = U_ILLEGAL_ARGUMENT_ERROR;
91 return FALSE;
92 }
93 // !!! Not sure how to update this with the new UText backing, which is stored in re->fMatcher anyway
94 if (requiresText && re->fText == NULL && !re->fOwnsText) {
95 *status = U_REGEX_INVALID_STATE;
96 return FALSE;
97 }
98 return TRUE;
99 }
100
101 //----------------------------------------------------------------------------------------
102 //
103 // uregex_open
104 //
105 //----------------------------------------------------------------------------------------
106 U_CAPI URegularExpression * U_EXPORT2
107 uregex_open( const UChar *pattern,
108 int32_t patternLength,
109 uint32_t flags,
110 UParseError *pe,
111 UErrorCode *status) {
112
113 if (U_FAILURE(*status)) {
114 return NULL;
115 }
116 if (pattern == NULL || patternLength < -1 || patternLength == 0) {
117 *status = U_ILLEGAL_ARGUMENT_ERROR;
118 return NULL;
119 }
120 int32_t actualPatLen = patternLength;
121 if (actualPatLen == -1) {
122 actualPatLen = u_strlen(pattern);
123 }
124
125 RegularExpression *re = new RegularExpression;
126 u_atomic_int32_t *refC = (u_atomic_int32_t *)uprv_malloc(sizeof(int32_t));
127 UChar *patBuf = (UChar *)uprv_malloc(sizeof(UChar)*(actualPatLen+1));
128 if (re == NULL || refC == NULL || patBuf == NULL) {
129 *status = U_MEMORY_ALLOCATION_ERROR;
130 delete re;
131 uprv_free((void *)refC);
132 uprv_free(patBuf);
133 return NULL;
134 }
135 re->fPatRefCount = refC;
136 *re->fPatRefCount = 1;
137
138 //
139 // Make a copy of the pattern string, so we can return it later if asked.
140 // For compiling the pattern, we will use a UText wrapper around
141 // this local copy, to avoid making even more copies.
142 //
143 re->fPatString = patBuf;
144 re->fPatStringLen = patternLength;
145 u_memcpy(patBuf, pattern, actualPatLen);
146 patBuf[actualPatLen] = 0;
147
148 UText patText = UTEXT_INITIALIZER;
149 utext_openUChars(&patText, patBuf, patternLength, status);
150
151 //
152 // Compile the pattern
153 //
154 if (pe != NULL) {
155 re->fPat = RegexPattern::compile(&patText, flags, *pe, *status);
156 } else {
157 re->fPat = RegexPattern::compile(&patText, flags, *status);
158 }
159 utext_close(&patText);
160
161 if (U_FAILURE(*status)) {
162 goto ErrorExit;
163 }
164
165 //
166 // Create the matcher object
167 //
168 re->fMatcher = re->fPat->matcher(*status);
169 if (U_SUCCESS(*status)) {
170 return (URegularExpression*)re;
171 }
172
173 ErrorExit:
174 delete re;
175 return NULL;
176
177 }
178
179 //----------------------------------------------------------------------------------------
180 //
181 // uregex_openUText
182 //
183 //----------------------------------------------------------------------------------------
184 U_CAPI URegularExpression * U_EXPORT2
185 uregex_openUText(UText *pattern,
186 uint32_t flags,
187 UParseError *pe,
188 UErrorCode *status) {
189
190 if (U_FAILURE(*status)) {
191 return NULL;
192 }
193 if (pattern == NULL) {
194 *status = U_ILLEGAL_ARGUMENT_ERROR;
195 return NULL;
196 }
197
198 int64_t patternNativeLength = utext_nativeLength(pattern);
199
200 if (patternNativeLength == 0) {
201 *status = U_ILLEGAL_ARGUMENT_ERROR;
202 return NULL;
203 }
204
205 RegularExpression *re = new RegularExpression;
206
207 UErrorCode lengthStatus = U_ZERO_ERROR;
208 int32_t pattern16Length = utext_extract(pattern, 0, patternNativeLength, NULL, 0, &lengthStatus);
209
210 u_atomic_int32_t *refC = (u_atomic_int32_t *)uprv_malloc(sizeof(int32_t));
211 UChar *patBuf = (UChar *)uprv_malloc(sizeof(UChar)*(pattern16Length+1));
212 if (re == NULL || refC == NULL || patBuf == NULL) {
213 *status = U_MEMORY_ALLOCATION_ERROR;
214 delete re;
215 uprv_free((void *)refC);
216 uprv_free(patBuf);
217 return NULL;
218 }
219 re->fPatRefCount = refC;
220 *re->fPatRefCount = 1;
221
222 //
223 // Make a copy of the pattern string, so we can return it later if asked.
224 // For compiling the pattern, we will use a read-only UText wrapper
225 // around this local copy, to avoid making even more copies.
226 //
227 re->fPatString = patBuf;
228 re->fPatStringLen = pattern16Length;
229 utext_extract(pattern, 0, patternNativeLength, patBuf, pattern16Length+1, status);
230
231 UText patText = UTEXT_INITIALIZER;
232 utext_openUChars(&patText, patBuf, pattern16Length, status);
233
234 //
235 // Compile the pattern
236 //
237 if (pe != NULL) {
238 re->fPat = RegexPattern::compile(&patText, flags, *pe, *status);
239 } else {
240 re->fPat = RegexPattern::compile(&patText, flags, *status);
241 }
242 utext_close(&patText);
243
244 if (U_FAILURE(*status)) {
245 goto ErrorExit;
246 }
247
248 //
249 // Create the matcher object
250 //
251 re->fMatcher = re->fPat->matcher(*status);
252 if (U_SUCCESS(*status)) {
253 return (URegularExpression*)re;
254 }
255
256 ErrorExit:
257 delete re;
258 return NULL;
259
260 }
261
262 //----------------------------------------------------------------------------------------
263 //
264 // uregex_close
265 //
266 //----------------------------------------------------------------------------------------
267 U_CAPI void U_EXPORT2
268 uregex_close(URegularExpression *re2) {
269 RegularExpression *re = (RegularExpression*)re2;
270 UErrorCode status = U_ZERO_ERROR;
271 if (validateRE(re, FALSE, &status) == FALSE) {
272 return;
273 }
274 delete re;
275 }
276
277
278 //----------------------------------------------------------------------------------------
279 //
280 // uregex_clone
281 //
282 //----------------------------------------------------------------------------------------
283 U_CAPI URegularExpression * U_EXPORT2
284 uregex_clone(const URegularExpression *source2, UErrorCode *status) {
285 RegularExpression *source = (RegularExpression*)source2;
286 if (validateRE(source, FALSE, status) == FALSE) {
287 return NULL;
288 }
289
290 RegularExpression *clone = new RegularExpression;
291 if (clone == NULL) {
292 *status = U_MEMORY_ALLOCATION_ERROR;
293 return NULL;
294 }
295
296 clone->fMatcher = source->fPat->matcher(*status);
297 if (U_FAILURE(*status)) {
298 delete clone;
299 return NULL;
300 }
301
302 clone->fPat = source->fPat;
303 clone->fPatRefCount = source->fPatRefCount;
304 clone->fPatString = source->fPatString;
305 clone->fPatStringLen = source->fPatStringLen;
306 umtx_atomic_inc(source->fPatRefCount);
307 // Note: fText is not cloned.
308
309 return (URegularExpression*)clone;
310 }
311
312
313
314
315 //------------------------------------------------------------------------------
316 //
317 // uregex_pattern
318 //
319 //------------------------------------------------------------------------------
320 U_CAPI const UChar * U_EXPORT2
321 uregex_pattern(const URegularExpression *regexp2,
322 int32_t *patLength,
323 UErrorCode *status) {
324 RegularExpression *regexp = (RegularExpression*)regexp2;
325
326 if (validateRE(regexp, FALSE, status) == FALSE) {
327 return NULL;
328 }
329 if (patLength != NULL) {
330 *patLength = regexp->fPatStringLen;
331 }
332 return regexp->fPatString;
333 }
334
335
336 //------------------------------------------------------------------------------
337 //
338 // uregex_patternUText
339 //
340 //------------------------------------------------------------------------------
341 U_CAPI UText * U_EXPORT2
342 uregex_patternUText(const URegularExpression *regexp2,
343 UErrorCode *status) {
344 RegularExpression *regexp = (RegularExpression*)regexp2;
345 return regexp->fPat->patternText(*status);
346 }
347
348
349 //------------------------------------------------------------------------------
350 //
351 // uregex_flags
352 //
353 //------------------------------------------------------------------------------
354 U_CAPI int32_t U_EXPORT2
355 uregex_flags(const URegularExpression *regexp2, UErrorCode *status) {
356 RegularExpression *regexp = (RegularExpression*)regexp2;
357 if (validateRE(regexp, FALSE, status) == FALSE) {
358 return 0;
359 }
360 int32_t flags = regexp->fPat->flags();
361 return flags;
362 }
363
364
365 //------------------------------------------------------------------------------
366 //
367 // uregex_setText
368 //
369 //------------------------------------------------------------------------------
370 U_CAPI void U_EXPORT2
371 uregex_setText(URegularExpression *regexp2,
372 const UChar *text,
373 int32_t textLength,
374 UErrorCode *status) {
375 RegularExpression *regexp = (RegularExpression*)regexp2;
376 if (validateRE(regexp, FALSE, status) == FALSE) {
377 return;
378 }
379 if (text == NULL || textLength < -1) {
380 *status = U_ILLEGAL_ARGUMENT_ERROR;
381 return;
382 }
383
384 if (regexp->fOwnsText && regexp->fText != NULL) {
385 uprv_free((void *)regexp->fText);
386 }
387
388 regexp->fText = text;
389 regexp->fTextLength = textLength;
390 regexp->fOwnsText = FALSE;
391
392 UText input = UTEXT_INITIALIZER;
393 utext_openUChars(&input, text, textLength, status);
394 regexp->fMatcher->reset(&input);
395 utext_close(&input); // reset() made a shallow clone, so we don't need this copy
396 }
397
398
399 //------------------------------------------------------------------------------
400 //
401 // uregex_setUText
402 //
403 //------------------------------------------------------------------------------
404 U_CAPI void U_EXPORT2
405 uregex_setUText(URegularExpression *regexp2,
406 UText *text,
407 UErrorCode *status) {
408 RegularExpression *regexp = (RegularExpression*)regexp2;
409 if (validateRE(regexp, FALSE, status) == FALSE) {
410 return;
411 }
412 if (text == NULL) {
413 *status = U_ILLEGAL_ARGUMENT_ERROR;
414 return;
415 }
416
417 if (regexp->fOwnsText && regexp->fText != NULL) {
418 uprv_free((void *)regexp->fText);
419 }
420
421 regexp->fText = NULL; // only fill it in on request
422 regexp->fTextLength = -1;
423 regexp->fOwnsText = TRUE;
424 regexp->fMatcher->reset(text);
425 }
426
427
428
429 //------------------------------------------------------------------------------
430 //
431 // uregex_getText
432 //
433 //------------------------------------------------------------------------------
434 U_CAPI const UChar * U_EXPORT2
435 uregex_getText(URegularExpression *regexp2,
436 int32_t *textLength,
437 UErrorCode *status) {
438 RegularExpression *regexp = (RegularExpression*)regexp2;
439 if (validateRE(regexp, FALSE, status) == FALSE) {
440 return NULL;
441 }
442
443 if (regexp->fText == NULL) {
444 // need to fill in the text
445 UText *inputText = regexp->fMatcher->inputText();
446 int64_t inputNativeLength = utext_nativeLength(inputText);
447 if (UTEXT_FULL_TEXT_IN_CHUNK(inputText, inputNativeLength)) {
448 regexp->fText = inputText->chunkContents;
449 regexp->fTextLength = (int32_t)inputNativeLength;
450 regexp->fOwnsText = FALSE; // because the UText owns it
451 } else {
452 UErrorCode lengthStatus = U_ZERO_ERROR;
453 regexp->fTextLength = utext_extract(inputText, 0, inputNativeLength, NULL, 0, &lengthStatus); // buffer overflow error
454 UChar *inputChars = (UChar *)uprv_malloc(sizeof(UChar)*(regexp->fTextLength+1));
455
456 utext_extract(inputText, 0, inputNativeLength, inputChars, regexp->fTextLength+1, status);
457 regexp->fText = inputChars;
458 regexp->fOwnsText = TRUE; // should already be set but just in case
459 }
460 }
461
462 if (textLength != NULL) {
463 *textLength = regexp->fTextLength;
464 }
465 return regexp->fText;
466 }
467
468
469 //------------------------------------------------------------------------------
470 //
471 // uregex_getUText
472 //
473 //------------------------------------------------------------------------------
474 U_CAPI UText * U_EXPORT2
475 uregex_getUText(URegularExpression *regexp2,
476 UText *dest,
477 UErrorCode *status) {
478 RegularExpression *regexp = (RegularExpression*)regexp2;
479 if (validateRE(regexp, FALSE, status) == FALSE) {
480 return dest;
481 }
482 return regexp->fMatcher->getInput(dest, *status);
483 }
484
485
486 //------------------------------------------------------------------------------
487 //
488 // uregex_refreshUText
489 //
490 //------------------------------------------------------------------------------
491 U_CAPI void U_EXPORT2
492 uregex_refreshUText(URegularExpression *regexp2,
493 UText *text,
494 UErrorCode *status) {
495 RegularExpression *regexp = (RegularExpression*)regexp2;
496 if (validateRE(regexp, FALSE, status) == FALSE) {
497 return;
498 }
499 regexp->fMatcher->refreshInputText(text, *status);
500 }
501
502
503 //------------------------------------------------------------------------------
504 //
505 // uregex_matches
506 //
507 //------------------------------------------------------------------------------
508 U_CAPI UBool U_EXPORT2
509 uregex_matches(URegularExpression *regexp2,
510 int32_t startIndex,
511 UErrorCode *status) {
512 return uregex_matches64( regexp2, (int64_t)startIndex, status);
513 }
514
515 U_CAPI UBool U_EXPORT2
516 uregex_matches64(URegularExpression *regexp2,
517 int64_t startIndex,
518 UErrorCode *status) {
519 RegularExpression *regexp = (RegularExpression*)regexp2;
520 UBool result = FALSE;
521 if (validateRE(regexp, TRUE, status) == FALSE) {
522 return result;
523 }
524 if (startIndex == -1) {
525 result = regexp->fMatcher->matches(*status);
526 } else {
527 result = regexp->fMatcher->matches(startIndex, *status);
528 }
529 return result;
530 }
531
532
533 //------------------------------------------------------------------------------
534 //
535 // uregex_lookingAt
536 //
537 //------------------------------------------------------------------------------
538 U_CAPI UBool U_EXPORT2
539 uregex_lookingAt(URegularExpression *regexp2,
540 int32_t startIndex,
541 UErrorCode *status) {
542 return uregex_lookingAt64( regexp2, (int64_t)startIndex, status);
543 }
544
545 U_CAPI UBool U_EXPORT2
546 uregex_lookingAt64(URegularExpression *regexp2,
547 int64_t startIndex,
548 UErrorCode *status) {
549 RegularExpression *regexp = (RegularExpression*)regexp2;
550 UBool result = FALSE;
551 if (validateRE(regexp, TRUE, status) == FALSE) {
552 return result;
553 }
554 if (startIndex == -1) {
555 result = regexp->fMatcher->lookingAt(*status);
556 } else {
557 result = regexp->fMatcher->lookingAt(startIndex, *status);
558 }
559 return result;
560 }
561
562
563
564 //------------------------------------------------------------------------------
565 //
566 // uregex_find
567 //
568 //------------------------------------------------------------------------------
569 U_CAPI UBool U_EXPORT2
570 uregex_find(URegularExpression *regexp2,
571 int32_t startIndex,
572 UErrorCode *status) {
573 return uregex_find64( regexp2, (int64_t)startIndex, status);
574 }
575
576 U_CAPI UBool U_EXPORT2
577 uregex_find64(URegularExpression *regexp2,
578 int64_t startIndex,
579 UErrorCode *status) {
580 RegularExpression *regexp = (RegularExpression*)regexp2;
581 UBool result = FALSE;
582 if (validateRE(regexp, TRUE, status) == FALSE) {
583 return result;
584 }
585 if (startIndex == -1) {
586 regexp->fMatcher->resetPreserveRegion();
587 result = regexp->fMatcher->find();
588 } else {
589 result = regexp->fMatcher->find(startIndex, *status);
590 }
591 return result;
592 }
593
594
595 //------------------------------------------------------------------------------
596 //
597 // uregex_findNext
598 //
599 //------------------------------------------------------------------------------
600 U_CAPI UBool U_EXPORT2
601 uregex_findNext(URegularExpression *regexp2,
602 UErrorCode *status) {
603 RegularExpression *regexp = (RegularExpression*)regexp2;
604 if (validateRE(regexp, TRUE, status) == FALSE) {
605 return FALSE;
606 }
607 UBool result = regexp->fMatcher->find();
608 return result;
609 }
610
611 //------------------------------------------------------------------------------
612 //
613 // uregex_groupCount
614 //
615 //------------------------------------------------------------------------------
616 U_CAPI int32_t U_EXPORT2
617 uregex_groupCount(URegularExpression *regexp2,
618 UErrorCode *status) {
619 RegularExpression *regexp = (RegularExpression*)regexp2;
620 if (validateRE(regexp, FALSE, status) == FALSE) {
621 return 0;
622 }
623 int32_t result = regexp->fMatcher->groupCount();
624 return result;
625 }
626
627
628 //------------------------------------------------------------------------------
629 //
630 // uregex_group
631 //
632 //------------------------------------------------------------------------------
633 U_CAPI int32_t U_EXPORT2
634 uregex_group(URegularExpression *regexp2,
635 int32_t groupNum,
636 UChar *dest,
637 int32_t destCapacity,
638 UErrorCode *status) {
639 RegularExpression *regexp = (RegularExpression*)regexp2;
640 if (validateRE(regexp, TRUE, status) == FALSE) {
641 return 0;
642 }
643 if (destCapacity < 0 || (destCapacity > 0 && dest == NULL)) {
644 *status = U_ILLEGAL_ARGUMENT_ERROR;
645 return 0;
646 }
647
648 if (destCapacity == 0 || regexp->fText != NULL) {
649 // If preflighting or if we already have the text as UChars,
650 // this is a little cheaper than going through uregex_groupUTextDeep()
651
652 //
653 // Pick up the range of characters from the matcher
654 //
655 int32_t startIx = regexp->fMatcher->start(groupNum, *status);
656 int32_t endIx = regexp->fMatcher->end (groupNum, *status);
657 if (U_FAILURE(*status)) {
658 return 0;
659 }
660
661 //
662 // Trim length based on buffer capacity
663 //
664 int32_t fullLength = endIx - startIx;
665 int32_t copyLength = fullLength;
666 if (copyLength < destCapacity) {
667 dest[copyLength] = 0;
668 } else if (copyLength == destCapacity) {
669 *status = U_STRING_NOT_TERMINATED_WARNING;
670 } else {
671 copyLength = destCapacity;
672 *status = U_BUFFER_OVERFLOW_ERROR;
673 }
674
675 //
676 // Copy capture group to user's buffer
677 //
678 if (copyLength > 0) {
679 u_memcpy(dest, &regexp->fText[startIx], copyLength);
680 }
681 return fullLength;
682 } else {
683 UText *groupText = uregex_groupUTextDeep(regexp2, groupNum, NULL, status);
684 int32_t result = utext_extract(groupText, 0, utext_nativeLength(groupText), dest, destCapacity, status);
685 utext_close(groupText);
686 return result;
687 }
688 }
689
690
691 //------------------------------------------------------------------------------
692 //
693 // uregex_groupUText
694 //
695 //------------------------------------------------------------------------------
696 U_CAPI UText * U_EXPORT2
697 uregex_groupUText(URegularExpression *regexp2,
698 int32_t groupNum,
699 UText *dest,
700 int64_t *groupLength,
701 UErrorCode *status) {
702 RegularExpression *regexp = (RegularExpression*)regexp2;
703 if (validateRE(regexp, TRUE, status) == FALSE) {
704 UErrorCode emptyTextStatus = U_ZERO_ERROR;
705 return (dest ? dest : utext_openUChars(NULL, NULL, 0, &emptyTextStatus));
706 }
707
708 return regexp->fMatcher->group(groupNum, dest, *groupLength, *status);
709 }
710
711 //------------------------------------------------------------------------------
712 //
713 // uregex_groupUTextDeep
714 //
715 //------------------------------------------------------------------------------
716 U_CAPI UText * U_EXPORT2
717 uregex_groupUTextDeep(URegularExpression *regexp2,
718 int32_t groupNum,
719 UText *dest,
720 UErrorCode *status) {
721 RegularExpression *regexp = (RegularExpression*)regexp2;
722 if (validateRE(regexp, TRUE, status) == FALSE) {
723 UErrorCode emptyTextStatus = U_ZERO_ERROR;
724 return (dest ? dest : utext_openUChars(NULL, NULL, 0, &emptyTextStatus));
725 }
726
727 if (regexp->fText != NULL) {
728 //
729 // Pick up the range of characters from the matcher
730 // and use our already-extracted characters
731 //
732 int32_t startIx = regexp->fMatcher->start(groupNum, *status);
733 int32_t endIx = regexp->fMatcher->end (groupNum, *status);
734 if (U_FAILURE(*status)) {
735 UErrorCode emptyTextStatus = U_ZERO_ERROR;
736 return (dest ? dest : utext_openUChars(NULL, NULL, 0, &emptyTextStatus));
737 }
738
739 if (dest) {
740 utext_replace(dest, 0, utext_nativeLength(dest), &regexp->fText[startIx], endIx - startIx, status);
741 } else {
742 UText groupText = UTEXT_INITIALIZER;
743 utext_openUChars(&groupText, &regexp->fText[startIx], endIx - startIx, status);
744 dest = utext_clone(NULL, &groupText, TRUE, FALSE, status);
745 utext_close(&groupText);
746 }
747
748 return dest;
749 } else {
750 return regexp->fMatcher->group(groupNum, dest, *status);
751 }
752 }
753
754 //------------------------------------------------------------------------------
755 //
756 // uregex_start
757 //
758 //------------------------------------------------------------------------------
759 U_CAPI int32_t U_EXPORT2
760 uregex_start(URegularExpression *regexp2,
761 int32_t groupNum,
762 UErrorCode *status) {
763 return (int32_t)uregex_start64( regexp2, groupNum, status);
764 }
765
766 U_CAPI int64_t U_EXPORT2
767 uregex_start64(URegularExpression *regexp2,
768 int32_t groupNum,
769 UErrorCode *status) {
770 RegularExpression *regexp = (RegularExpression*)regexp2;
771 if (validateRE(regexp, TRUE, status) == FALSE) {
772 return 0;
773 }
774 int32_t result = regexp->fMatcher->start(groupNum, *status);
775 return result;
776 }
777
778 //------------------------------------------------------------------------------
779 //
780 // uregex_end
781 //
782 //------------------------------------------------------------------------------
783 U_CAPI int32_t U_EXPORT2
784 uregex_end(URegularExpression *regexp2,
785 int32_t groupNum,
786 UErrorCode *status) {
787 return (int32_t)uregex_end64( regexp2, groupNum, status);
788 }
789
790 U_CAPI int64_t U_EXPORT2
791 uregex_end64(URegularExpression *regexp2,
792 int32_t groupNum,
793 UErrorCode *status) {
794 RegularExpression *regexp = (RegularExpression*)regexp2;
795 if (validateRE(regexp, TRUE, status) == FALSE) {
796 return 0;
797 }
798 int32_t result = regexp->fMatcher->end(groupNum, *status);
799 return result;
800 }
801
802 //------------------------------------------------------------------------------
803 //
804 // uregex_reset
805 //
806 //------------------------------------------------------------------------------
807 U_CAPI void U_EXPORT2
808 uregex_reset(URegularExpression *regexp2,
809 int32_t index,
810 UErrorCode *status) {
811 uregex_reset64( regexp2, (int64_t)index, status);
812 }
813
814 U_CAPI void U_EXPORT2
815 uregex_reset64(URegularExpression *regexp2,
816 int64_t index,
817 UErrorCode *status) {
818 RegularExpression *regexp = (RegularExpression*)regexp2;
819 if (validateRE(regexp, TRUE, status) == FALSE) {
820 return;
821 }
822 regexp->fMatcher->reset(index, *status);
823 }
824
825
826 //------------------------------------------------------------------------------
827 //
828 // uregex_setRegion
829 //
830 //------------------------------------------------------------------------------
831 U_CAPI void U_EXPORT2
832 uregex_setRegion(URegularExpression *regexp2,
833 int32_t regionStart,
834 int32_t regionLimit,
835 UErrorCode *status) {
836 uregex_setRegion64( regexp2, (int64_t)regionStart, (int64_t)regionLimit, status);
837 }
838
839 U_CAPI void U_EXPORT2
840 uregex_setRegion64(URegularExpression *regexp2,
841 int64_t regionStart,
842 int64_t regionLimit,
843 UErrorCode *status) {
844 RegularExpression *regexp = (RegularExpression*)regexp2;
845 if (validateRE(regexp, TRUE, status) == FALSE) {
846 return;
847 }
848 regexp->fMatcher->region(regionStart, regionLimit, *status);
849 }
850
851
852 //------------------------------------------------------------------------------
853 //
854 // uregex_setRegionAndStart
855 //
856 //------------------------------------------------------------------------------
857 U_CAPI void U_EXPORT2
858 uregex_setRegionAndStart(URegularExpression *regexp2,
859 int64_t regionStart,
860 int64_t regionLimit,
861 int64_t startIndex,
862 UErrorCode *status) {
863 RegularExpression *regexp = (RegularExpression*)regexp2;
864 if (validateRE(regexp, TRUE, status) == FALSE) {
865 return;
866 }
867 regexp->fMatcher->region(regionStart, regionLimit, startIndex, *status);
868 }
869
870 //------------------------------------------------------------------------------
871 //
872 // uregex_regionStart
873 //
874 //------------------------------------------------------------------------------
875 U_CAPI int32_t U_EXPORT2
876 uregex_regionStart(const URegularExpression *regexp2,
877 UErrorCode *status) {
878 return (int32_t)uregex_regionStart64(regexp2, status);
879 }
880
881 U_CAPI int64_t U_EXPORT2
882 uregex_regionStart64(const URegularExpression *regexp2,
883 UErrorCode *status) {
884 RegularExpression *regexp = (RegularExpression*)regexp2;
885 if (validateRE(regexp, TRUE, status) == FALSE) {
886 return 0;
887 }
888 return regexp->fMatcher->regionStart();
889 }
890
891
892 //------------------------------------------------------------------------------
893 //
894 // uregex_regionEnd
895 //
896 //------------------------------------------------------------------------------
897 U_CAPI int32_t U_EXPORT2
898 uregex_regionEnd(const URegularExpression *regexp2,
899 UErrorCode *status) {
900 return (int32_t)uregex_regionEnd64(regexp2, status);
901 }
902
903 U_CAPI int64_t U_EXPORT2
904 uregex_regionEnd64(const URegularExpression *regexp2,
905 UErrorCode *status) {
906 RegularExpression *regexp = (RegularExpression*)regexp2;
907 if (validateRE(regexp, TRUE, status) == FALSE) {
908 return 0;
909 }
910 return regexp->fMatcher->regionEnd();
911 }
912
913
914 //------------------------------------------------------------------------------
915 //
916 // uregex_hasTransparentBounds
917 //
918 //------------------------------------------------------------------------------
919 U_CAPI UBool U_EXPORT2
920 uregex_hasTransparentBounds(const URegularExpression *regexp2,
921 UErrorCode *status) {
922 RegularExpression *regexp = (RegularExpression*)regexp2;
923 if (validateRE(regexp, FALSE, status) == FALSE) {
924 return FALSE;
925 }
926 return regexp->fMatcher->hasTransparentBounds();
927 }
928
929
930 //------------------------------------------------------------------------------
931 //
932 // uregex_useTransparentBounds
933 //
934 //------------------------------------------------------------------------------
935 U_CAPI void U_EXPORT2
936 uregex_useTransparentBounds(URegularExpression *regexp2,
937 UBool b,
938 UErrorCode *status) {
939 RegularExpression *regexp = (RegularExpression*)regexp2;
940 if (validateRE(regexp, FALSE, status) == FALSE) {
941 return;
942 }
943 regexp->fMatcher->useTransparentBounds(b);
944 }
945
946
947 //------------------------------------------------------------------------------
948 //
949 // uregex_hasAnchoringBounds
950 //
951 //------------------------------------------------------------------------------
952 U_CAPI UBool U_EXPORT2
953 uregex_hasAnchoringBounds(const URegularExpression *regexp2,
954 UErrorCode *status) {
955 RegularExpression *regexp = (RegularExpression*)regexp2;
956 if (validateRE(regexp, FALSE, status) == FALSE) {
957 return FALSE;
958 }
959 return regexp->fMatcher->hasAnchoringBounds();
960 }
961
962
963 //------------------------------------------------------------------------------
964 //
965 // uregex_useAnchoringBounds
966 //
967 //------------------------------------------------------------------------------
968 U_CAPI void U_EXPORT2
969 uregex_useAnchoringBounds(URegularExpression *regexp2,
970 UBool b,
971 UErrorCode *status) {
972 RegularExpression *regexp = (RegularExpression*)regexp2;
973 if (validateRE(regexp, FALSE, status) == FALSE) {
974 return;
975 }
976 regexp->fMatcher->useAnchoringBounds(b);
977 }
978
979
980 //------------------------------------------------------------------------------
981 //
982 // uregex_hitEnd
983 //
984 //------------------------------------------------------------------------------
985 U_CAPI UBool U_EXPORT2
986 uregex_hitEnd(const URegularExpression *regexp2,
987 UErrorCode *status) {
988 RegularExpression *regexp = (RegularExpression*)regexp2;
989 if (validateRE(regexp, TRUE, status) == FALSE) {
990 return FALSE;
991 }
992 return regexp->fMatcher->hitEnd();
993 }
994
995
996 //------------------------------------------------------------------------------
997 //
998 // uregex_requireEnd
999 //
1000 //------------------------------------------------------------------------------
1001 U_CAPI UBool U_EXPORT2
1002 uregex_requireEnd(const URegularExpression *regexp2,
1003 UErrorCode *status) {
1004 RegularExpression *regexp = (RegularExpression*)regexp2;
1005 if (validateRE(regexp, TRUE, status) == FALSE) {
1006 return FALSE;
1007 }
1008 return regexp->fMatcher->requireEnd();
1009 }
1010
1011
1012 //------------------------------------------------------------------------------
1013 //
1014 // uregex_setTimeLimit
1015 //
1016 //------------------------------------------------------------------------------
1017 U_CAPI void U_EXPORT2
1018 uregex_setTimeLimit(URegularExpression *regexp2,
1019 int32_t limit,
1020 UErrorCode *status) {
1021 RegularExpression *regexp = (RegularExpression*)regexp2;
1022 if (validateRE(regexp, FALSE, status)) {
1023 regexp->fMatcher->setTimeLimit(limit, *status);
1024 }
1025 }
1026
1027
1028
1029 //------------------------------------------------------------------------------
1030 //
1031 // uregex_getTimeLimit
1032 //
1033 //------------------------------------------------------------------------------
1034 U_CAPI int32_t U_EXPORT2
1035 uregex_getTimeLimit(const URegularExpression *regexp2,
1036 UErrorCode *status) {
1037 int32_t retVal = 0;
1038 RegularExpression *regexp = (RegularExpression*)regexp2;
1039 if (validateRE(regexp, FALSE, status)) {
1040 retVal = regexp->fMatcher->getTimeLimit();
1041 }
1042 return retVal;
1043 }
1044
1045
1046
1047 //------------------------------------------------------------------------------
1048 //
1049 // uregex_setStackLimit
1050 //
1051 //------------------------------------------------------------------------------
1052 U_CAPI void U_EXPORT2
1053 uregex_setStackLimit(URegularExpression *regexp2,
1054 int32_t limit,
1055 UErrorCode *status) {
1056 RegularExpression *regexp = (RegularExpression*)regexp2;
1057 if (validateRE(regexp, FALSE, status)) {
1058 regexp->fMatcher->setStackLimit(limit, *status);
1059 }
1060 }
1061
1062
1063
1064 //------------------------------------------------------------------------------
1065 //
1066 // uregex_getStackLimit
1067 //
1068 //------------------------------------------------------------------------------
1069 U_CAPI int32_t U_EXPORT2
1070 uregex_getStackLimit(const URegularExpression *regexp2,
1071 UErrorCode *status) {
1072 int32_t retVal = 0;
1073 RegularExpression *regexp = (RegularExpression*)regexp2;
1074 if (validateRE(regexp, FALSE, status)) {
1075 retVal = regexp->fMatcher->getStackLimit();
1076 }
1077 return retVal;
1078 }
1079
1080
1081 //------------------------------------------------------------------------------
1082 //
1083 // uregex_setMatchCallback
1084 //
1085 //------------------------------------------------------------------------------
1086 U_CAPI void U_EXPORT2
1087 uregex_setMatchCallback(URegularExpression *regexp2,
1088 URegexMatchCallback *callback,
1089 const void *context,
1090 UErrorCode *status) {
1091 RegularExpression *regexp = (RegularExpression*)regexp2;
1092 if (validateRE(regexp, FALSE, status)) {
1093 regexp->fMatcher->setMatchCallback(callback, context, *status);
1094 }
1095 }
1096
1097
1098 //------------------------------------------------------------------------------
1099 //
1100 // uregex_getMatchCallback
1101 //
1102 //------------------------------------------------------------------------------
1103 U_CAPI void U_EXPORT2
1104 uregex_getMatchCallback(const URegularExpression *regexp2,
1105 URegexMatchCallback **callback,
1106 const void **context,
1107 UErrorCode *status) {
1108 RegularExpression *regexp = (RegularExpression*)regexp2;
1109 if (validateRE(regexp, FALSE, status)) {
1110 regexp->fMatcher->getMatchCallback(*callback, *context, *status);
1111 }
1112 }
1113
1114
1115 //------------------------------------------------------------------------------
1116 //
1117 // uregex_setMatchProgressCallback
1118 //
1119 //------------------------------------------------------------------------------
1120 U_CAPI void U_EXPORT2
1121 uregex_setFindProgressCallback(URegularExpression *regexp2,
1122 URegexFindProgressCallback *callback,
1123 const void *context,
1124 UErrorCode *status) {
1125 RegularExpression *regexp = (RegularExpression*)regexp2;
1126 if (validateRE(regexp, FALSE, status)) {
1127 regexp->fMatcher->setFindProgressCallback(callback, context, *status);
1128 }
1129 }
1130
1131
1132 //------------------------------------------------------------------------------
1133 //
1134 // uregex_getMatchCallback
1135 //
1136 //------------------------------------------------------------------------------
1137 U_CAPI void U_EXPORT2
1138 uregex_getFindProgressCallback(const URegularExpression *regexp2,
1139 URegexFindProgressCallback **callback,
1140 const void **context,
1141 UErrorCode *status) {
1142 RegularExpression *regexp = (RegularExpression*)regexp2;
1143 if (validateRE(regexp, FALSE, status)) {
1144 regexp->fMatcher->getFindProgressCallback(*callback, *context, *status);
1145 }
1146 }
1147
1148
1149 //------------------------------------------------------------------------------
1150 //
1151 // uregex_replaceAll
1152 //
1153 //------------------------------------------------------------------------------
1154 U_CAPI int32_t U_EXPORT2
1155 uregex_replaceAll(URegularExpression *regexp2,
1156 const UChar *replacementText,
1157 int32_t replacementLength,
1158 UChar *destBuf,
1159 int32_t destCapacity,
1160 UErrorCode *status) {
1161 RegularExpression *regexp = (RegularExpression*)regexp2;
1162 if (validateRE(regexp, TRUE, status) == FALSE) {
1163 return 0;
1164 }
1165 if (replacementText == NULL || replacementLength < -1 ||
1166 (destBuf == NULL && destCapacity > 0) ||
1167 destCapacity < 0) {
1168 *status = U_ILLEGAL_ARGUMENT_ERROR;
1169 return 0;
1170 }
1171
1172 int32_t len = 0;
1173
1174 uregex_reset(regexp2, 0, status);
1175
1176 // Note: Seperate error code variables for findNext() and appendReplacement()
1177 // are used so that destination buffer overflow errors
1178 // in appendReplacement won't stop findNext() from working.
1179 // appendReplacement() and appendTail() special case incoming buffer
1180 // overflow errors, continuing to return the correct length.
1181 UErrorCode findStatus = *status;
1182 while (uregex_findNext(regexp2, &findStatus)) {
1183 len += uregex_appendReplacement(regexp2, replacementText, replacementLength,
1184 &destBuf, &destCapacity, status);
1185 }
1186 len += uregex_appendTail(regexp2, &destBuf, &destCapacity, status);
1187
1188 if (U_FAILURE(findStatus)) {
1189 // If anything went wrong with the findNext(), make that error trump
1190 // whatever may have happened with the append() operations.
1191 // Errors in findNext() are not expected.
1192 *status = findStatus;
1193 }
1194
1195 return len;
1196 }
1197
1198
1199 //------------------------------------------------------------------------------
1200 //
1201 // uregex_replaceAllUText
1202 //
1203 //------------------------------------------------------------------------------
1204 U_CAPI UText * U_EXPORT2
1205 uregex_replaceAllUText(URegularExpression *regexp2,
1206 UText *replacementText,
1207 UText *dest,
1208 UErrorCode *status) {
1209 RegularExpression *regexp = (RegularExpression*)regexp2;
1210 if (validateRE(regexp, TRUE, status) == FALSE) {
1211 return 0;
1212 }
1213 if (replacementText == NULL) {
1214 *status = U_ILLEGAL_ARGUMENT_ERROR;
1215 return 0;
1216 }
1217
1218 dest = regexp->fMatcher->replaceAll(replacementText, dest, *status);
1219 return dest;
1220 }
1221
1222
1223 //------------------------------------------------------------------------------
1224 //
1225 // uregex_replaceFirst
1226 //
1227 //------------------------------------------------------------------------------
1228 U_CAPI int32_t U_EXPORT2
1229 uregex_replaceFirst(URegularExpression *regexp2,
1230 const UChar *replacementText,
1231 int32_t replacementLength,
1232 UChar *destBuf,
1233 int32_t destCapacity,
1234 UErrorCode *status) {
1235 RegularExpression *regexp = (RegularExpression*)regexp2;
1236 if (validateRE(regexp, TRUE, status) == FALSE) {
1237 return 0;
1238 }
1239 if (replacementText == NULL || replacementLength < -1 ||
1240 (destBuf == NULL && destCapacity > 0) ||
1241 destCapacity < 0) {
1242 *status = U_ILLEGAL_ARGUMENT_ERROR;
1243 return 0;
1244 }
1245
1246 int32_t len = 0;
1247 UBool findSucceeded;
1248 uregex_reset(regexp2, 0, status);
1249 findSucceeded = uregex_find(regexp2, 0, status);
1250 if (findSucceeded) {
1251 len = uregex_appendReplacement(regexp2, replacementText, replacementLength,
1252 &destBuf, &destCapacity, status);
1253 }
1254 len += uregex_appendTail(regexp2, &destBuf, &destCapacity, status);
1255
1256 return len;
1257 }
1258
1259
1260 //------------------------------------------------------------------------------
1261 //
1262 // uregex_replaceFirstUText
1263 //
1264 //------------------------------------------------------------------------------
1265 U_CAPI UText * U_EXPORT2
1266 uregex_replaceFirstUText(URegularExpression *regexp2,
1267 UText *replacementText,
1268 UText *dest,
1269 UErrorCode *status) {
1270 RegularExpression *regexp = (RegularExpression*)regexp2;
1271 if (validateRE(regexp, TRUE, status) == FALSE) {
1272 return 0;
1273 }
1274 if (replacementText == NULL) {
1275 *status = U_ILLEGAL_ARGUMENT_ERROR;
1276 return 0;
1277 }
1278
1279 dest = regexp->fMatcher->replaceFirst(replacementText, dest, *status);
1280 return dest;
1281 }
1282
1283
1284 //------------------------------------------------------------------------------
1285 //
1286 // uregex_appendReplacement
1287 //
1288 //------------------------------------------------------------------------------
1289
1290 U_NAMESPACE_BEGIN
1291 //
1292 // Dummy class, because these functions need to be friends of class RegexMatcher,
1293 // and stand-alone C functions don't work as friends
1294 //
1295 class RegexCImpl {
1296 public:
1297 inline static int32_t appendReplacement(RegularExpression *regexp,
1298 const UChar *replacementText,
1299 int32_t replacementLength,
1300 UChar **destBuf,
1301 int32_t *destCapacity,
1302 UErrorCode *status);
1303
1304 inline static int32_t appendTail(RegularExpression *regexp,
1305 UChar **destBuf,
1306 int32_t *destCapacity,
1307 UErrorCode *status);
1308
1309 inline static int32_t split(RegularExpression *regexp,
1310 UChar *destBuf,
1311 int32_t destCapacity,
1312 int32_t *requiredCapacity,
1313 UChar *destFields[],
1314 int32_t destFieldsCapacity,
1315 UErrorCode *status);
1316 };
1317
1318 U_NAMESPACE_END
1319
1320
1321
1322 static const UChar BACKSLASH = 0x5c;
1323 static const UChar DOLLARSIGN = 0x24;
1324
1325 //
1326 // Move a character to an output buffer, with bounds checking on the index.
1327 // Index advances even if capacity is exceeded, for preflight size computations.
1328 // This little sequence is used a LOT.
1329 //
1330 static inline void appendToBuf(UChar c, int32_t *idx, UChar *buf, int32_t bufCapacity) {
1331 if (*idx < bufCapacity) {
1332 buf[*idx] = c;
1333 }
1334 (*idx)++;
1335 }
1336
1337
1338 //
1339 // appendReplacement, the actual implementation.
1340 //
1341 int32_t RegexCImpl::appendReplacement(RegularExpression *regexp,
1342 const UChar *replacementText,
1343 int32_t replacementLength,
1344 UChar **destBuf,
1345 int32_t *destCapacity,
1346 UErrorCode *status) {
1347
1348 // If we come in with a buffer overflow error, don't suppress the operation.
1349 // A series of appendReplacements, appendTail need to correctly preflight
1350 // the buffer size when an overflow happens somewhere in the middle.
1351 UBool pendingBufferOverflow = FALSE;
1352 if (*status == U_BUFFER_OVERFLOW_ERROR && destCapacity != NULL && *destCapacity == 0) {
1353 pendingBufferOverflow = TRUE;
1354 *status = U_ZERO_ERROR;
1355 }
1356
1357 //
1358 // Validate all paramters
1359 //
1360 if (validateRE(regexp, TRUE, status) == FALSE) {
1361 return 0;
1362 }
1363 if (replacementText == NULL || replacementLength < -1 ||
1364 destCapacity == NULL || destBuf == NULL ||
1365 (*destBuf == NULL && *destCapacity > 0) ||
1366 *destCapacity < 0) {
1367 *status = U_ILLEGAL_ARGUMENT_ERROR;
1368 return 0;
1369 }
1370
1371 RegexMatcher *m = regexp->fMatcher;
1372 if (m->fMatch == FALSE) {
1373 *status = U_REGEX_INVALID_STATE;
1374 return 0;
1375 }
1376
1377 UChar *dest = *destBuf;
1378 int32_t capacity = *destCapacity;
1379 int32_t destIdx = 0;
1380 int32_t i;
1381
1382 // If it wasn't supplied by the caller, get the length of the replacement text.
1383 // TODO: slightly smarter logic in the copy loop could watch for the NUL on
1384 // the fly and avoid this step.
1385 if (replacementLength == -1) {
1386 replacementLength = u_strlen(replacementText);
1387 }
1388
1389 // Copy input string from the end of previous match to start of current match
1390 if (regexp->fText != NULL) {
1391 int32_t matchStart;
1392 int32_t lastMatchEnd;
1393 if (UTEXT_USES_U16(m->fInputText)) {
1394 lastMatchEnd = (int32_t)m->fLastMatchEnd;
1395 matchStart = (int32_t)m->fMatchStart;
1396 } else {
1397 // !!!: Would like a better way to do this!
1398 UErrorCode status = U_ZERO_ERROR;
1399 lastMatchEnd = utext_extract(m->fInputText, 0, m->fLastMatchEnd, NULL, 0, &status);
1400 status = U_ZERO_ERROR;
1401 matchStart = lastMatchEnd + utext_extract(m->fInputText, m->fLastMatchEnd, m->fMatchStart, NULL, 0, &status);
1402 }
1403 for (i=lastMatchEnd; i<matchStart; i++) {
1404 appendToBuf(regexp->fText[i], &destIdx, dest, capacity);
1405 }
1406 } else {
1407 UErrorCode possibleOverflowError = U_ZERO_ERROR; // ignore
1408 destIdx += utext_extract(m->fInputText, m->fLastMatchEnd, m->fMatchStart,
1409 dest==NULL?NULL:&dest[destIdx], REMAINING_CAPACITY(destIdx, capacity),
1410 &possibleOverflowError);
1411 }
1412 U_ASSERT(destIdx >= 0);
1413
1414 // scan the replacement text, looking for substitutions ($n) and \escapes.
1415 int32_t replIdx = 0;
1416 while (replIdx < replacementLength) {
1417 UChar c = replacementText[replIdx];
1418 replIdx++;
1419 if (c != DOLLARSIGN && c != BACKSLASH) {
1420 // Common case, no substitution, no escaping,
1421 // just copy the char to the dest buf.
1422 appendToBuf(c, &destIdx, dest, capacity);
1423 continue;
1424 }
1425
1426 if (c == BACKSLASH) {
1427 // Backslash Escape. Copy the following char out without further checks.
1428 // Note: Surrogate pairs don't need any special handling
1429 // The second half wont be a '$' or a '\', and
1430 // will move to the dest normally on the next
1431 // loop iteration.
1432 if (replIdx >= replacementLength) {
1433 break;
1434 }
1435 c = replacementText[replIdx];
1436
1437 if (c==0x55/*U*/ || c==0x75/*u*/) {
1438 // We have a \udddd or \Udddddddd escape sequence.
1439 UChar32 escapedChar =
1440 u_unescapeAt(uregex_ucstr_unescape_charAt,
1441 &replIdx, // Index is updated by unescapeAt
1442 replacementLength, // Length of replacement text
1443 (void *)replacementText);
1444
1445 if (escapedChar != (UChar32)0xFFFFFFFF) {
1446 if (escapedChar <= 0xffff) {
1447 appendToBuf((UChar)escapedChar, &destIdx, dest, capacity);
1448 } else {
1449 appendToBuf(U16_LEAD(escapedChar), &destIdx, dest, capacity);
1450 appendToBuf(U16_TRAIL(escapedChar), &destIdx, dest, capacity);
1451 }
1452 continue;
1453 }
1454 // Note: if the \u escape was invalid, just fall through and
1455 // treat it as a plain \<anything> escape.
1456 }
1457
1458 // Plain backslash escape. Just put out the escaped character.
1459 appendToBuf(c, &destIdx, dest, capacity);
1460
1461 replIdx++;
1462 continue;
1463 }
1464
1465
1466
1467 // We've got a $. Pick up a capture group number if one follows.
1468 // Consume at most the number of digits necessary for the largest capture
1469 // number that is valid for this pattern.
1470
1471 int32_t numDigits = 0;
1472 int32_t groupNum = 0;
1473 UChar32 digitC;
1474 for (;;) {
1475 if (replIdx >= replacementLength) {
1476 break;
1477 }
1478 U16_GET(replacementText, 0, replIdx, replacementLength, digitC);
1479 if (u_isdigit(digitC) == FALSE) {
1480 break;
1481 }
1482
1483 U16_FWD_1(replacementText, replIdx, replacementLength);
1484 groupNum=groupNum*10 + u_charDigitValue(digitC);
1485 numDigits++;
1486 if (numDigits >= m->fPattern->fMaxCaptureDigits) {
1487 break;
1488 }
1489 }
1490
1491
1492 if (numDigits == 0) {
1493 // The $ didn't introduce a group number at all.
1494 // Treat it as just part of the substitution text.
1495 appendToBuf(DOLLARSIGN, &destIdx, dest, capacity);
1496 continue;
1497 }
1498
1499 // Finally, append the capture group data to the destination.
1500 destIdx += uregex_group((URegularExpression*)regexp, groupNum,
1501 dest==NULL?NULL:&dest[destIdx], REMAINING_CAPACITY(destIdx, capacity), status);
1502 if (*status == U_BUFFER_OVERFLOW_ERROR) {
1503 // Ignore buffer overflow when extracting the group. We need to
1504 // continue on to get full size of the untruncated result. We will
1505 // raise our own buffer overflow error at the end.
1506 *status = U_ZERO_ERROR;
1507 }
1508
1509 if (U_FAILURE(*status)) {
1510 // Can fail if group number is out of range.
1511 break;
1512 }
1513
1514 }
1515
1516 //
1517 // Nul Terminate the dest buffer if possible.
1518 // Set the appropriate buffer overflow or not terminated error, if needed.
1519 //
1520 if (destIdx < capacity) {
1521 dest[destIdx] = 0;
1522 } else if (destIdx == *destCapacity) {
1523 *status = U_STRING_NOT_TERMINATED_WARNING;
1524 } else {
1525 *status = U_BUFFER_OVERFLOW_ERROR;
1526 }
1527
1528 //
1529 // Return an updated dest buffer and capacity to the caller.
1530 //
1531 if (destIdx > 0 && *destCapacity > 0) {
1532 if (destIdx < capacity) {
1533 *destBuf += destIdx;
1534 *destCapacity -= destIdx;
1535 } else {
1536 *destBuf += capacity;
1537 *destCapacity = 0;
1538 }
1539 }
1540
1541 // If we came in with a buffer overflow, make sure we go out with one also.
1542 // (A zero length match right at the end of the previous match could
1543 // make this function succeed even though a previous call had overflowed the buf)
1544 if (pendingBufferOverflow && U_SUCCESS(*status)) {
1545 *status = U_BUFFER_OVERFLOW_ERROR;
1546 }
1547
1548 return destIdx;
1549 }
1550
1551 //
1552 // appendReplacement the actual API function,
1553 //
1554 U_CAPI int32_t U_EXPORT2
1555 uregex_appendReplacement(URegularExpression *regexp2,
1556 const UChar *replacementText,
1557 int32_t replacementLength,
1558 UChar **destBuf,
1559 int32_t *destCapacity,
1560 UErrorCode *status) {
1561
1562 RegularExpression *regexp = (RegularExpression*)regexp2;
1563 return RegexCImpl::appendReplacement(
1564 regexp, replacementText, replacementLength,destBuf, destCapacity, status);
1565 }
1566
1567 //
1568 // uregex_appendReplacementUText...can just use the normal C++ method
1569 //
1570 U_CAPI void U_EXPORT2
1571 uregex_appendReplacementUText(URegularExpression *regexp2,
1572 UText *replText,
1573 UText *dest,
1574 UErrorCode *status) {
1575 RegularExpression *regexp = (RegularExpression*)regexp2;
1576 regexp->fMatcher->appendReplacement(dest, replText, *status);
1577 }
1578
1579
1580 //------------------------------------------------------------------------------
1581 //
1582 // uregex_appendTail
1583 //
1584 //------------------------------------------------------------------------------
1585 int32_t RegexCImpl::appendTail(RegularExpression *regexp,
1586 UChar **destBuf,
1587 int32_t *destCapacity,
1588 UErrorCode *status)
1589 {
1590
1591 // If we come in with a buffer overflow error, don't suppress the operation.
1592 // A series of appendReplacements, appendTail need to correctly preflight
1593 // the buffer size when an overflow happens somewhere in the middle.
1594 UBool pendingBufferOverflow = FALSE;
1595 if (*status == U_BUFFER_OVERFLOW_ERROR && destCapacity != NULL && *destCapacity == 0) {
1596 pendingBufferOverflow = TRUE;
1597 *status = U_ZERO_ERROR;
1598 }
1599
1600 if (validateRE(regexp, TRUE, status) == FALSE) {
1601 return 0;
1602 }
1603
1604 if (destCapacity == NULL || destBuf == NULL ||
1605 (*destBuf == NULL && *destCapacity > 0) ||
1606 *destCapacity < 0)
1607 {
1608 *status = U_ILLEGAL_ARGUMENT_ERROR;
1609 return 0;
1610 }
1611
1612 RegexMatcher *m = regexp->fMatcher;
1613
1614 int32_t destIdx = 0;
1615 int32_t destCap = *destCapacity;
1616 UChar *dest = *destBuf;
1617
1618 if (regexp->fText != NULL) {
1619 int32_t srcIdx;
1620 int64_t nativeIdx = (m->fMatch ? m->fMatchEnd : m->fLastMatchEnd);
1621 if (nativeIdx == -1) {
1622 srcIdx = 0;
1623 } else if (UTEXT_USES_U16(m->fInputText)) {
1624 srcIdx = (int32_t)nativeIdx;
1625 } else {
1626 UErrorCode status = U_ZERO_ERROR;
1627 srcIdx = utext_extract(m->fInputText, 0, nativeIdx, NULL, 0, &status);
1628 }
1629
1630 for (;;) {
1631 U_ASSERT(destIdx >= 0);
1632
1633 if (srcIdx == regexp->fTextLength) {
1634 break;
1635 }
1636 UChar c = regexp->fText[srcIdx];
1637 if (c == 0 && regexp->fTextLength == -1) {
1638 regexp->fTextLength = srcIdx;
1639 break;
1640 }
1641
1642 if (destIdx < destCap) {
1643 dest[destIdx] = c;
1644 } else {
1645 // We've overflowed the dest buffer.
1646 // If the total input string length is known, we can
1647 // compute the total buffer size needed without scanning through the string.
1648 if (regexp->fTextLength > 0) {
1649 destIdx += (regexp->fTextLength - srcIdx);
1650 break;
1651 }
1652 }
1653 srcIdx++;
1654 destIdx++;
1655 }
1656 } else {
1657 int64_t srcIdx;
1658 if (m->fMatch) {
1659 // The most recent call to find() succeeded.
1660 srcIdx = m->fMatchEnd;
1661 } else {
1662 // The last call to find() on this matcher failed().
1663 // Look back to the end of the last find() that succeeded for src index.
1664 srcIdx = m->fLastMatchEnd;
1665 if (srcIdx == -1) {
1666 // There has been no successful match with this matcher.
1667 // We want to copy the whole string.
1668 srcIdx = 0;
1669 }
1670 }
1671
1672 destIdx = utext_extract(m->fInputText, srcIdx, m->fInputLength, dest, destCap, status);
1673 }
1674
1675 //
1676 // NUL terminate the output string, if possible, otherwise issue the
1677 // appropriate error or warning.
1678 //
1679 if (destIdx < destCap) {
1680 dest[destIdx] = 0;
1681 } else if (destIdx == destCap) {
1682 *status = U_STRING_NOT_TERMINATED_WARNING;
1683 } else {
1684 *status = U_BUFFER_OVERFLOW_ERROR;
1685 }
1686
1687 //
1688 // Update the user's buffer ptr and capacity vars to reflect the
1689 // amount used.
1690 //
1691 if (destIdx < destCap) {
1692 *destBuf += destIdx;
1693 *destCapacity -= destIdx;
1694 } else if (*destBuf != NULL) {
1695 *destBuf += destCap;
1696 *destCapacity = 0;
1697 }
1698
1699 if (pendingBufferOverflow && U_SUCCESS(*status)) {
1700 *status = U_BUFFER_OVERFLOW_ERROR;
1701 }
1702
1703 return destIdx;
1704 }
1705
1706
1707 //
1708 // appendTail the actual API function
1709 //
1710 U_CAPI int32_t U_EXPORT2
1711 uregex_appendTail(URegularExpression *regexp2,
1712 UChar **destBuf,
1713 int32_t *destCapacity,
1714 UErrorCode *status) {
1715 RegularExpression *regexp = (RegularExpression*)regexp2;
1716 return RegexCImpl::appendTail(regexp, destBuf, destCapacity, status);
1717 }
1718
1719
1720 //
1721 // uregex_appendTailUText...can just use the normal C++ method
1722 //
1723 U_CAPI UText * U_EXPORT2
1724 uregex_appendTailUText(URegularExpression *regexp2,
1725 UText *dest,
1726 UErrorCode *status) {
1727 RegularExpression *regexp = (RegularExpression*)regexp2;
1728 return regexp->fMatcher->appendTail(dest, *status);
1729 }
1730
1731
1732 //------------------------------------------------------------------------------
1733 //
1734 // copyString Internal utility to copy a string to an output buffer,
1735 // while managing buffer overflow and preflight size
1736 // computation. NUL termination is added to destination,
1737 // and the NUL is counted in the output size.
1738 //
1739 //------------------------------------------------------------------------------
1740 #if 0
1741 static void copyString(UChar *destBuffer, // Destination buffer.
1742 int32_t destCapacity, // Total capacity of dest buffer
1743 int32_t *destIndex, // Index into dest buffer. Updated on return.
1744 // Update not clipped to destCapacity.
1745 const UChar *srcPtr, // Pointer to source string
1746 int32_t srcLen) // Source string len.
1747 {
1748 int32_t si;
1749 int32_t di = *destIndex;
1750 UChar c;
1751
1752 for (si=0; si<srcLen; si++) {
1753 c = srcPtr[si];
1754 if (di < destCapacity) {
1755 destBuffer[di] = c;
1756 di++;
1757 } else {
1758 di += srcLen - si;
1759 break;
1760 }
1761 }
1762 if (di<destCapacity) {
1763 destBuffer[di] = 0;
1764 }
1765 di++;
1766 *destIndex = di;
1767 }
1768 #endif
1769
1770 //------------------------------------------------------------------------------
1771 //
1772 // uregex_split
1773 //
1774 //------------------------------------------------------------------------------
1775 int32_t RegexCImpl::split(RegularExpression *regexp,
1776 UChar *destBuf,
1777 int32_t destCapacity,
1778 int32_t *requiredCapacity,
1779 UChar *destFields[],
1780 int32_t destFieldsCapacity,
1781 UErrorCode *status) {
1782 //
1783 // Reset for the input text
1784 //
1785 regexp->fMatcher->reset();
1786 UText *inputText = regexp->fMatcher->fInputText;
1787 int64_t nextOutputStringStart = 0;
1788 int64_t inputLen = regexp->fMatcher->fInputLength;
1789 if (inputLen == 0) {
1790 return 0;
1791 }
1792
1793 //
1794 // Loop through the input text, searching for the delimiter pattern
1795 //
1796 int32_t i; // Index of the field being processed.
1797 int32_t destIdx = 0; // Next available position in destBuf;
1798 int32_t numCaptureGroups = regexp->fMatcher->groupCount();
1799 UErrorCode tStatus = U_ZERO_ERROR; // Want to ignore any buffer overflow errors so that the strings are still counted
1800 for (i=0; ; i++) {
1801 if (i>=destFieldsCapacity-1) {
1802 // There are one or zero output strings left.
1803 // Fill the last output string with whatever is left from the input, then exit the loop.
1804 // ( i will be == destFieldsCapacity if we filled the output array while processing
1805 // capture groups of the delimiter expression, in which case we will discard the
1806 // last capture group saved in favor of the unprocessed remainder of the
1807 // input string.)
1808 if (inputLen > nextOutputStringStart) {
1809 if (i != destFieldsCapacity-1) {
1810 // No fields are left. Recycle the last one for holding the trailing part of
1811 // the input string.
1812 i = destFieldsCapacity-1;
1813 destIdx = (int32_t)(destFields[i] - destFields[0]);
1814 }
1815
1816 destFields[i] = &destBuf[destIdx];
1817 destIdx += 1 + utext_extract(inputText, nextOutputStringStart, inputLen,
1818 &destBuf[destIdx], REMAINING_CAPACITY(destIdx, destCapacity), status);
1819 }
1820 break;
1821 }
1822
1823 if (regexp->fMatcher->find()) {
1824 // We found another delimiter. Move everything from where we started looking
1825 // up until the start of the delimiter into the next output string.
1826 destFields[i] = &destBuf[destIdx];
1827
1828 destIdx += 1 + utext_extract(inputText, nextOutputStringStart, regexp->fMatcher->fMatchStart,
1829 &destBuf[destIdx], REMAINING_CAPACITY(destIdx, destCapacity), &tStatus);
1830 if (tStatus == U_BUFFER_OVERFLOW_ERROR) {
1831 tStatus = U_ZERO_ERROR;
1832 } else {
1833 *status = tStatus;
1834 }
1835 nextOutputStringStart = regexp->fMatcher->fMatchEnd;
1836
1837 // If the delimiter pattern has capturing parentheses, the captured
1838 // text goes out into the next n destination strings.
1839 int32_t groupNum;
1840 for (groupNum=1; groupNum<=numCaptureGroups; groupNum++) {
1841 // If we've run out of output string slots, bail out.
1842 if (i==destFieldsCapacity-1) {
1843 break;
1844 }
1845 i++;
1846
1847 // Set up to extract the capture group contents into the dest buffer.
1848 destFields[i] = &destBuf[destIdx];
1849 tStatus = U_ZERO_ERROR;
1850 int32_t t = uregex_group((URegularExpression*)regexp,
1851 groupNum,
1852 destFields[i],
1853 REMAINING_CAPACITY(destIdx, destCapacity),
1854 &tStatus);
1855 destIdx += t + 1; // Record the space used in the output string buffer.
1856 // +1 for the NUL that terminates the string.
1857 if (tStatus == U_BUFFER_OVERFLOW_ERROR) {
1858 tStatus = U_ZERO_ERROR;
1859 } else {
1860 *status = tStatus;
1861 }
1862 }
1863
1864 if (nextOutputStringStart == inputLen) {
1865 // The delimiter was at the end of the string.
1866 // Output an empty string, and then we are done.
1867 if (destIdx < destCapacity) {
1868 destBuf[destIdx] = 0;
1869 }
1870 if (i < destFieldsCapacity-1) {
1871 ++i;
1872 }
1873 if (destIdx < destCapacity) {
1874 destFields[i] = destBuf + destIdx;
1875 }
1876 ++destIdx;
1877 break;
1878 }
1879
1880 }
1881 else
1882 {
1883 // We ran off the end of the input while looking for the next delimiter.
1884 // All the remaining text goes into the current output string.
1885 destFields[i] = &destBuf[destIdx];
1886 destIdx += 1 + utext_extract(inputText, nextOutputStringStart, inputLen,
1887 &destBuf[destIdx], REMAINING_CAPACITY(destIdx, destCapacity), status);
1888 break;
1889 }
1890 }
1891
1892 // Zero out any unused portion of the destFields array
1893 int j;
1894 for (j=i+1; j<destFieldsCapacity; j++) {
1895 destFields[j] = NULL;
1896 }
1897
1898 if (requiredCapacity != NULL) {
1899 *requiredCapacity = destIdx;
1900 }
1901 if (destIdx > destCapacity) {
1902 *status = U_BUFFER_OVERFLOW_ERROR;
1903 }
1904 return i+1;
1905 }
1906
1907 //
1908 // uregex_split The actual API function
1909 //
1910 U_CAPI int32_t U_EXPORT2
1911 uregex_split(URegularExpression *regexp2,
1912 UChar *destBuf,
1913 int32_t destCapacity,
1914 int32_t *requiredCapacity,
1915 UChar *destFields[],
1916 int32_t destFieldsCapacity,
1917 UErrorCode *status) {
1918 RegularExpression *regexp = (RegularExpression*)regexp2;
1919 if (validateRE(regexp, TRUE, status) == FALSE) {
1920 return 0;
1921 }
1922 if ((destBuf == NULL && destCapacity > 0) ||
1923 destCapacity < 0 ||
1924 destFields == NULL ||
1925 destFieldsCapacity < 1 ) {
1926 *status = U_ILLEGAL_ARGUMENT_ERROR;
1927 return 0;
1928 }
1929
1930 return RegexCImpl::split(regexp, destBuf, destCapacity, requiredCapacity, destFields, destFieldsCapacity, status);
1931 }
1932
1933
1934 //
1935 // uregex_splitUText...can just use the normal C++ method
1936 //
1937 U_CAPI int32_t U_EXPORT2
1938 uregex_splitUText(URegularExpression *regexp2,
1939 UText *destFields[],
1940 int32_t destFieldsCapacity,
1941 UErrorCode *status) {
1942 RegularExpression *regexp = (RegularExpression*)regexp2;
1943 return regexp->fMatcher->split(regexp->fMatcher->inputText(), destFields, destFieldsCapacity, *status);
1944 }
1945
1946
1947 #endif // !UCONFIG_NO_REGULAR_EXPRESSIONS
1948

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial