1 /************************************************* 2 * Perl-Compatible Regular Expressions * 3 *************************************************/ 4 5 /* PCRE is a library of functions to support regular expressions whose syntax 6 and semantics are as close as possible to those of the Perl 5 language. 7 8 Written by Philip Hazel 9 Original API code Copyright (c) 1997-2012 University of Cambridge 10 New API code Copyright (c) 2016-2018 University of Cambridge 11 12 ----------------------------------------------------------------------------- 13 Redistribution and use in source and binary forms, with or without 14 modification, are permitted provided that the following conditions are met: 15 16 * Redistributions of source code must retain the above copyright notice, 17 this list of conditions and the following disclaimer. 18 19 * Redistributions in binary form must reproduce the above copyright 20 notice, this list of conditions and the following disclaimer in the 21 documentation and/or other materials provided with the distribution. 22 23 * Neither the name of the University of Cambridge nor the names of its 24 contributors may be used to endorse or promote products derived from 25 this software without specific prior written permission. 26 27 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 28 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 29 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 30 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 31 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 32 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 33 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 34 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 35 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 36 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 37 POSSIBILITY OF SUCH DAMAGE. 38 ----------------------------------------------------------------------------- 39 */ 40 41 42 #ifdef HAVE_CONFIG_H 43 #include "config.h" 44 #endif 45 46 #include "pcre2_internal.h" 47 48 #define PTR_STACK_SIZE 20 49 50 #define SUBSTITUTE_OPTIONS \ 51 (PCRE2_SUBSTITUTE_EXTENDED|PCRE2_SUBSTITUTE_GLOBAL| \ 52 PCRE2_SUBSTITUTE_OVERFLOW_LENGTH|PCRE2_SUBSTITUTE_UNKNOWN_UNSET| \ 53 PCRE2_SUBSTITUTE_UNSET_EMPTY) 54 55 56 57 /************************************************* 58 * Find end of substitute text * 59 *************************************************/ 60 61 /* In extended mode, we recognize ${name:+set text:unset text} and similar 62 constructions. This requires the identification of unescaped : and } 63 characters. This function scans for such. It must deal with nested ${ 64 constructions. The pointer to the text is updated, either to the required end 65 character, or to where an error was detected. 66 67 Arguments: 68 code points to the compiled expression (for options) 69 ptrptr points to the pointer to the start of the text (updated) 70 ptrend end of the whole string 71 last TRUE if the last expected string (only } recognized) 72 73 Returns: 0 on success 74 negative error code on failure 75 */ 76 77 static int 78 find_text_end(const pcre2_code *code, PCRE2_SPTR *ptrptr, PCRE2_SPTR ptrend, 79 BOOL last) 80 { 81 int rc = 0; 82 uint32_t nestlevel = 0; 83 BOOL literal = FALSE; 84 PCRE2_SPTR ptr = *ptrptr; 85 86 for (; ptr < ptrend; ptr++) 87 { 88 if (literal) 89 { 90 if (ptr[0] == CHAR_BACKSLASH && ptr < ptrend - 1 && ptr[1] == CHAR_E) 91 { 92 literal = FALSE; 93 ptr += 1; 94 } 95 } 96 97 else if (*ptr == CHAR_RIGHT_CURLY_BRACKET) 98 { 99 if (nestlevel == 0) goto EXIT; 100 nestlevel--; 101 } 102 103 else if (*ptr == CHAR_COLON && !last && nestlevel == 0) goto EXIT; 104 105 else if (*ptr == CHAR_DOLLAR_SIGN) 106 { 107 if (ptr < ptrend - 1 && ptr[1] == CHAR_LEFT_CURLY_BRACKET) 108 { 109 nestlevel++; 110 ptr += 1; 111 } 112 } 113 114 else if (*ptr == CHAR_BACKSLASH) 115 { 116 int erc; 117 int errorcode; 118 uint32_t ch; 119 120 if (ptr < ptrend - 1) switch (ptr[1]) 121 { 122 case CHAR_L: 123 case CHAR_l: 124 case CHAR_U: 125 case CHAR_u: 126 ptr += 1; 127 continue; 128 } 129 130 ptr += 1; /* Must point after \ */ 131 erc = PRIV(check_escape)(&ptr, ptrend, &ch, &errorcode, 132 code->overall_options, FALSE, NULL); 133 ptr -= 1; /* Back to last code unit of escape */ 134 if (errorcode != 0) 135 { 136 rc = errorcode; 137 goto EXIT; 138 } 139 140 switch(erc) 141 { 142 case 0: /* Data character */ 143 case ESC_E: /* Isolated \E is ignored */ 144 break; 145 146 case ESC_Q: 147 literal = TRUE; 148 break; 149 150 default: 151 rc = PCRE2_ERROR_BADREPESCAPE; 152 goto EXIT; 153 } 154 } 155 } 156 157 rc = PCRE2_ERROR_REPMISSINGBRACE; /* Terminator not found */ 158 159 EXIT: 160 *ptrptr = ptr; 161 return rc; 162 } 163 164 165 166 /************************************************* 167 * Match and substitute * 168 *************************************************/ 169 170 /* This function applies a compiled re to a subject string and creates a new 171 string with substitutions. The first 7 arguments are the same as for 172 pcre2_match(). Either string length may be PCRE2_ZERO_TERMINATED. 173 174 Arguments: 175 code points to the compiled expression 176 subject points to the subject string 177 length length of subject string (may contain binary zeros) 178 start_offset where to start in the subject string 179 options option bits 180 match_data points to a match_data block, or is NULL 181 context points a PCRE2 context 182 replacement points to the replacement string 183 rlength length of replacement string 184 buffer where to put the substituted string 185 blength points to length of buffer; updated to length of string 186 187 Returns: >= 0 number of substitutions made 188 < 0 an error code 189 PCRE2_ERROR_BADREPLACEMENT means invalid use of $ 190 */ 191 192 /* This macro checks for space in the buffer before copying into it. On 193 overflow, either give an error immediately, or keep on, accumulating the 194 length. */ 195 196 #define CHECKMEMCPY(from,length) \ 197 if (!overflowed && lengthleft < length) \ 198 { \ 199 if ((suboptions & PCRE2_SUBSTITUTE_OVERFLOW_LENGTH) == 0) goto NOROOM; \ 200 overflowed = TRUE; \ 201 extra_needed = length - lengthleft; \ 202 } \ 203 else if (overflowed) \ 204 { \ 205 extra_needed += length; \ 206 } \ 207 else \ 208 { \ 209 memcpy(buffer + buff_offset, from, CU2BYTES(length)); \ 210 buff_offset += length; \ 211 lengthleft -= length; \ 212 } 213 214 /* Here's the function */ 215 216 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION 217 pcre2_substitute(const pcre2_code *code, PCRE2_SPTR subject, PCRE2_SIZE length, 218 PCRE2_SIZE start_offset, uint32_t options, pcre2_match_data *match_data, 219 pcre2_match_context *mcontext, PCRE2_SPTR replacement, PCRE2_SIZE rlength, 220 PCRE2_UCHAR *buffer, PCRE2_SIZE *blength) 221 { 222 int rc; 223 int subs; 224 int forcecase = 0; 225 int forcecasereset = 0; 226 uint32_t ovector_count; 227 uint32_t goptions = 0; 228 uint32_t suboptions; 229 BOOL match_data_created = FALSE; 230 BOOL literal = FALSE; 231 BOOL overflowed = FALSE; 232 #ifdef SUPPORT_UNICODE 233 BOOL utf = (code->overall_options & PCRE2_UTF) != 0; 234 #endif 235 PCRE2_UCHAR temp[6]; 236 PCRE2_SPTR ptr; 237 PCRE2_SPTR repend; 238 PCRE2_SIZE extra_needed = 0; 239 PCRE2_SIZE buff_offset, buff_length, lengthleft, fraglength; 240 PCRE2_SIZE *ovector; 241 PCRE2_SIZE ovecsave[3]; 242 243 buff_offset = 0; 244 lengthleft = buff_length = *blength; 245 *blength = PCRE2_UNSET; 246 ovecsave[0] = ovecsave[1] = ovecsave[2] = PCRE2_UNSET; 247 248 /* Partial matching is not valid. */ 249 250 if ((options & (PCRE2_PARTIAL_HARD|PCRE2_PARTIAL_SOFT)) != 0) 251 return PCRE2_ERROR_BADOPTION; 252 253 /* If no match data block is provided, create one. */ 254 255 if (match_data == NULL) 256 { 257 pcre2_general_context *gcontext = (mcontext == NULL)? 258 (pcre2_general_context *)code : 259 (pcre2_general_context *)mcontext; 260 match_data = pcre2_match_data_create_from_pattern(code, gcontext); 261 if (match_data == NULL) return PCRE2_ERROR_NOMEMORY; 262 match_data_created = TRUE; 263 } 264 ovector = pcre2_get_ovector_pointer(match_data); 265 ovector_count = pcre2_get_ovector_count(match_data); 266 267 /* Find lengths of zero-terminated strings and the end of the replacement. */ 268 269 if (length == PCRE2_ZERO_TERMINATED) length = PRIV(strlen)(subject); 270 if (rlength == PCRE2_ZERO_TERMINATED) rlength = PRIV(strlen)(replacement); 271 repend = replacement + rlength; 272 273 /* Check UTF replacement string if necessary. */ 274 275 #ifdef SUPPORT_UNICODE 276 if (utf && (options & PCRE2_NO_UTF_CHECK) == 0) 277 { 278 rc = PRIV(valid_utf)(replacement, rlength, &(match_data->rightchar)); 279 if (rc != 0) 280 { 281 match_data->leftchar = 0; 282 goto EXIT; 283 } 284 } 285 #endif /* SUPPORT_UNICODE */ 286 287 /* Save the substitute options and remove them from the match options. */ 288 289 suboptions = options & SUBSTITUTE_OPTIONS; 290 options &= ~SUBSTITUTE_OPTIONS; 291 292 /* Copy up to the start offset */ 293 294 if (start_offset > length) 295 { 296 match_data->leftchar = 0; 297 rc = PCRE2_ERROR_BADOFFSET; 298 goto EXIT; 299 } 300 CHECKMEMCPY(subject, start_offset); 301 302 /* Loop for global substituting. */ 303 304 subs = 0; 305 do 306 { 307 PCRE2_SPTR ptrstack[PTR_STACK_SIZE]; 308 uint32_t ptrstackptr = 0; 309 310 rc = pcre2_match(code, subject, length, start_offset, options|goptions, 311 match_data, mcontext); 312 313 #ifdef SUPPORT_UNICODE 314 if (utf) options |= PCRE2_NO_UTF_CHECK; /* Only need to check once */ 315 #endif 316 317 /* Any error other than no match returns the error code. No match when not 318 doing the special after-empty-match global rematch, or when at the end of the 319 subject, breaks the global loop. Otherwise, advance the starting point by one 320 character, copying it to the output, and try again. */ 321 322 if (rc < 0) 323 { 324 PCRE2_SIZE save_start; 325 326 if (rc != PCRE2_ERROR_NOMATCH) goto EXIT; 327 if (goptions == 0 || start_offset >= length) break; 328 329 /* Advance by one code point. Then, if CRLF is a valid newline sequence and 330 we have advanced into the middle of it, advance one more code point. In 331 other words, do not start in the middle of CRLF, even if CR and LF on their 332 own are valid newlines. */ 333 334 save_start = start_offset++; 335 if (subject[start_offset-1] == CHAR_CR && 336 code->newline_convention != PCRE2_NEWLINE_CR && 337 code->newline_convention != PCRE2_NEWLINE_LF && 338 start_offset < length && 339 subject[start_offset] == CHAR_LF) 340 start_offset++; 341 342 /* Otherwise, in UTF mode, advance past any secondary code points. */ 343 344 else if ((code->overall_options & PCRE2_UTF) != 0) 345 { 346 #if PCRE2_CODE_UNIT_WIDTH == 8 347 while (start_offset < length && (subject[start_offset] & 0xc0) == 0x80) 348 start_offset++; 349 #elif PCRE2_CODE_UNIT_WIDTH == 16 350 while (start_offset < length && 351 (subject[start_offset] & 0xfc00) == 0xdc00) 352 start_offset++; 353 #endif 354 } 355 356 /* Copy what we have advanced past, reset the special global options, and 357 continue to the next match. */ 358 359 fraglength = start_offset - save_start; 360 CHECKMEMCPY(subject + save_start, fraglength); 361 goptions = 0; 362 continue; 363 } 364 365 /* Handle a successful match. Matches that use \K to end before they start 366 or start before the current point in the subject are not supported. */ 367 368 if (ovector[1] < ovector[0] || ovector[0] < start_offset) 369 { 370 rc = PCRE2_ERROR_BADSUBSPATTERN; 371 goto EXIT; 372 } 373 374 /* Check for the same match as previous. This is legitimate after matching an 375 empty string that starts after the initial match offset. We have tried again 376 at the match point in case the pattern is one like /(?<=\G.)/ which can never 377 match at its starting point, so running the match achieves the bumpalong. If 378 we do get the same (null) match at the original match point, it isn't such a 379 pattern, so we now do the empty string magic. In all other cases, a repeat 380 match should never occur. */ 381 382 if (ovecsave[0] == ovector[0] && ovecsave[1] == ovector[1]) 383 { 384 if (ovector[0] == ovector[1] && ovecsave[2] != start_offset) 385 { 386 goptions = PCRE2_NOTEMPTY_ATSTART | PCRE2_ANCHORED; 387 ovecsave[2] = start_offset; 388 continue; /* Back to the top of the loop */ 389 } 390 rc = PCRE2_ERROR_INTERNAL_DUPMATCH; 391 goto EXIT; 392 } 393 394 /* Count substitutions with a paranoid check for integer overflow; surely no 395 real call to this function would ever hit this! */ 396 397 if (subs == INT_MAX) 398 { 399 rc = PCRE2_ERROR_TOOMANYREPLACE; 400 goto EXIT; 401 } 402 subs++; 403 404 /* Copy the text leading up to the match. */ 405 406 if (rc == 0) rc = ovector_count; 407 fraglength = ovector[0] - start_offset; 408 CHECKMEMCPY(subject + start_offset, fraglength); 409 410 /* Process the replacement string. Literal mode is set by \Q, but only in 411 extended mode when backslashes are being interpreted. In extended mode we 412 must handle nested substrings that are to be reprocessed. */ 413 414 ptr = replacement; 415 for (;;) 416 { 417 uint32_t ch; 418 unsigned int chlen; 419 420 /* If at the end of a nested substring, pop the stack. */ 421 422 if (ptr >= repend) 423 { 424 if (ptrstackptr <= 0) break; /* End of replacement string */ 425 repend = ptrstack[--ptrstackptr]; 426 ptr = ptrstack[--ptrstackptr]; 427 continue; 428 } 429 430 /* Handle the next character */ 431 432 if (literal) 433 { 434 if (ptr[0] == CHAR_BACKSLASH && ptr < repend - 1 && ptr[1] == CHAR_E) 435 { 436 literal = FALSE; 437 ptr += 2; 438 continue; 439 } 440 goto LOADLITERAL; 441 } 442 443 /* Not in literal mode. */ 444 445 if (*ptr == CHAR_DOLLAR_SIGN) 446 { 447 int group, n; 448 uint32_t special = 0; 449 BOOL inparens; 450 BOOL star; 451 PCRE2_SIZE sublength; 452 PCRE2_SPTR text1_start = NULL; 453 PCRE2_SPTR text1_end = NULL; 454 PCRE2_SPTR text2_start = NULL; 455 PCRE2_SPTR text2_end = NULL; 456 PCRE2_UCHAR next; 457 PCRE2_UCHAR name[33]; 458 459 if (++ptr >= repend) goto BAD; 460 if ((next = *ptr) == CHAR_DOLLAR_SIGN) goto LOADLITERAL; 461 462 group = -1; 463 n = 0; 464 inparens = FALSE; 465 star = FALSE; 466 467 if (next == CHAR_LEFT_CURLY_BRACKET) 468 { 469 if (++ptr >= repend) goto BAD; 470 next = *ptr; 471 inparens = TRUE; 472 } 473 474 if (next == CHAR_ASTERISK) 475 { 476 if (++ptr >= repend) goto BAD; 477 next = *ptr; 478 star = TRUE; 479 } 480 481 if (!star && next >= CHAR_0 && next <= CHAR_9) 482 { 483 group = next - CHAR_0; 484 while (++ptr < repend) 485 { 486 next = *ptr; 487 if (next < CHAR_0 || next > CHAR_9) break; 488 group = group * 10 + next - CHAR_0; 489 490 /* A check for a number greater than the hightest captured group 491 is sufficient here; no need for a separate overflow check. If unknown 492 groups are to be treated as unset, just skip over any remaining 493 digits and carry on. */ 494 495 if (group > code->top_bracket) 496 { 497 if ((suboptions & PCRE2_SUBSTITUTE_UNKNOWN_UNSET) != 0) 498 { 499 while (++ptr < repend && *ptr >= CHAR_0 && *ptr <= CHAR_9); 500 break; 501 } 502 else 503 { 504 rc = PCRE2_ERROR_NOSUBSTRING; 505 goto PTREXIT; 506 } 507 } 508 } 509 } 510 else 511 { 512 const uint8_t *ctypes = code->tables + ctypes_offset; 513 while (MAX_255(next) && (ctypes[next] & ctype_word) != 0) 514 { 515 name[n++] = next; 516 if (n > 32) goto BAD; 517 if (++ptr >= repend) break; 518 next = *ptr; 519 } 520 if (n == 0) goto BAD; 521 name[n] = 0; 522 } 523 524 /* In extended mode we recognize ${name:+set text:unset text} and 525 ${name:-default text}. */ 526 527 if (inparens) 528 { 529 if ((suboptions & PCRE2_SUBSTITUTE_EXTENDED) != 0 && 530 !star && ptr < repend - 2 && next == CHAR_COLON) 531 { 532 special = *(++ptr); 533 if (special != CHAR_PLUS && special != CHAR_MINUS) 534 { 535 rc = PCRE2_ERROR_BADSUBSTITUTION; 536 goto PTREXIT; 537 } 538 539 text1_start = ++ptr; 540 rc = find_text_end(code, &ptr, repend, special == CHAR_MINUS); 541 if (rc != 0) goto PTREXIT; 542 text1_end = ptr; 543 544 if (special == CHAR_PLUS && *ptr == CHAR_COLON) 545 { 546 text2_start = ++ptr; 547 rc = find_text_end(code, &ptr, repend, TRUE); 548 if (rc != 0) goto PTREXIT; 549 text2_end = ptr; 550 } 551 } 552 553 else 554 { 555 if (ptr >= repend || *ptr != CHAR_RIGHT_CURLY_BRACKET) 556 { 557 rc = PCRE2_ERROR_REPMISSINGBRACE; 558 goto PTREXIT; 559 } 560 } 561 562 ptr++; 563 } 564 565 /* Have found a syntactically correct group number or name, or *name. 566 Only *MARK is currently recognized. */ 567 568 if (star) 569 { 570 if (PRIV(strcmp_c8)(name, STRING_MARK) == 0) 571 { 572 PCRE2_SPTR mark = pcre2_get_mark(match_data); 573 if (mark != NULL) 574 { 575 PCRE2_SPTR mark_start = mark; 576 while (*mark != 0) mark++; 577 fraglength = mark - mark_start; 578 CHECKMEMCPY(mark_start, fraglength); 579 } 580 } 581 else goto BAD; 582 } 583 584 /* Substitute the contents of a group. We don't use substring_copy 585 functions any more, in order to support case forcing. */ 586 587 else 588 { 589 PCRE2_SPTR subptr, subptrend; 590 591 /* Find a number for a named group. In case there are duplicate names, 592 search for the first one that is set. If the name is not found when 593 PCRE2_SUBSTITUTE_UNKNOWN_EMPTY is set, set the group number to a 594 non-existent group. */ 595 596 if (group < 0) 597 { 598 PCRE2_SPTR first, last, entry; 599 rc = pcre2_substring_nametable_scan(code, name, &first, &last); 600 if (rc == PCRE2_ERROR_NOSUBSTRING && 601 (suboptions & PCRE2_SUBSTITUTE_UNKNOWN_UNSET) != 0) 602 { 603 group = code->top_bracket + 1; 604 } 605 else 606 { 607 if (rc < 0) goto PTREXIT; 608 for (entry = first; entry <= last; entry += rc) 609 { 610 uint32_t ng = GET2(entry, 0); 611 if (ng < ovector_count) 612 { 613 if (group < 0) group = ng; /* First in ovector */ 614 if (ovector[ng*2] != PCRE2_UNSET) 615 { 616 group = ng; /* First that is set */ 617 break; 618 } 619 } 620 } 621 622 /* If group is still negative, it means we did not find a group 623 that is in the ovector. Just set the first group. */ 624 625 if (group < 0) group = GET2(first, 0); 626 } 627 } 628 629 /* We now have a group that is identified by number. Find the length of 630 the captured string. If a group in a non-special substitution is unset 631 when PCRE2_SUBSTITUTE_UNSET_EMPTY is set, substitute nothing. */ 632 633 rc = pcre2_substring_length_bynumber(match_data, group, &sublength); 634 if (rc < 0) 635 { 636 if (rc == PCRE2_ERROR_NOSUBSTRING && 637 (suboptions & PCRE2_SUBSTITUTE_UNKNOWN_UNSET) != 0) 638 { 639 rc = PCRE2_ERROR_UNSET; 640 } 641 if (rc != PCRE2_ERROR_UNSET) goto PTREXIT; /* Non-unset errors */ 642 if (special == 0) /* Plain substitution */ 643 { 644 if ((suboptions & PCRE2_SUBSTITUTE_UNSET_EMPTY) != 0) continue; 645 goto PTREXIT; /* Else error */ 646 } 647 } 648 649 /* If special is '+' we have a 'set' and possibly an 'unset' text, 650 both of which are reprocessed when used. If special is '-' we have a 651 default text for when the group is unset; it must be reprocessed. */ 652 653 if (special != 0) 654 { 655 if (special == CHAR_MINUS) 656 { 657 if (rc == 0) goto LITERAL_SUBSTITUTE; 658 text2_start = text1_start; 659 text2_end = text1_end; 660 } 661 662 if (ptrstackptr >= PTR_STACK_SIZE) goto BAD; 663 ptrstack[ptrstackptr++] = ptr; 664 ptrstack[ptrstackptr++] = repend; 665 666 if (rc == 0) 667 { 668 ptr = text1_start; 669 repend = text1_end; 670 } 671 else 672 { 673 ptr = text2_start; 674 repend = text2_end; 675 } 676 continue; 677 } 678 679 /* Otherwise we have a literal substitution of a group's contents. */ 680 681 LITERAL_SUBSTITUTE: 682 subptr = subject + ovector[group*2]; 683 subptrend = subject + ovector[group*2 + 1]; 684 685 /* Substitute a literal string, possibly forcing alphabetic case. */ 686 687 while (subptr < subptrend) 688 { 689 GETCHARINCTEST(ch, subptr); 690 if (forcecase != 0) 691 { 692 #ifdef SUPPORT_UNICODE 693 if (utf) 694 { 695 uint32_t type = UCD_CHARTYPE(ch); 696 if (PRIV(ucp_gentype)[type] == ucp_L && 697 type != ((forcecase > 0)? ucp_Lu : ucp_Ll)) 698 ch = UCD_OTHERCASE(ch); 699 } 700 else 701 #endif 702 { 703 if (((code->tables + cbits_offset + 704 ((forcecase > 0)? cbit_upper:cbit_lower) 705 )[ch/8] & (1 << (ch%8))) == 0) 706 ch = (code->tables + fcc_offset)[ch]; 707 } 708 forcecase = forcecasereset; 709 } 710 711 #ifdef SUPPORT_UNICODE 712 if (utf) chlen = PRIV(ord2utf)(ch, temp); else 713 #endif 714 { 715 temp[0] = ch; 716 chlen = 1; 717 } 718 CHECKMEMCPY(temp, chlen); 719 } 720 } 721 } 722 723 /* Handle an escape sequence in extended mode. We can use check_escape() 724 to process \Q, \E, \c, \o, \x and \ followed by non-alphanumerics, but 725 the case-forcing escapes are not supported in pcre2_compile() so must be 726 recognized here. */ 727 728 else if ((suboptions & PCRE2_SUBSTITUTE_EXTENDED) != 0 && 729 *ptr == CHAR_BACKSLASH) 730 { 731 int errorcode; 732 733 if (ptr < repend - 1) switch (ptr[1]) 734 { 735 case CHAR_L: 736 forcecase = forcecasereset = -1; 737 ptr += 2; 738 continue; 739 740 case CHAR_l: 741 forcecase = -1; 742 forcecasereset = 0; 743 ptr += 2; 744 continue; 745 746 case CHAR_U: 747 forcecase = forcecasereset = 1; 748 ptr += 2; 749 continue; 750 751 case CHAR_u: 752 forcecase = 1; 753 forcecasereset = 0; 754 ptr += 2; 755 continue; 756 757 default: 758 break; 759 } 760 761 ptr++; /* Point after \ */ 762 rc = PRIV(check_escape)(&ptr, repend, &ch, &errorcode, 763 code->overall_options, FALSE, NULL); 764 if (errorcode != 0) goto BADESCAPE; 765 766 switch(rc) 767 { 768 case ESC_E: 769 forcecase = forcecasereset = 0; 770 continue; 771 772 case ESC_Q: 773 literal = TRUE; 774 continue; 775 776 case 0: /* Data character */ 777 goto LITERAL; 778 779 default: 780 goto BADESCAPE; 781 } 782 } 783 784 /* Handle a literal code unit */ 785 786 else 787 { 788 LOADLITERAL: 789 GETCHARINCTEST(ch, ptr); /* Get character value, increment pointer */ 790 791 LITERAL: 792 if (forcecase != 0) 793 { 794 #ifdef SUPPORT_UNICODE 795 if (utf) 796 { 797 uint32_t type = UCD_CHARTYPE(ch); 798 if (PRIV(ucp_gentype)[type] == ucp_L && 799 type != ((forcecase > 0)? ucp_Lu : ucp_Ll)) 800 ch = UCD_OTHERCASE(ch); 801 } 802 else 803 #endif 804 { 805 if (((code->tables + cbits_offset + 806 ((forcecase > 0)? cbit_upper:cbit_lower) 807 )[ch/8] & (1 << (ch%8))) == 0) 808 ch = (code->tables + fcc_offset)[ch]; 809 } 810 forcecase = forcecasereset; 811 } 812 813 #ifdef SUPPORT_UNICODE 814 if (utf) chlen = PRIV(ord2utf)(ch, temp); else 815 #endif 816 { 817 temp[0] = ch; 818 chlen = 1; 819 } 820 CHECKMEMCPY(temp, chlen); 821 } /* End handling a literal code unit */ 822 } /* End of loop for scanning the replacement. */ 823 824 /* The replacement has been copied to the output. Save the details of this 825 match. See above for how this data is used. If we matched an empty string, do 826 the magic for global matches. Finally, update the start offset to point to 827 the rest of the subject string. */ 828 829 ovecsave[0] = ovector[0]; 830 ovecsave[1] = ovector[1]; 831 ovecsave[2] = start_offset; 832 833 goptions = (ovector[0] != ovector[1] || ovector[0] > start_offset)? 0 : 834 PCRE2_ANCHORED|PCRE2_NOTEMPTY_ATSTART; 835 start_offset = ovector[1]; 836 } while ((suboptions & PCRE2_SUBSTITUTE_GLOBAL) != 0); /* Repeat "do" loop */ 837 838 /* Copy the rest of the subject. */ 839 840 fraglength = length - start_offset; 841 CHECKMEMCPY(subject + start_offset, fraglength); 842 temp[0] = 0; 843 CHECKMEMCPY(temp , 1); 844 845 /* If overflowed is set it means the PCRE2_SUBSTITUTE_OVERFLOW_LENGTH is set, 846 and matching has carried on after a full buffer, in order to compute the length 847 needed. Otherwise, an overflow generates an immediate error return. */ 848 849 if (overflowed) 850 { 851 rc = PCRE2_ERROR_NOMEMORY; 852 *blength = buff_length + extra_needed; 853 } 854 855 /* After a successful execution, return the number of substitutions and set the 856 length of buffer used, excluding the trailing zero. */ 857 858 else 859 { 860 rc = subs; 861 *blength = buff_offset - 1; 862 } 863 864 EXIT: 865 if (match_data_created) pcre2_match_data_free(match_data); 866 else match_data->rc = rc; 867 return rc; 868 869 NOROOM: 870 rc = PCRE2_ERROR_NOMEMORY; 871 goto EXIT; 872 873 BAD: 874 rc = PCRE2_ERROR_BADREPLACEMENT; 875 goto PTREXIT; 876 877 BADESCAPE: 878 rc = PCRE2_ERROR_BADREPESCAPE; 879 880 PTREXIT: 881 *blength = (PCRE2_SIZE)(ptr - replacement); 882 goto EXIT; 883 } 884 885 /* End of pcre2_substitute.c */ 886
