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