source/i18n/uregex.cpp

   1 // Copyright (C) 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
  30 U_NAMESPACE_BEGIN
  31
  32 #define REMAINING_CAPACITY(idx,len) ((((len)-(idx))>0)?((len)-(idx)):0)
  33
  34 struct RegularExpression: public UMemory {
  35 public:
  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
  50 static const int32_t REXP_MAGIC = 0x72657870; // "rexp" in ASCII
  51
  52 RegularExpression::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
  64 RegularExpression::~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
  78 U_NAMESPACE_END
  79
  80 U_NAMESPACE_USE
  81
  82 //----------------------------------------------------------------------------------------
  83 //
  84 //   validateRE    Do boilerplate style checks on API function parameters.
  85 //                 Return TRUE if they look OK.
  86 //----------------------------------------------------------------------------------------
  87 static 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 //----------------------------------------------------------------------------------------
 108 U_CAPI URegularExpression *  U_EXPORT2
 109 uregex_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
 175 ErrorExit:
 176     delete re;
 177     return NULL;
 178
 179 }
 180
 181 //----------------------------------------------------------------------------------------
 182 //
 183 //    uregex_openUText
 184 //
 185 //----------------------------------------------------------------------------------------
 186 U_CAPI URegularExpression *  U_EXPORT2
 187 uregex_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
 258 ErrorExit:
 259     delete re;
 260     return NULL;
 261
 262 }
 263
 264 //----------------------------------------------------------------------------------------
 265 //
 266 //    uregex_close
 267 //
 268 //----------------------------------------------------------------------------------------
 269 U_CAPI void  U_EXPORT2
 270 uregex_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 //----------------------------------------------------------------------------------------
 285 U_CAPI URegularExpression * U_EXPORT2
 286 uregex_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 //------------------------------------------------------------------------------
 322 U_CAPI const UChar * U_EXPORT2
 323 uregex_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 //------------------------------------------------------------------------------
 343 U_CAPI UText * U_EXPORT2
 344 uregex_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 //------------------------------------------------------------------------------
 356 U_CAPI int32_t U_EXPORT2
 357 uregex_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 //------------------------------------------------------------------------------
 372 U_CAPI void U_EXPORT2
 373 uregex_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 //------------------------------------------------------------------------------
 406 U_CAPI void U_EXPORT2
 407 uregex_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 //------------------------------------------------------------------------------
 436 U_CAPI const UChar * U_EXPORT2
 437 uregex_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 //------------------------------------------------------------------------------
 476 U_CAPI UText * U_EXPORT2
 477 uregex_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 //------------------------------------------------------------------------------
 493 U_CAPI void U_EXPORT2
 494 uregex_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 //------------------------------------------------------------------------------
 510 U_CAPI UBool U_EXPORT2
 511 uregex_matches(URegularExpression *regexp2,
 512                int32_t            startIndex,
 513                UErrorCode        *status)  {
 514     return uregex_matches64( regexp2, (int64_t)startIndex, status);
 515 }
 516
 517 U_CAPI UBool U_EXPORT2
 518 uregex_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 //------------------------------------------------------------------------------
 540 U_CAPI UBool U_EXPORT2
 541 uregex_lookingAt(URegularExpression *regexp2,
 542                  int32_t             startIndex,
 543                  UErrorCode         *status)  {
 544     return uregex_lookingAt64( regexp2, (int64_t)startIndex, status);
 545 }
 546
 547 U_CAPI UBool U_EXPORT2
 548 uregex_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 //------------------------------------------------------------------------------
 571 U_CAPI UBool U_EXPORT2
 572 uregex_find(URegularExpression *regexp2,
 573             int32_t             startIndex,
 574             UErrorCode         *status)  {
 575     return uregex_find64( regexp2, (int64_t)startIndex, status);
 576 }
 577
 578 U_CAPI UBool U_EXPORT2
 579 uregex_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 //------------------------------------------------------------------------------
 602 U_CAPI UBool U_EXPORT2
 603 uregex_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 //------------------------------------------------------------------------------
 618 U_CAPI int32_t U_EXPORT2
 619 uregex_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 //------------------------------------------------------------------------------
 635 int32_t
 636 uregex_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
 648 int32_t
 649 uregex_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 //------------------------------------------------------------------------------
 665 U_CAPI int32_t U_EXPORT2
 666 uregex_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 //------------------------------------------------------------------------------
 735 U_CAPI UText * U_EXPORT2
 736 uregex_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 //------------------------------------------------------------------------------
 755 U_CAPI int32_t U_EXPORT2
 756 uregex_start(URegularExpression *regexp2,
 757              int32_t             groupNum,
 758              UErrorCode          *status)  {
 759     return (int32_t)uregex_start64( regexp2, groupNum, status);
 760 }
 761
 762 U_CAPI int64_t U_EXPORT2
 763 uregex_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     int32_t result = regexp->fMatcher->start(groupNum, *status);
 771     return result;
 772 }
 773
 774 //------------------------------------------------------------------------------
 775 //
 776 //    uregex_end
 777 //
 778 //------------------------------------------------------------------------------
 779 U_CAPI int32_t U_EXPORT2
 780 uregex_end(URegularExpression   *regexp2,
 781            int32_t               groupNum,
 782            UErrorCode           *status)  {
 783     return (int32_t)uregex_end64( regexp2, groupNum, status);
 784 }
 785
 786 U_CAPI int64_t U_EXPORT2
 787 uregex_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     int32_t result = regexp->fMatcher->end(groupNum, *status);
 795     return result;
 796 }
 797
 798 //------------------------------------------------------------------------------
 799 //
 800 //    uregex_reset
 801 //
 802 //------------------------------------------------------------------------------
 803 U_CAPI void U_EXPORT2
 804 uregex_reset(URegularExpression    *regexp2,
 805              int32_t               index,
 806              UErrorCode            *status)  {
 807     uregex_reset64( regexp2, (int64_t)index, status);
 808 }
 809
 810 U_CAPI void U_EXPORT2
 811 uregex_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 //------------------------------------------------------------------------------
 827 U_CAPI void U_EXPORT2
 828 uregex_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
 835 U_CAPI void U_EXPORT2
 836 uregex_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 //------------------------------------------------------------------------------
 853 U_CAPI void U_EXPORT2
 854 uregex_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 //------------------------------------------------------------------------------
 871 U_CAPI int32_t U_EXPORT2
 872 uregex_regionStart(const  URegularExpression   *regexp2,
 873                           UErrorCode           *status)  {
 874     return (int32_t)uregex_regionStart64(regexp2, status);
 875 }
 876
 877 U_CAPI int64_t U_EXPORT2
 878 uregex_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 //------------------------------------------------------------------------------
 893 U_CAPI int32_t U_EXPORT2
 894 uregex_regionEnd(const  URegularExpression   *regexp2,
 895                         UErrorCode           *status)  {
 896     return (int32_t)uregex_regionEnd64(regexp2, status);
 897 }
 898
 899 U_CAPI int64_t U_EXPORT2
 900 uregex_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 //------------------------------------------------------------------------------
 915 U_CAPI UBool U_EXPORT2
 916 uregex_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 //------------------------------------------------------------------------------
 931 U_CAPI void U_EXPORT2
 932 uregex_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 //------------------------------------------------------------------------------
 948 U_CAPI UBool U_EXPORT2
 949 uregex_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 //------------------------------------------------------------------------------
 964 U_CAPI void U_EXPORT2
 965 uregex_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 //------------------------------------------------------------------------------
 981 U_CAPI UBool U_EXPORT2
 982 uregex_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 //------------------------------------------------------------------------------
 997 U_CAPI UBool U_EXPORT2
 998 uregex_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 //------------------------------------------------------------------------------
1013 U_CAPI void U_EXPORT2
1014 uregex_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 //------------------------------------------------------------------------------
1030 U_CAPI int32_t U_EXPORT2
1031 uregex_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 //------------------------------------------------------------------------------
1048 U_CAPI void U_EXPORT2
1049 uregex_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 //------------------------------------------------------------------------------
1065 U_CAPI int32_t U_EXPORT2
1066 uregex_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 //------------------------------------------------------------------------------
1082 U_CAPI void U_EXPORT2
1083 uregex_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 //------------------------------------------------------------------------------
1099 U_CAPI void U_EXPORT2
1100 uregex_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 //------------------------------------------------------------------------------
1116 U_CAPI void U_EXPORT2
1117 uregex_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 //------------------------------------------------------------------------------
1133 U_CAPI void U_EXPORT2
1134 uregex_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 //------------------------------------------------------------------------------
1150 U_CAPI int32_t U_EXPORT2
1151 uregex_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 //------------------------------------------------------------------------------
1200 U_CAPI UText * U_EXPORT2
1201 uregex_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 //------------------------------------------------------------------------------
1224 U_CAPI int32_t U_EXPORT2
1225 uregex_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 //------------------------------------------------------------------------------
1261 U_CAPI UText * U_EXPORT2
1262 uregex_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
1286 U_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 //
1291 class 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
1314 U_NAMESPACE_END
1315
1316
1317
1318 static const UChar BACKSLASH  = 0x5c;
1319 static const UChar DOLLARSIGN = 0x24;
1320 static const UChar LEFTBRACKET = 0x7b;
1321 static 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 //
1328 static 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 //
1339 int32_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;
1469         U16_GET(replacementText, 0, replIdx, replacementLength, c32);
1470         if (u_isdigit(c32)) {
1471             int32_t numDigits = 0;
1472             int32_t numCaptureGroups = m->fPattern->fGroupMap->size();
1473             for (;;) {
1474                 if (replIdx >= replacementLength) {
1475                     break;
1476                 }
1477                 U16_GET(replacementText, 0, replIdx, replacementLength, c32);
1478                 if (u_isdigit(c32) == FALSE) {
1479                     break;
1480                 }
1481
1482                 int32_t digitVal = u_charDigitValue(c32);
1483                 if (groupNum * 10 + digitVal <= numCaptureGroups) {
1484                     groupNum = groupNum * 10 + digitVal;
1485                     U16_FWD_1(replacementText, replIdx, replacementLength);
1486                     numDigits++;
1487                 } else {
1488                     if (numDigits == 0) {
1489                         *status = U_INDEX_OUTOFBOUNDS_ERROR;
1490                     }
1491                     break;
1492                 }
1493             }
1494         } else if (c32 == LEFTBRACKET) {
1495             // Scan for Named Capture Group, ${name}.
1496             UnicodeString groupName;
1497             U16_FWD_1(replacementText, replIdx, replacementLength);
1498             while (U_SUCCESS(*status) && c32 != RIGHTBRACKET) {
1499                 if (replIdx >= replacementLength) {
1500                     *status = U_REGEX_INVALID_CAPTURE_GROUP_NAME;
1501                     break;
1502                 }
1503                 U16_NEXT(replacementText, replIdx, replacementLength, c32);
1504                 if ((c32 >= 0x41 && c32 <= 0x5a) ||           // A..Z
1505                         (c32 >= 0x61 && c32 <= 0x7a) ||       // a..z
1506                         (c32 >= 0x31 && c32 <= 0x39)) {       // 0..9
1507                     groupName.append(c32);
1508                 } else if (c32 == RIGHTBRACKET) {
1509                     groupNum = uhash_geti(regexp->fPat->fNamedCaptureMap, &groupName);
1510                     if (groupNum == 0) {
1511                         // Name not defined by pattern.
1512                         *status = U_REGEX_INVALID_CAPTURE_GROUP_NAME;
1513                     }
1514                 } else {
1515                     // Character was something other than a name char or a closing '}'
1516                     *status = U_REGEX_INVALID_CAPTURE_GROUP_NAME;
1517                 }
1518             }
1519         } else {
1520             // $ not followed by {name} or digits.
1521             *status = U_REGEX_INVALID_CAPTURE_GROUP_NAME;
1522         }
1523
1524
1525         // Finally, append the capture group data to the destination.
1526         if (U_SUCCESS(*status)) {
1527             destIdx += uregex_group((URegularExpression*)regexp, groupNum,
1528                                     dest==NULL?NULL:&dest[destIdx], REMAINING_CAPACITY(destIdx, capacity), status);
1529             if (*status == U_BUFFER_OVERFLOW_ERROR) {
1530                 // Ignore buffer overflow when extracting the group.  We need to
1531                 //   continue on to get full size of the untruncated result.  We will
1532                 //   raise our own buffer overflow error at the end.
1533                 *status = U_ZERO_ERROR;
1534             }
1535         }
1536
1537         if (U_FAILURE(*status)) {
1538             // bad group number or name.
1539             break;
1540         }
1541     }
1542
1543     //
1544     //  Nul Terminate the dest buffer if possible.
1545     //  Set the appropriate buffer overflow or not terminated error, if needed.
1546     //
1547     if (destIdx < capacity) {
1548         dest[destIdx] = 0;
1549     } else if (U_SUCCESS(*status)) {
1550         if (destIdx == *destCapacity) {
1551             *status = U_STRING_NOT_TERMINATED_WARNING;
1552         } else {
1553             *status = U_BUFFER_OVERFLOW_ERROR;
1554         }
1555     }
1556
1557     //
1558     // Return an updated dest buffer and capacity to the caller.
1559     //
1560     if (destIdx > 0 &&  *destCapacity > 0) {
1561         if (destIdx < capacity) {
1562             *destBuf      += destIdx;
1563             *destCapacity -= destIdx;
1564         } else {
1565             *destBuf      += capacity;
1566             *destCapacity =  0;
1567         }
1568     }
1569
1570     // If we came in with a buffer overflow, make sure we go out with one also.
1571     //   (A zero length match right at the end of the previous match could
1572     //    make this function succeed even though a previous call had overflowed the buf)
1573     if (pendingBufferOverflow && U_SUCCESS(*status)) {
1574         *status = U_BUFFER_OVERFLOW_ERROR;
1575     }
1576
1577     return destIdx;
1578 }
1579
1580 //
1581 //   appendReplacement   the actual API function,
1582 //
1583 U_CAPI int32_t U_EXPORT2
1584 uregex_appendReplacement(URegularExpression    *regexp2,
1585                          const UChar           *replacementText,
1586                          int32_t                replacementLength,
1587                          UChar                **destBuf,
1588                          int32_t               *destCapacity,
1589                          UErrorCode            *status) {
1590
1591     RegularExpression *regexp = (RegularExpression*)regexp2;
1592     return RegexCImpl::appendReplacement(
1593         regexp, replacementText, replacementLength,destBuf, destCapacity, status);
1594 }
1595
1596 //
1597 //   uregex_appendReplacementUText...can just use the normal C++ method
1598 //
1599 U_CAPI void U_EXPORT2
1600 uregex_appendReplacementUText(URegularExpression    *regexp2,
1601                               UText                 *replText,
1602                               UText                 *dest,
1603                               UErrorCode            *status)  {
1604     RegularExpression *regexp = (RegularExpression*)regexp2;
1605     regexp->fMatcher->appendReplacement(dest, replText, *status);
1606 }
1607
1608
1609 //------------------------------------------------------------------------------
1610 //
1611 //    uregex_appendTail
1612 //
1613 //------------------------------------------------------------------------------
1614 int32_t RegexCImpl::appendTail(RegularExpression    *regexp,
1615                                UChar                **destBuf,
1616                                int32_t               *destCapacity,
1617                                UErrorCode            *status)
1618 {
1619
1620     // If we come in with a buffer overflow error, don't suppress the operation.
1621     //  A series of appendReplacements, appendTail need to correctly preflight
1622     //  the buffer size when an overflow happens somewhere in the middle.
1623     UBool pendingBufferOverflow = FALSE;
1624     if (*status == U_BUFFER_OVERFLOW_ERROR && destCapacity != NULL && *destCapacity == 0) {
1625         pendingBufferOverflow = TRUE;
1626         *status = U_ZERO_ERROR;
1627     }
1628
1629     if (validateRE(regexp, TRUE, status) == FALSE) {
1630         return 0;
1631     }
1632
1633     if (destCapacity == NULL || destBuf == NULL ||
1634         (*destBuf == NULL && *destCapacity > 0) ||
1635         *destCapacity < 0)
1636     {
1637         *status = U_ILLEGAL_ARGUMENT_ERROR;
1638         return 0;
1639     }
1640
1641     RegexMatcher *m = regexp->fMatcher;
1642
1643     int32_t  destIdx     = 0;
1644     int32_t  destCap     = *destCapacity;
1645     UChar    *dest       = *destBuf;
1646
1647     if (regexp->fText != NULL) {
1648         int32_t srcIdx;
1649         int64_t nativeIdx = (m->fMatch ? m->fMatchEnd : m->fLastMatchEnd);
1650         if (nativeIdx == -1) {
1651             srcIdx = 0;
1652         } else if (UTEXT_USES_U16(m->fInputText)) {
1653             srcIdx = (int32_t)nativeIdx;
1654         } else {
1655             UErrorCode status = U_ZERO_ERROR;
1656             srcIdx = utext_extract(m->fInputText, 0, nativeIdx, NULL, 0, &status);
1657         }
1658
1659         for (;;) {
1660             U_ASSERT(destIdx >= 0);
1661
1662             if (srcIdx == regexp->fTextLength) {
1663                 break;
1664             }
1665             UChar c = regexp->fText[srcIdx];
1666             if (c == 0 && regexp->fTextLength == -1) {
1667                 regexp->fTextLength = srcIdx;
1668                 break;
1669             }
1670
1671             if (destIdx < destCap) {
1672                 dest[destIdx] = c;
1673             } else {
1674                 // We've overflowed the dest buffer.
1675                 //  If the total input string length is known, we can
1676                 //    compute the total buffer size needed without scanning through the string.
1677                 if (regexp->fTextLength > 0) {
1678                     destIdx += (regexp->fTextLength - srcIdx);
1679                     break;
1680                 }
1681             }
1682             srcIdx++;
1683             destIdx++;
1684         }
1685     } else {
1686         int64_t  srcIdx;
1687         if (m->fMatch) {
1688             // The most recent call to find() succeeded.
1689             srcIdx = m->fMatchEnd;
1690         } else {
1691             // The last call to find() on this matcher failed().
1692             //   Look back to the end of the last find() that succeeded for src index.
1693             srcIdx = m->fLastMatchEnd;
1694             if (srcIdx == -1)  {
1695                 // There has been no successful match with this matcher.
1696                 //   We want to copy the whole string.
1697                 srcIdx = 0;
1698             }
1699         }
1700
1701         destIdx = utext_extract(m->fInputText, srcIdx, m->fInputLength, dest, destCap, status);
1702     }
1703
1704     //
1705     //  NUL terminate the output string, if possible, otherwise issue the
1706     //   appropriate error or warning.
1707     //
1708     if (destIdx < destCap) {
1709         dest[destIdx] = 0;
1710     } else  if (destIdx == destCap) {
1711         *status = U_STRING_NOT_TERMINATED_WARNING;
1712     } else {
1713         *status = U_BUFFER_OVERFLOW_ERROR;
1714     }
1715
1716     //
1717     // Update the user's buffer ptr and capacity vars to reflect the
1718     //   amount used.
1719     //
1720     if (destIdx < destCap) {
1721         *destBuf      += destIdx;
1722         *destCapacity -= destIdx;
1723     } else if (*destBuf != NULL) {
1724         *destBuf      += destCap;
1725         *destCapacity  = 0;
1726     }
1727
1728     if (pendingBufferOverflow && U_SUCCESS(*status)) {
1729         *status = U_BUFFER_OVERFLOW_ERROR;
1730     }
1731
1732     return destIdx;
1733 }
1734
1735
1736 //
1737 //   appendTail   the actual API function
1738 //
1739 U_CAPI int32_t U_EXPORT2
1740 uregex_appendTail(URegularExpression    *regexp2,
1741                   UChar                **destBuf,
1742                   int32_t               *destCapacity,
1743                   UErrorCode            *status)  {
1744     RegularExpression *regexp = (RegularExpression*)regexp2;
1745     return RegexCImpl::appendTail(regexp, destBuf, destCapacity, status);
1746 }
1747
1748
1749 //
1750 //   uregex_appendTailUText...can just use the normal C++ method
1751 //
1752 U_CAPI UText * U_EXPORT2
1753 uregex_appendTailUText(URegularExpression    *regexp2,
1754                        UText                 *dest,
1755                        UErrorCode            *status)  {
1756     RegularExpression *regexp = (RegularExpression*)regexp2;
1757     return regexp->fMatcher->appendTail(dest, *status);
1758 }
1759
1760
1761 //------------------------------------------------------------------------------
1762 //
1763 //    copyString     Internal utility to copy a string to an output buffer,
1764 //                   while managing buffer overflow and preflight size
1765 //                   computation.  NUL termination is added to destination,
1766 //                   and the NUL is counted in the output size.
1767 //
1768 //------------------------------------------------------------------------------
1769 #if 0
1770 static void copyString(UChar        *destBuffer,    //  Destination buffer.
1771                        int32_t       destCapacity,  //  Total capacity of dest buffer
1772                        int32_t      *destIndex,     //  Index into dest buffer.  Updated on return.
1773                                                     //    Update not clipped to destCapacity.
1774                        const UChar  *srcPtr,        //  Pointer to source string
1775                        int32_t       srcLen)        //  Source string len.
1776 {
1777     int32_t  si;
1778     int32_t  di = *destIndex;
1779     UChar    c;
1780
1781     for (si=0; si<srcLen;  si++) {
1782         c = srcPtr[si];
1783         if (di < destCapacity) {
1784             destBuffer[di] = c;
1785             di++;
1786         } else {
1787             di += srcLen - si;
1788             break;
1789         }
1790     }
1791     if (di<destCapacity) {
1792         destBuffer[di] = 0;
1793     }
1794     di++;
1795     *destIndex = di;
1796 }
1797 #endif
1798
1799 //------------------------------------------------------------------------------
1800 //
1801 //    uregex_split
1802 //
1803 //------------------------------------------------------------------------------
1804 int32_t RegexCImpl::split(RegularExpression     *regexp,
1805                           UChar                 *destBuf,
1806                           int32_t                destCapacity,
1807                           int32_t               *requiredCapacity,
1808                           UChar                 *destFields[],
1809                           int32_t                destFieldsCapacity,
1810                           UErrorCode            *status) {
1811     //
1812     // Reset for the input text
1813     //
1814     regexp->fMatcher->reset();
1815     UText *inputText = regexp->fMatcher->fInputText;
1816     int64_t   nextOutputStringStart = 0;
1817     int64_t   inputLen = regexp->fMatcher->fInputLength;
1818     if (inputLen == 0) {
1819         return 0;
1820     }
1821
1822     //
1823     // Loop through the input text, searching for the delimiter pattern
1824     //
1825     int32_t   i;             // Index of the field being processed.
1826     int32_t   destIdx = 0;   // Next available position in destBuf;
1827     int32_t   numCaptureGroups = regexp->fMatcher->groupCount();
1828     UErrorCode  tStatus = U_ZERO_ERROR;   // Want to ignore any buffer overflow errors so that the strings are still counted
1829     for (i=0; ; i++) {
1830         if (i>=destFieldsCapacity-1) {
1831             // There are one or zero output strings left.
1832             // Fill the last output string with whatever is left from the input, then exit the loop.
1833             //  ( i will be == destFieldsCapacity if we filled the output array while processing
1834             //    capture groups of the delimiter expression, in which case we will discard the
1835             //    last capture group saved in favor of the unprocessed remainder of the
1836             //    input string.)
1837             if (inputLen > nextOutputStringStart) {
1838                 if (i != destFieldsCapacity-1) {
1839                     // No fields are left.  Recycle the last one for holding the trailing part of
1840                     //   the input string.
1841                     i = destFieldsCapacity-1;
1842                     destIdx = (int32_t)(destFields[i] - destFields[0]);
1843                 }
1844
1845                 destFields[i] = &destBuf[destIdx];
1846                 destIdx += 1 + utext_extract(inputText, nextOutputStringStart, inputLen,
1847                                              &destBuf[destIdx], REMAINING_CAPACITY(destIdx, destCapacity), status);
1848             }
1849             break;
1850         }
1851
1852         if (regexp->fMatcher->find()) {
1853             // We found another delimiter.  Move everything from where we started looking
1854             //  up until the start of the delimiter into the next output string.
1855             destFields[i] = &destBuf[destIdx];
1856
1857             destIdx += 1 + utext_extract(inputText, nextOutputStringStart, regexp->fMatcher->fMatchStart,
1858                                          &destBuf[destIdx], REMAINING_CAPACITY(destIdx, destCapacity), &tStatus);
1859             if (tStatus == U_BUFFER_OVERFLOW_ERROR) {
1860                 tStatus = U_ZERO_ERROR;
1861             } else {
1862                 *status = tStatus;
1863             }
1864             nextOutputStringStart = regexp->fMatcher->fMatchEnd;
1865
1866             // If the delimiter pattern has capturing parentheses, the captured
1867             //  text goes out into the next n destination strings.
1868             int32_t groupNum;
1869             for (groupNum=1; groupNum<=numCaptureGroups; groupNum++) {
1870                 // If we've run out of output string slots, bail out.
1871                 if (i==destFieldsCapacity-1) {
1872                     break;
1873                 }
1874                 i++;
1875
1876                 // Set up to extract the capture group contents into the dest buffer.
1877                 destFields[i] = &destBuf[destIdx];
1878                 tStatus = U_ZERO_ERROR;
1879                 int32_t t = uregex_group((URegularExpression*)regexp,
1880                                          groupNum,
1881                                          destFields[i],
1882                                          REMAINING_CAPACITY(destIdx, destCapacity),
1883                                          &tStatus);
1884                 destIdx += t + 1;    // Record the space used in the output string buffer.
1885                                      //  +1 for the NUL that terminates the string.
1886                 if (tStatus == U_BUFFER_OVERFLOW_ERROR) {
1887                     tStatus = U_ZERO_ERROR;
1888                 } else {
1889                     *status = tStatus;
1890                 }
1891             }
1892
1893             if (nextOutputStringStart == inputLen) {
1894                 // The delimiter was at the end of the string.
1895                 // Output an empty string, and then we are done.
1896                 if (destIdx < destCapacity) {
1897                     destBuf[destIdx] = 0;
1898                 }
1899                 if (i < destFieldsCapacity-1) {
1900                    ++i;
1901                 }
1902                 if (destIdx < destCapacity) {
1903                     destFields[i] = destBuf + destIdx;
1904                 }
1905                 ++destIdx;
1906                 break;
1907             }
1908
1909         }
1910         else
1911         {
1912             // We ran off the end of the input while looking for the next delimiter.
1913             // All the remaining text goes into the current output string.
1914             destFields[i] = &destBuf[destIdx];
1915             destIdx += 1 + utext_extract(inputText, nextOutputStringStart, inputLen,
1916                                          &destBuf[destIdx], REMAINING_CAPACITY(destIdx, destCapacity), status);
1917             break;
1918         }
1919     }
1920
1921     // Zero out any unused portion of the destFields array
1922     int j;
1923     for (j=i+1; j<destFieldsCapacity; j++) {
1924         destFields[j] = NULL;
1925     }
1926
1927     if (requiredCapacity != NULL) {
1928         *requiredCapacity = destIdx;
1929     }
1930     if (destIdx > destCapacity) {
1931         *status = U_BUFFER_OVERFLOW_ERROR;
1932     }
1933     return i+1;
1934 }
1935
1936 //
1937 //   uregex_split   The actual API function
1938 //
1939 U_CAPI int32_t U_EXPORT2
1940 uregex_split(URegularExpression      *regexp2,
1941              UChar                   *destBuf,
1942              int32_t                  destCapacity,
1943              int32_t                 *requiredCapacity,
1944              UChar                   *destFields[],
1945              int32_t                  destFieldsCapacity,
1946              UErrorCode              *status) {
1947     RegularExpression *regexp = (RegularExpression*)regexp2;
1948     if (validateRE(regexp, TRUE, status) == FALSE) {
1949         return 0;
1950     }
1951     if ((destBuf == NULL && destCapacity > 0) ||
1952         destCapacity < 0 ||
1953         destFields == NULL ||
1954         destFieldsCapacity < 1 ) {
1955         *status = U_ILLEGAL_ARGUMENT_ERROR;
1956         return 0;
1957     }
1958
1959     return RegexCImpl::split(regexp, destBuf, destCapacity, requiredCapacity, destFields, destFieldsCapacity, status);
1960 }
1961
1962
1963 //
1964 //   uregex_splitUText...can just use the normal C++ method
1965 //
1966 U_CAPI int32_t U_EXPORT2
1967 uregex_splitUText(URegularExpression    *regexp2,
1968                   UText                 *destFields[],
1969                   int32_t                destFieldsCapacity,
1970                   UErrorCode            *status) {
1971     RegularExpression *regexp = (RegularExpression*)regexp2;
1972     return regexp->fMatcher->split(regexp->fMatcher->inputText(), destFields, destFieldsCapacity, *status);
1973 }
1974
1975
1976 #endif   // !UCONFIG_NO_REGULAR_EXPRESSIONS
1977