../deps/icu-small/source/i18n/rematch.cpp

1

2

// License & terms of use: http://www.unicode.org/copyright.html

3

/*

4

**************************************************************************

5

6

7

**************************************************************************

8

*/

9

//

10

// file: rematch.cpp

11

//

12

// Contains the implementation of class RegexMatcher,

13

// which is one of the main API classes for the ICU regular expression package.

14

//

15

16

#include "unicode/utypes.h"

17

#if !UCONFIG_NO_REGULAR_EXPRESSIONS0

18

19

#include "unicode/regex.h"

20

#include "unicode/uniset.h"

21

#include "unicode/uchar.h"

22

#include "unicode/ustring.h"

23

#include "unicode/rbbi.h"

24

#include "unicode/utf.h"

25

#include "unicode/utf16.h"

26

#include "uassert.h"

27

#include "cmemory.h"

28

#include "cstr.h"

29

#include "uvector.h"

30

#include "uvectr32.h"

31

#include "uvectr64.h"

32

#include "regeximp.h"

33

#include "regexst.h"

34

#include "regextxt.h"

35

#include "ucase.h"

36

37

// #include <malloc.h> // Needed for heapcheck testing

38

39

40

U_NAMESPACE_BEGINnamespace icu_71 {

41

42

// Default limit for the size of the back track stack, to avoid system

43

// failures causedby heap exhaustion. Units are in 32 bit words, not bytes.

44

// This value puts ICU's limits higher than most other regexp implementations,

45

// which use recursion rather than the heap, and take more storage per

46

// backtrack point.

47

//

48

static const int32_t DEFAULT_BACKTRACK_STACK_CAPACITY = 8000000;

49

50

// Time limit counter constant.

51

// Time limits for expression evaluation are in terms of quanta of work by

52

// the engine, each of which is 10,000 state saves.

53

// This constant determines that state saves per tick number.

54

static const int32_t TIMER_INITIAL_VALUE = 10000;

55

56

57

// Test for any of the Unicode line terminating characters.

58

static inline UBool isLineTerminator(UChar32 c) {

59

if (c & ~(0x0a | 0x0b | 0x0c | 0x0d | 0x85 | 0x2028 | 0x2029)) {

60

return false;

61

}

62

return (c<=0x0d && c>=0x0a) || c==0x85 || c==0x2028 || c==0x2029;

63

}

64

65

//-----------------------------------------------------------------------------

66

//

67

// Constructor and Destructor

68

//

69

//-----------------------------------------------------------------------------

70

RegexMatcher::RegexMatcher(const RegexPattern *pat) {

71

fDeferredStatus = U_ZERO_ERROR;

72

init(fDeferredStatus);

73

if (U_FAILURE(fDeferredStatus)) {

74

return;

75

}

76

if (pat==NULL__null) {

77

fDeferredStatus = U_ILLEGAL_ARGUMENT_ERROR;

78

return;

79

}

80

fPattern = pat;

81

init2(RegexStaticSets::gStaticSets->fEmptyText, fDeferredStatus);

82

}

83

84

85

86

RegexMatcher::RegexMatcher(const UnicodeString &regexp, const UnicodeString &input,

87

uint32_t flags, UErrorCode &status) {

88

init(status);

89

if (U_FAILURE(status)) {

90

return;

91

}

92

UParseError pe;

93

fPatternOwned = RegexPattern::compile(regexp, flags, pe, status);

94

fPattern = fPatternOwned;

95

96

UText inputText = UTEXT_INITIALIZER{ UTEXT_MAGIC, 0, 0, sizeof(UText), 0, 0, 0, 0, 0, 0, __null,
__null, __null, __null, __null, __null, __null, __null, 0, 0
, 0, 0, 0, 0 };

97

utext_openConstUnicodeStringutext_openConstUnicodeString_71(&inputText, &input, &status);

98

init2(&inputText, status);

99

utext_closeutext_close_71(&inputText);

100

101

fInputUniStrMaybeMutable = TRUE1;

102

}

103

104

105

RegexMatcher::RegexMatcher(UText *regexp, UText *input,

106

uint32_t flags, UErrorCode &status) {

107

init(status);

108

if (U_FAILURE(status)) {

109

return;

110

}

111

UParseError pe;

112

fPatternOwned = RegexPattern::compile(regexp, flags, pe, status);

113

if (U_FAILURE(status)) {

114

return;

115

}

116

117

fPattern = fPatternOwned;

118

init2(input, status);

119

}

120

121

122

RegexMatcher::RegexMatcher(const UnicodeString &regexp,

123

uint32_t flags, UErrorCode &status) {

124

init(status);

125

if (U_FAILURE(status)) {

126

return;

127

}

128

UParseError pe;

129

fPatternOwned = RegexPattern::compile(regexp, flags, pe, status);

130

if (U_FAILURE(status)) {

131

return;

132

}

133

fPattern = fPatternOwned;

134

init2(RegexStaticSets::gStaticSets->fEmptyText, status);

135

}

136

137

RegexMatcher::RegexMatcher(UText *regexp,

138

uint32_t flags, UErrorCode &status) {

139

init(status);

140

if (U_FAILURE(status)) {

141

return;

142

}

143

UParseError pe;

144

fPatternOwned = RegexPattern::compile(regexp, flags, pe, status);

145

if (U_FAILURE(status)) {

146

return;

147

}

148

149

fPattern = fPatternOwned;

150

init2(RegexStaticSets::gStaticSets->fEmptyText, status);

151

}

152

153

154

155

156

RegexMatcher::~RegexMatcher() {

157

delete fStack;

158

if (fData != fSmallData) {

159

uprv_freeuprv_free_71(fData);

160

fData = NULL__null;

161

}

162

if (fPatternOwned) {

163

delete fPatternOwned;

164

fPatternOwned = NULL__null;

165

fPattern = NULL__null;

166

}

167

168

if (fInput) {

169

delete fInput;

170

}

171

if (fInputText) {

172

utext_closeutext_close_71(fInputText);

173

}

174

if (fAltInputText) {

175

utext_closeutext_close_71(fAltInputText);

176

}

177

178

#if UCONFIG_NO_BREAK_ITERATION0==0

179

delete fWordBreakItr;

180

delete fGCBreakItr;

181

#endif

182

}

183

184

//

185

// init() common initialization for use by all constructors.

186

// Initialize all fields, get the object into a consistent state.

187

// This must be done even when the initial status shows an error,

188

// so that the object is initialized sufficiently well for the destructor

189

// to run safely.

190

//

191

void RegexMatcher::init(UErrorCode &status) {

192

fPattern = NULL__null;

193

fPatternOwned = NULL__null;

194

fFrameSize = 0;

195

fRegionStart = 0;

196

fRegionLimit = 0;

197

fAnchorStart = 0;

198

fAnchorLimit = 0;

199

fLookStart = 0;

200

fLookLimit = 0;

201

fActiveStart = 0;

202

fActiveLimit = 0;

203

fTransparentBounds = FALSE0;

204

fAnchoringBounds = TRUE1;

205

fMatch = FALSE0;

206

fMatchStart = 0;

207

fMatchEnd = 0;

208

fLastMatchEnd = -1;

209

fAppendPosition = 0;

210

fHitEnd = FALSE0;

211

fRequireEnd = FALSE0;

212

fStack = NULL__null;

213

fFrame = NULL__null;

214

fTimeLimit = 0;

215

fTime = 0;

216

fTickCounter = 0;

217

fStackLimit = DEFAULT_BACKTRACK_STACK_CAPACITY;

218

fCallbackFn = NULL__null;

219

fCallbackContext = NULL__null;

220

fFindProgressCallbackFn = NULL__null;

221

fFindProgressCallbackContext = NULL__null;

222

fTraceDebug = FALSE0;

223

fDeferredStatus = status;

224

fData = fSmallData;

225

fWordBreakItr = NULL__null;

226

fGCBreakItr = NULL__null;

227

228

fStack = NULL__null;

229

fInputText = NULL__null;

230

fAltInputText = NULL__null;

231

fInput = NULL__null;

232

fInputLength = 0;

233

fInputUniStrMaybeMutable = FALSE0;

234

}

235

236

//

237

// init2() Common initialization for use by RegexMatcher constructors, part 2.

238

// This handles the common setup to be done after the Pattern is available.

239

//

240

void RegexMatcher::init2(UText *input, UErrorCode &status) {

241

if (U_FAILURE(status)) {

242

fDeferredStatus = status;

243

return;

244

}

245

246

if (fPattern->fDataSize > UPRV_LENGTHOF(fSmallData)(int32_t)(sizeof(fSmallData)/sizeof((fSmallData)[0]))) {

247

fData = (int64_t *)uprv_mallocuprv_malloc_71(fPattern->fDataSize * sizeof(int64_t));

248

if (fData == NULL__null) {

249

status = fDeferredStatus = U_MEMORY_ALLOCATION_ERROR;

250

return;

251

}

252

}

253

254

fStack = new UVector64(status);

255

if (fStack == NULL__null) {

256

status = fDeferredStatus = U_MEMORY_ALLOCATION_ERROR;

257

return;

258

}

259

260

reset(input);

261

setStackLimit(DEFAULT_BACKTRACK_STACK_CAPACITY, status);

262

if (U_FAILURE(status)) {

263

fDeferredStatus = status;

264

return;

265

}

266

}

267

268

269

static const UChar BACKSLASH = 0x5c;

270

static const UChar DOLLARSIGN = 0x24;

271

static const UChar LEFTBRACKET = 0x7b;

272

static const UChar RIGHTBRACKET = 0x7d;

273

274

//--------------------------------------------------------------------------------

275

//

276

// appendReplacement

277

//

278

//--------------------------------------------------------------------------------

279

RegexMatcher &RegexMatcher::appendReplacement(UnicodeString &dest,

280

const UnicodeString &replacement,

281

UErrorCode &status) {

282

UText replacementText = UTEXT_INITIALIZER{ UTEXT_MAGIC, 0, 0, sizeof(UText), 0, 0, 0, 0, 0, 0, __null,
__null, __null, __null, __null, __null, __null, __null, 0, 0
, 0, 0, 0, 0 };

283

284

utext_openConstUnicodeStringutext_openConstUnicodeString_71(&replacementText, &replacement, &status);

285

if (U_SUCCESS(status)) {

286

UText resultText = UTEXT_INITIALIZER{ UTEXT_MAGIC, 0, 0, sizeof(UText), 0, 0, 0, 0, 0, 0, __null,
__null, __null, __null, __null, __null, __null, __null, 0, 0
, 0, 0, 0, 0 };

287

utext_openUnicodeStringutext_openUnicodeString_71(&resultText, &dest, &status);

288

289

if (U_SUCCESS(status)) {

290

appendReplacement(&resultText, &replacementText, status);

291

utext_closeutext_close_71(&resultText);

292

}

293

utext_closeutext_close_71(&replacementText);

294

}

295

296

return *this;

297

}

298

299

//

300

// appendReplacement, UText mode

301

//

302

RegexMatcher &RegexMatcher::appendReplacement(UText *dest,

303

UText *replacement,

304

UErrorCode &status) {

305

if (U_FAILURE(status)) {

306

return *this;

307

}

308

if (U_FAILURE(fDeferredStatus)) {

309

status = fDeferredStatus;

310

return *this;

311

}

312

if (fMatch == FALSE0) {

313

status = U_REGEX_INVALID_STATE;

314

return *this;

315

}

316

317

// Copy input string from the end of previous match to start of current match

318

int64_t destLen = utext_nativeLengthutext_nativeLength_71(dest);

319

if (fMatchStart > fAppendPosition) {

320

if (UTEXT_FULL_TEXT_IN_CHUNK(fInputText, fInputLength)((0==((fInputText)->chunkNativeStart))&&((fInputLength
)==((fInputText)->chunkNativeLimit))&&((fInputLength
)==((fInputText)->nativeIndexingLimit)))) {

321

destLen += utext_replaceutext_replace_71(dest, destLen, destLen, fInputText->chunkContents+fAppendPosition,

322

(int32_t)(fMatchStart-fAppendPosition), &status);

323

} else {

324

int32_t len16;

325

if (UTEXT_USES_U16(fInputText)(__null==((fInputText)->pFuncs->mapNativeIndexToUTF16))) {

326

len16 = (int32_t)(fMatchStart-fAppendPosition);

327

} else {

328

UErrorCode lengthStatus = U_ZERO_ERROR;

329

len16 = utext_extractutext_extract_71(fInputText, fAppendPosition, fMatchStart, NULL__null, 0, &lengthStatus);

330

}

331

UChar *inputChars = (UChar *)uprv_mallocuprv_malloc_71(sizeof(UChar)*(len16+1));

332

if (inputChars == NULL__null) {

333

status = U_MEMORY_ALLOCATION_ERROR;

334

return *this;

335

}

336

utext_extractutext_extract_71(fInputText, fAppendPosition, fMatchStart, inputChars, len16+1, &status);

337

destLen += utext_replaceutext_replace_71(dest, destLen, destLen, inputChars, len16, &status);

338

uprv_freeuprv_free_71(inputChars);

339

}

340

}

341

fAppendPosition = fMatchEnd;

342

343

344

// scan the replacement text, looking for substitutions ($n) and \escapes.

345

// TODO: optimize this loop by efficiently scanning for '$' or '\',

346

// move entire ranges not containing substitutions.

347

UTEXT_SETNATIVEINDEX(replacement, 0)do { int64_t __offset = (0) - (replacement)->chunkNativeStart
; if (__offset>=0 && __offset<(int64_t)(replacement
)->nativeIndexingLimit && (replacement)->chunkContents
[__offset]<0xdc00) { (replacement)->chunkOffset=(int32_t
)__offset; } else { utext_setNativeIndex_71((replacement), (0
)); } } while (false);

348

for (UChar32 c = UTEXT_NEXT32(replacement)((replacement)->chunkOffset < (replacement)->chunkLength
&& ((replacement)->chunkContents)[(replacement)->
chunkOffset]<0xd800 ? ((replacement)->chunkContents)[((
replacement)->chunkOffset)++] : utext_next32_71(replacement
)); U_SUCCESS(status) && c != U_SENTINEL(-1); c = UTEXT_NEXT32(replacement)((replacement)->chunkOffset < (replacement)->chunkLength
&& ((replacement)->chunkContents)[(replacement)->
chunkOffset]<0xd800 ? ((replacement)->chunkContents)[((
replacement)->chunkOffset)++] : utext_next32_71(replacement
))) {

349

if (c == BACKSLASH) {

350

// Backslash Escape. Copy the following char out without further checks.

351

// Note: Surrogate pairs don't need any special handling

352

// The second half wont be a '$' or a '\', and

353

// will move to the dest normally on the next

354

// loop iteration.

355

c = UTEXT_CURRENT32(replacement)((replacement)->chunkOffset < (replacement)->chunkLength
&& ((replacement)->chunkContents)[(replacement)->
chunkOffset]<0xd800 ? ((replacement)->chunkContents)[((
replacement)->chunkOffset)] : utext_current32_71(replacement
));

356

if (c == U_SENTINEL(-1)) {

357

break;

358

}

359

360

if (c==0x55/*U*/ || c==0x75/*u*/) {

361

// We have a \udddd or \Udddddddd escape sequence.

362

int32_t offset = 0;

363

struct URegexUTextUnescapeCharContext context = U_REGEX_UTEXT_UNESCAPE_CONTEXT(replacement){ (replacement), -1 };

364

UChar32 escapedChar = u_unescapeAtu_unescapeAt_71(uregex_utext_unescape_charAturegex_utext_unescape_charAt_71, &offset, INT32_MAX(2147483647), &context);

365

if (escapedChar != (UChar32)0xFFFFFFFF) {

366

if (U_IS_BMP(escapedChar)((uint32_t)(escapedChar)<=0xffff)) {

367

UChar c16 = (UChar)escapedChar;

368

destLen += utext_replaceutext_replace_71(dest, destLen, destLen, &c16, 1, &status);

369

} else {

370

UChar surrogate[2];

371

surrogate[0] = U16_LEAD(escapedChar)(UChar)(((escapedChar)>>10)+0xd7c0);

372

surrogate[1] = U16_TRAIL(escapedChar)(UChar)(((escapedChar)&0x3ff)|0xdc00);

373

if (U_SUCCESS(status)) {

374

destLen += utext_replaceutext_replace_71(dest, destLen, destLen, surrogate, 2, &status);

375

}

376

}

377

// TODO: Report errors for mal-formed \u escapes?

378

// As this is, the original sequence is output, which may be OK.

379

if (context.lastOffset == offset) {

380

(void)UTEXT_PREVIOUS32(replacement)((replacement)->chunkOffset > 0 && (replacement
)->chunkContents[(replacement)->chunkOffset-1] < 0xd800
? (replacement)->chunkContents[--((replacement)->chunkOffset
)] : utext_previous32_71(replacement));

381

} else if (context.lastOffset != offset-1) {

382

utext_moveIndex32utext_moveIndex32_71(replacement, offset - context.lastOffset - 1);

383

}

384

}

385

} else {

386

(void)UTEXT_NEXT32(replacement)((replacement)->chunkOffset < (replacement)->chunkLength
&& ((replacement)->chunkContents)[(replacement)->
chunkOffset]<0xd800 ? ((replacement)->chunkContents)[((
replacement)->chunkOffset)++] : utext_next32_71(replacement
));

387

// Plain backslash escape. Just put out the escaped character.

388

if (U_IS_BMP(c)((uint32_t)(c)<=0xffff)) {

389

UChar c16 = (UChar)c;

390

destLen += utext_replaceutext_replace_71(dest, destLen, destLen, &c16, 1, &status);

391

} else {

392

UChar surrogate[2];

393

surrogate[0] = U16_LEAD(c)(UChar)(((c)>>10)+0xd7c0);

394

surrogate[1] = U16_TRAIL(c)(UChar)(((c)&0x3ff)|0xdc00);

395

if (U_SUCCESS(status)) {

396

destLen += utext_replaceutext_replace_71(dest, destLen, destLen, surrogate, 2, &status);

397

}

398

}

399

}

400

} else if (c != DOLLARSIGN) {

401

// Normal char, not a $. Copy it out without further checks.

402

if (U_IS_BMP(c)((uint32_t)(c)<=0xffff)) {

403

UChar c16 = (UChar)c;

404

destLen += utext_replaceutext_replace_71(dest, destLen, destLen, &c16, 1, &status);

405

} else {

406

UChar surrogate[2];

407

surrogate[0] = U16_LEAD(c)(UChar)(((c)>>10)+0xd7c0);

408

surrogate[1] = U16_TRAIL(c)(UChar)(((c)&0x3ff)|0xdc00);

409

if (U_SUCCESS(status)) {

410

destLen += utext_replaceutext_replace_71(dest, destLen, destLen, surrogate, 2, &status);

411

}

412

}

413

} else {

414

// We've got a $. Pick up a capture group name or number if one follows.

415

// Consume digits so long as the resulting group number <= the number of

416

// number of capture groups in the pattern.

417

418

int32_t groupNum = 0;

419

int32_t numDigits = 0;

420

UChar32 nextChar = utext_current32utext_current32_71(replacement);

421

if (nextChar == LEFTBRACKET) {

422

// Scan for a Named Capture Group, ${name}.

423

UnicodeString groupName;

424

utext_next32utext_next32_71(replacement);

425

while(U_SUCCESS(status) && nextChar != RIGHTBRACKET) {

426

nextChar = utext_next32utext_next32_71(replacement);

427

if (nextChar == U_SENTINEL(-1)) {

428

status = U_REGEX_INVALID_CAPTURE_GROUP_NAME;

429

} else if ((nextChar >= 0x41 && nextChar <= 0x5a) || // A..Z

430

(nextChar >= 0x61 && nextChar <= 0x7a) || // a..z

431

(nextChar >= 0x31 && nextChar <= 0x39)) { // 0..9

432

groupName.append(nextChar);

433

} else if (nextChar == RIGHTBRACKET) {

434

groupNum = fPattern->fNamedCaptureMap ? uhash_getiuhash_geti_71(fPattern->fNamedCaptureMap, &groupName) : 0;

435

if (groupNum == 0) {

436

status = U_REGEX_INVALID_CAPTURE_GROUP_NAME;

437

}

438

} else {

439

// Character was something other than a name char or a closing '}'

440

status = U_REGEX_INVALID_CAPTURE_GROUP_NAME;

441

}

442

}

443

444

} else if (u_isdigitu_isdigit_71(nextChar)) {

445

// $n Scan for a capture group number

446

int32_t numCaptureGroups = fPattern->fGroupMap->size();

447

for (;;) {

448

nextChar = UTEXT_CURRENT32(replacement)((replacement)->chunkOffset < (replacement)->chunkLength
&& ((replacement)->chunkContents)[(replacement)->
chunkOffset]<0xd800 ? ((replacement)->chunkContents)[((
replacement)->chunkOffset)] : utext_current32_71(replacement
));

449

if (nextChar == U_SENTINEL(-1)) {

450

break;

451

}

452

if (u_isdigitu_isdigit_71(nextChar) == FALSE0) {

453

break;

454

}

455

int32_t nextDigitVal = u_charDigitValueu_charDigitValue_71(nextChar);

456

if (groupNum*10 + nextDigitVal > numCaptureGroups) {

457

// Don't consume the next digit if it makes the capture group number too big.

458

if (numDigits == 0) {

459

status = U_INDEX_OUTOFBOUNDS_ERROR;

460

}

461

break;

462

}

463

(void)UTEXT_NEXT32(replacement)((replacement)->chunkOffset < (replacement)->chunkLength
&& ((replacement)->chunkContents)[(replacement)->
chunkOffset]<0xd800 ? ((replacement)->chunkContents)[((
replacement)->chunkOffset)++] : utext_next32_71(replacement
));

464

groupNum=groupNum*10 + nextDigitVal;

465

++numDigits;

466

}

467

} else {

468

// $ not followed by capture group name or number.

469

status = U_REGEX_INVALID_CAPTURE_GROUP_NAME;

470

}

471

472

if (U_SUCCESS(status)) {

473

destLen += appendGroup(groupNum, dest, status);

474

}

475

} // End of $ capture group handling

476

} // End of per-character loop through the replacement string.

477

478

return *this;

479

}

480

481

482

483

//--------------------------------------------------------------------------------

484

//

485

// appendTail Intended to be used in conjunction with appendReplacement()

486

// To the destination string, append everything following

487

// the last match position from the input string.

488

//

489

// Note: Match ranges do not affect appendTail or appendReplacement

490

//

491

//--------------------------------------------------------------------------------

492

UnicodeString &RegexMatcher::appendTail(UnicodeString &dest) {

493

UErrorCode status = U_ZERO_ERROR;

494

UText resultText = UTEXT_INITIALIZER{ UTEXT_MAGIC, 0, 0, sizeof(UText), 0, 0, 0, 0, 0, 0, __null,
__null, __null, __null, __null, __null, __null, __null, 0, 0
, 0, 0, 0, 0 };

495

utext_openUnicodeStringutext_openUnicodeString_71(&resultText, &dest, &status);

496

497

if (U_SUCCESS(status)) {

498

appendTail(&resultText, status);

499

utext_closeutext_close_71(&resultText);

500

}

501

502

return dest;

503

}

504

505

//

506

// appendTail, UText mode

507

//

508

UText *RegexMatcher::appendTail(UText *dest, UErrorCode &status) {

509

if (U_FAILURE(status)) {

510

return dest;

511

}

512

if (U_FAILURE(fDeferredStatus)) {

513

status = fDeferredStatus;

514

return dest;

515

}

516

517

if (fInputLength > fAppendPosition) {

518

if (UTEXT_FULL_TEXT_IN_CHUNK(fInputText, fInputLength)((0==((fInputText)->chunkNativeStart))&&((fInputLength
)==((fInputText)->chunkNativeLimit))&&((fInputLength
)==((fInputText)->nativeIndexingLimit)))) {

519

int64_t destLen = utext_nativeLengthutext_nativeLength_71(dest);

520

utext_replaceutext_replace_71(dest, destLen, destLen, fInputText->chunkContents+fAppendPosition,

521

(int32_t)(fInputLength-fAppendPosition), &status);

522

} else {

523

int32_t len16;

524

if (UTEXT_USES_U16(fInputText)(__null==((fInputText)->pFuncs->mapNativeIndexToUTF16))) {

525

len16 = (int32_t)(fInputLength-fAppendPosition);

526

} else {

527

len16 = utext_extractutext_extract_71(fInputText, fAppendPosition, fInputLength, NULL__null, 0, &status);

528

status = U_ZERO_ERROR; // buffer overflow

529

}

530

531

UChar *inputChars = (UChar *)uprv_mallocuprv_malloc_71(sizeof(UChar)*(len16));

532

if (inputChars == NULL__null) {

533

fDeferredStatus = U_MEMORY_ALLOCATION_ERROR;

534

} else {

535

utext_extractutext_extract_71(fInputText, fAppendPosition, fInputLength, inputChars, len16, &status); // unterminated

536

int64_t destLen = utext_nativeLengthutext_nativeLength_71(dest);

537

utext_replaceutext_replace_71(dest, destLen, destLen, inputChars, len16, &status);

538

uprv_freeuprv_free_71(inputChars);

539

}

540

}

541

}

542

return dest;

543

}

544

545

546

547

//--------------------------------------------------------------------------------

548

//

549

// end

550

//

551

//--------------------------------------------------------------------------------

552

int32_t RegexMatcher::end(UErrorCode &err) const {

553

return end(0, err);

554

}

555

556

int64_t RegexMatcher::end64(UErrorCode &err) const {

557

return end64(0, err);

558

}

559

560

int64_t RegexMatcher::end64(int32_t group, UErrorCode &err) const {

561

if (U_FAILURE(err)) {

562

return -1;

563

}

564

if (fMatch == FALSE0) {

565

err = U_REGEX_INVALID_STATE;

566

return -1;

567

}

568

if (group < 0 || group > fPattern->fGroupMap->size()) {

569

err = U_INDEX_OUTOFBOUNDS_ERROR;

570

return -1;

571

}

572

int64_t e = -1;

573

if (group == 0) {

574

e = fMatchEnd;

575

} else {

576

// Get the position within the stack frame of the variables for

577

// this capture group.

578

int32_t groupOffset = fPattern->fGroupMap->elementAti(group-1);

579

U_ASSERT(groupOffset < fPattern->fFrameSize)(void)0;

580

U_ASSERT(groupOffset >= 0)(void)0;

581

e = fFrame->fExtra[groupOffset + 1];

582

}

583

584

return e;

585

}

586

587

int32_t RegexMatcher::end(int32_t group, UErrorCode &err) const {

588

return (int32_t)end64(group, err);

589

}

590

591

//--------------------------------------------------------------------------------

592

//

593

// findProgressInterrupt This function is called once for each advance in the target

594

// string from the find() function, and calls the user progress callback

595

// function if there is one installed.

596

//

597

// Return: TRUE if the find operation is to be terminated.

598

// FALSE if the find operation is to continue running.

599

//

600

//--------------------------------------------------------------------------------

601

UBool RegexMatcher::findProgressInterrupt(int64_t pos, UErrorCode &status) {

602

if (fFindProgressCallbackFn && !(*fFindProgressCallbackFn)(fFindProgressCallbackContext, pos)) {

603

status = U_REGEX_STOPPED_BY_CALLER;

604

return TRUE1;

605

}

606

return FALSE0;

607

}

608

609

//--------------------------------------------------------------------------------

610

//

611

// find()

612

//

613

//--------------------------------------------------------------------------------

614

UBool RegexMatcher::find() {

615

if (U_FAILURE(fDeferredStatus)) {

616

return FALSE0;

617

}

618

UErrorCode status = U_ZERO_ERROR;

619

UBool result = find(status);

620

return result;

621

}

622

623

//--------------------------------------------------------------------------------

624

//

625

// find()

626

//

627

//--------------------------------------------------------------------------------

628

UBool RegexMatcher::find(UErrorCode &status) {

629

// Start at the position of the last match end. (Will be zero if the

630

// matcher has been reset.)

631

//

632

if (U_FAILURE(status)) {

633

return FALSE0;

634

}

635

if (U_FAILURE(fDeferredStatus)) {

636

status = fDeferredStatus;

637

return FALSE0;

638

}

639

640

if (UTEXT_FULL_TEXT_IN_CHUNK(fInputText, fInputLength)((0==((fInputText)->chunkNativeStart))&&((fInputLength
)==((fInputText)->chunkNativeLimit))&&((fInputLength
)==((fInputText)->nativeIndexingLimit)))) {

641

return findUsingChunk(status);

642

}

643

644

int64_t startPos = fMatchEnd;

645

if (startPos==0) {

646

startPos = fActiveStart;

647

}

648

649

if (fMatch) {

650

// Save the position of any previous successful match.

651

fLastMatchEnd = fMatchEnd;

652

653

if (fMatchStart == fMatchEnd) {

654

// Previous match had zero length. Move start position up one position

655

// to avoid sending find() into a loop on zero-length matches.

656

if (startPos >= fActiveLimit) {

657

fMatch = FALSE0;

658

fHitEnd = TRUE1;

659

return FALSE0;

660

}

661

UTEXT_SETNATIVEINDEX(fInputText, startPos)do { int64_t __offset = (startPos) - (fInputText)->chunkNativeStart
; if (__offset>=0 && __offset<(int64_t)(fInputText
)->nativeIndexingLimit && (fInputText)->chunkContents
[__offset]<0xdc00) { (fInputText)->chunkOffset=(int32_t
)__offset; } else { utext_setNativeIndex_71((fInputText), (startPos
)); } } while (false);

662

(void)UTEXT_NEXT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)++] : utext_next32_71(fInputText));

663

startPos = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

664

}

665

} else {

666

if (fLastMatchEnd >= 0) {

667

// A previous find() failed to match. Don't try again.

668

// (without this test, a pattern with a zero-length match

669

// could match again at the end of an input string.)

670

fHitEnd = TRUE1;

671

return FALSE0;

672

}

673

}

674

675

676

// Compute the position in the input string beyond which a match can not begin, because

677

// the minimum length match would extend past the end of the input.

678

// Note: some patterns that cannot match anything will have fMinMatchLength==Max Int.

679

// Be aware of possible overflows if making changes here.

680

int64_t testStartLimit;

681

if (UTEXT_USES_U16(fInputText)(__null==((fInputText)->pFuncs->mapNativeIndexToUTF16))) {

682

testStartLimit = fActiveLimit - fPattern->fMinMatchLen;

683

if (startPos > testStartLimit) {

684

fMatch = FALSE0;

685

fHitEnd = TRUE1;

686

return FALSE0;

687

}

688

} else {

689

// We don't know exactly how long the minimum match length is in native characters.

690

// Treat anything > 0 as 1.

691

testStartLimit = fActiveLimit - (fPattern->fMinMatchLen > 0 ? 1 : 0);

692

}

693

694

UChar32 c;

695

U_ASSERT(startPos >= 0)(void)0;

696

697

switch (fPattern->fStartType) {

698

case START_NO_INFO:

699

// No optimization was found.

700

// Try a match at each input position.

701

for (;;) {

702

MatchAt(startPos, FALSE0, status);

703

if (U_FAILURE(status)) {

704

return FALSE0;

705

}

706

if (fMatch) {

707

return TRUE1;

708

}

709

if (startPos >= testStartLimit) {

710

fHitEnd = TRUE1;

711

return FALSE0;

712

}

713

UTEXT_SETNATIVEINDEX(fInputText, startPos)do { int64_t __offset = (startPos) - (fInputText)->chunkNativeStart
; if (__offset>=0 && __offset<(int64_t)(fInputText
)->nativeIndexingLimit && (fInputText)->chunkContents
[__offset]<0xdc00) { (fInputText)->chunkOffset=(int32_t
)__offset; } else { utext_setNativeIndex_71((fInputText), (startPos
)); } } while (false);

714

(void)UTEXT_NEXT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)++] : utext_next32_71(fInputText));

715

startPos = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

716

// Note that it's perfectly OK for a pattern to have a zero-length

717

// match at the end of a string, so we must make sure that the loop

718

// runs with startPos == testStartLimit the last time through.

719

if (findProgressInterrupt(startPos, status))

720

return FALSE0;

721

}

722

UPRV_UNREACHABLE_EXITabort();

723

724

case START_START:

725

// Matches are only possible at the start of the input string

726

// (pattern begins with ^ or \A)

727

if (startPos > fActiveStart) {

728

fMatch = FALSE0;

729

return FALSE0;

730

}

731

MatchAt(startPos, FALSE0, status);

732

if (U_FAILURE(status)) {

733

return FALSE0;

734

}

735

return fMatch;

736

737

738

case START_SET:

739

{

740

// Match may start on any char from a pre-computed set.

741

U_ASSERT(fPattern->fMinMatchLen > 0)(void)0;

742

UTEXT_SETNATIVEINDEX(fInputText, startPos)do { int64_t __offset = (startPos) - (fInputText)->chunkNativeStart
; if (__offset>=0 && __offset<(int64_t)(fInputText
)->nativeIndexingLimit && (fInputText)->chunkContents
[__offset]<0xdc00) { (fInputText)->chunkOffset=(int32_t
)__offset; } else { utext_setNativeIndex_71((fInputText), (startPos
)); } } while (false);

743

for (;;) {

744

int64_t pos = startPos;

745

c = UTEXT_NEXT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)++] : utext_next32_71(fInputText));

746

startPos = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

747

// c will be -1 (U_SENTINEL) at end of text, in which case we

748

// skip this next block (so we don't have a negative array index)

749

// and handle end of text in the following block.

750

if (c >= 0 && ((c<256 && fPattern->fInitialChars8->contains(c)) ||

751

(c>=256 && fPattern->fInitialChars->contains(c)))) {

752

MatchAt(pos, FALSE0, status);

753

if (U_FAILURE(status)) {

754

return FALSE0;

755

}

756

if (fMatch) {

757

return TRUE1;

758

}

759

UTEXT_SETNATIVEINDEX(fInputText, pos)do { int64_t __offset = (pos) - (fInputText)->chunkNativeStart
; if (__offset>=0 && __offset<(int64_t)(fInputText
)->nativeIndexingLimit && (fInputText)->chunkContents
[__offset]<0xdc00) { (fInputText)->chunkOffset=(int32_t
)__offset; } else { utext_setNativeIndex_71((fInputText), (pos
)); } } while (false);

760

}

761

if (startPos > testStartLimit) {

762

fMatch = FALSE0;

763

fHitEnd = TRUE1;

764

return FALSE0;

765

}

766

if (findProgressInterrupt(startPos, status))

767

return FALSE0;

768

}

769

}

770

UPRV_UNREACHABLE_EXITabort();

771

772

case START_STRING:

773

case START_CHAR:

774

{

775

// Match starts on exactly one char.

776

U_ASSERT(fPattern->fMinMatchLen > 0)(void)0;

777

UChar32 theChar = fPattern->fInitialChar;

778

UTEXT_SETNATIVEINDEX(fInputText, startPos)do { int64_t __offset = (startPos) - (fInputText)->chunkNativeStart
; if (__offset>=0 && __offset<(int64_t)(fInputText
)->nativeIndexingLimit && (fInputText)->chunkContents
[__offset]<0xdc00) { (fInputText)->chunkOffset=(int32_t
)__offset; } else { utext_setNativeIndex_71((fInputText), (startPos
)); } } while (false);

779

for (;;) {

780

int64_t pos = startPos;

781

c = UTEXT_NEXT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)++] : utext_next32_71(fInputText));

782

startPos = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

783

if (c == theChar) {

784

MatchAt(pos, FALSE0, status);

785

if (U_FAILURE(status)) {

786

return FALSE0;

787

}

788

if (fMatch) {

789

return TRUE1;

790

}

791

UTEXT_SETNATIVEINDEX(fInputText, startPos)do { int64_t __offset = (startPos) - (fInputText)->chunkNativeStart
; if (__offset>=0 && __offset<(int64_t)(fInputText
)->nativeIndexingLimit && (fInputText)->chunkContents
[__offset]<0xdc00) { (fInputText)->chunkOffset=(int32_t
)__offset; } else { utext_setNativeIndex_71((fInputText), (startPos
)); } } while (false);

792

}

793

if (startPos > testStartLimit) {

794

fMatch = FALSE0;

795

fHitEnd = TRUE1;

796

return FALSE0;

797

}

798

if (findProgressInterrupt(startPos, status))

799

return FALSE0;

800

}

801

}

802

UPRV_UNREACHABLE_EXITabort();

803

804

case START_LINE:

805

{

806

UChar32 ch;

807

if (startPos == fAnchorStart) {

808

MatchAt(startPos, FALSE0, status);

809

if (U_FAILURE(status)) {

810

return FALSE0;

811

}

812

if (fMatch) {

813

return TRUE1;

814

}

815

UTEXT_SETNATIVEINDEX(fInputText, startPos)do { int64_t __offset = (startPos) - (fInputText)->chunkNativeStart
; if (__offset>=0 && __offset<(int64_t)(fInputText
)->nativeIndexingLimit && (fInputText)->chunkContents
[__offset]<0xdc00) { (fInputText)->chunkOffset=(int32_t
)__offset; } else { utext_setNativeIndex_71((fInputText), (startPos
)); } } while (false);

816

ch = UTEXT_NEXT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)++] : utext_next32_71(fInputText));

817

startPos = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

818

} else {

819

UTEXT_SETNATIVEINDEX(fInputText, startPos)do { int64_t __offset = (startPos) - (fInputText)->chunkNativeStart
; if (__offset>=0 && __offset<(int64_t)(fInputText
)->nativeIndexingLimit && (fInputText)->chunkContents
[__offset]<0xdc00) { (fInputText)->chunkOffset=(int32_t
)__offset; } else { utext_setNativeIndex_71((fInputText), (startPos
)); } } while (false);

820

ch = UTEXT_PREVIOUS32(fInputText)((fInputText)->chunkOffset > 0 && (fInputText)->
chunkContents[(fInputText)->chunkOffset-1] < 0xd800 ? (
fInputText)->chunkContents[--((fInputText)->chunkOffset
)] : utext_previous32_71(fInputText));

821

UTEXT_SETNATIVEINDEX(fInputText, startPos)do { int64_t __offset = (startPos) - (fInputText)->chunkNativeStart
; if (__offset>=0 && __offset<(int64_t)(fInputText
)->nativeIndexingLimit && (fInputText)->chunkContents
[__offset]<0xdc00) { (fInputText)->chunkOffset=(int32_t
)__offset; } else { utext_setNativeIndex_71((fInputText), (startPos
)); } } while (false);

822

}

823

824

if (fPattern->fFlags & UREGEX_UNIX_LINES) {

825

for (;;) {

826

if (ch == 0x0a) {

827

MatchAt(startPos, FALSE0, status);

828

if (U_FAILURE(status)) {

829

return FALSE0;

830

}

831

if (fMatch) {

832

return TRUE1;

833

}

834

UTEXT_SETNATIVEINDEX(fInputText, startPos)do { int64_t __offset = (startPos) - (fInputText)->chunkNativeStart
; if (__offset>=0 && __offset<(int64_t)(fInputText
)->nativeIndexingLimit && (fInputText)->chunkContents
[__offset]<0xdc00) { (fInputText)->chunkOffset=(int32_t
)__offset; } else { utext_setNativeIndex_71((fInputText), (startPos
)); } } while (false);

835

}

836

if (startPos >= testStartLimit) {

837

fMatch = FALSE0;

838

fHitEnd = TRUE1;

839

return FALSE0;

840

}

841

ch = UTEXT_NEXT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)++] : utext_next32_71(fInputText));

842

startPos = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

843

// Note that it's perfectly OK for a pattern to have a zero-length

844

// match at the end of a string, so we must make sure that the loop

845

// runs with startPos == testStartLimit the last time through.

846

if (findProgressInterrupt(startPos, status))

847

return FALSE0;

848

}

849

} else {

850

for (;;) {

851

if (isLineTerminator(ch)) {

852

if (ch == 0x0d && startPos < fActiveLimit && UTEXT_CURRENT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)] : utext_current32_71(fInputText)) == 0x0a) {

853

(void)UTEXT_NEXT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)++] : utext_next32_71(fInputText));

854

startPos = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

855

}

856

MatchAt(startPos, FALSE0, status);

857

if (U_FAILURE(status)) {

858

return FALSE0;

859

}

860

if (fMatch) {

861

return TRUE1;

862

}

863

UTEXT_SETNATIVEINDEX(fInputText, startPos)do { int64_t __offset = (startPos) - (fInputText)->chunkNativeStart
; if (__offset>=0 && __offset<(int64_t)(fInputText
)->nativeIndexingLimit && (fInputText)->chunkContents
[__offset]<0xdc00) { (fInputText)->chunkOffset=(int32_t
)__offset; } else { utext_setNativeIndex_71((fInputText), (startPos
)); } } while (false);

864

}

865

if (startPos >= testStartLimit) {

866

fMatch = FALSE0;

867

fHitEnd = TRUE1;

868

return FALSE0;

869

}

870

ch = UTEXT_NEXT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)++] : utext_next32_71(fInputText));

871

startPos = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

872

// Note that it's perfectly OK for a pattern to have a zero-length

873

// match at the end of a string, so we must make sure that the loop

874

// runs with startPos == testStartLimit the last time through.

875

if (findProgressInterrupt(startPos, status))

876

return FALSE0;

877

}

878

}

879

}

880

881

default:

882

UPRV_UNREACHABLE_ASSERT(void)0;

883

// Unknown value in fPattern->fStartType, should be from StartOfMatch enum. But

884

// we have reports of this in production code, don't use UPRV_UNREACHABLE_EXIT.

885

// See ICU-21669.

886

status = U_INTERNAL_PROGRAM_ERROR;

887

return FALSE0;

888

}

889

890

UPRV_UNREACHABLE_EXITabort();

891

}

892

893

894

895

UBool RegexMatcher::find(int64_t start, UErrorCode &status) {

896

if (U_FAILURE(status)) {

897

return FALSE0;

898

}

899

if (U_FAILURE(fDeferredStatus)) {

900

status = fDeferredStatus;

901

return FALSE0;

902

}

903

this->reset(); // Note: Reset() is specified by Java Matcher documentation.

904

// This will reset the region to be the full input length.

905

if (start < 0) {

906

status = U_INDEX_OUTOFBOUNDS_ERROR;

907

return FALSE0;

908

}

909

910

int64_t nativeStart = start;

911

if (nativeStart < fActiveStart || nativeStart > fActiveLimit) {

912

status = U_INDEX_OUTOFBOUNDS_ERROR;

913

return FALSE0;

914

}

915

fMatchEnd = nativeStart;

916

return find(status);

917

}

918

919

920

//--------------------------------------------------------------------------------

921

//

922

// findUsingChunk() -- like find(), but with the advance knowledge that the

923

// entire string is available in the UText's chunk buffer.

924

//

925

//--------------------------------------------------------------------------------

926

UBool RegexMatcher::findUsingChunk(UErrorCode &status) {

927

// Start at the position of the last match end. (Will be zero if the

928

// matcher has been reset.

929

//

930

931

int32_t startPos = (int32_t)fMatchEnd;

932

if (startPos==0) {

933

startPos = (int32_t)fActiveStart;

934

}

935

936

const UChar *inputBuf = fInputText->chunkContents;

937

938

if (fMatch) {

939

// Save the position of any previous successful match.

940

fLastMatchEnd = fMatchEnd;

941

942

if (fMatchStart == fMatchEnd) {

943

// Previous match had zero length. Move start position up one position

944

// to avoid sending find() into a loop on zero-length matches.

945

if (startPos >= fActiveLimit) {

946

fMatch = FALSE0;

947

fHitEnd = TRUE1;

948

return FALSE0;

949

}

950

U16_FWD_1(inputBuf, startPos, fInputLength)do { if(((((inputBuf)[(startPos)++])&0xfffffc00)==0xd800)
&& (startPos)!=(fInputLength) && ((((inputBuf
)[startPos])&0xfffffc00)==0xdc00)) { ++(startPos); } } while
(false);

951

}

952

} else {

953

if (fLastMatchEnd >= 0) {

954

// A previous find() failed to match. Don't try again.

955

// (without this test, a pattern with a zero-length match

956

// could match again at the end of an input string.)

957

fHitEnd = TRUE1;

958

return FALSE0;

959

}

960

}

961

962

963

// Compute the position in the input string beyond which a match can not begin, because

964

// the minimum length match would extend past the end of the input.

965

// Note: some patterns that cannot match anything will have fMinMatchLength==Max Int.

966

// Be aware of possible overflows if making changes here.

967

// Note: a match can begin at inputBuf + testLen; it is an inclusive limit.

968

int32_t testLen = (int32_t)(fActiveLimit - fPattern->fMinMatchLen);

969

if (startPos > testLen) {

970

fMatch = FALSE0;

971

fHitEnd = TRUE1;

972

return FALSE0;

973

}

974

975

UChar32 c;

976

U_ASSERT(startPos >= 0)(void)0;

977

978

switch (fPattern->fStartType) {

979

case START_NO_INFO:

980

// No optimization was found.

981

// Try a match at each input position.

982

for (;;) {

983

MatchChunkAt(startPos, FALSE0, status);

984

if (U_FAILURE(status)) {

985

return FALSE0;

986

}

987

if (fMatch) {

988

return TRUE1;

989

}

990

if (startPos >= testLen) {

991

fHitEnd = TRUE1;

992

return FALSE0;

993

}

994

U16_FWD_1(inputBuf, startPos, fActiveLimit)do { if(((((inputBuf)[(startPos)++])&0xfffffc00)==0xd800)
&& (startPos)!=(fActiveLimit) && ((((inputBuf
)[startPos])&0xfffffc00)==0xdc00)) { ++(startPos); } } while
(false);

995

// Note that it's perfectly OK for a pattern to have a zero-length

996

// match at the end of a string, so we must make sure that the loop

997

// runs with startPos == testLen the last time through.

998

if (findProgressInterrupt(startPos, status))

999

return FALSE0;

1000

}

1001

UPRV_UNREACHABLE_EXITabort();

1002

1003

case START_START:

1004

// Matches are only possible at the start of the input string

1005

// (pattern begins with ^ or \A)

1006

if (startPos > fActiveStart) {

1007

fMatch = FALSE0;

1008

return FALSE0;

1009

}

1010

MatchChunkAt(startPos, FALSE0, status);

1011

if (U_FAILURE(status)) {

1012

return FALSE0;

1013

}

1014

return fMatch;

1015

1016

1017

case START_SET:

1018

{

1019

// Match may start on any char from a pre-computed set.

1020

U_ASSERT(fPattern->fMinMatchLen > 0)(void)0;

1021

for (;;) {

1022

int32_t pos = startPos;

1023

U16_NEXT(inputBuf, startPos, fActiveLimit, c)do { (c)=(inputBuf)[(startPos)++]; if((((c)&0xfffffc00)==
0xd800)) { uint16_t __c2; if((startPos)!=(fActiveLimit) &&
(((__c2=(inputBuf)[(startPos)])&0xfffffc00)==0xdc00)) { ++
(startPos); (c)=(((UChar32)((c))<<10UL)+(UChar32)(__c2)
-((0xd800<<10UL)+0xdc00-0x10000)); } } } while (false); // like c = inputBuf[startPos++];

1024

if ((c<256 && fPattern->fInitialChars8->contains(c)) ||

1025

(c>=256 && fPattern->fInitialChars->contains(c))) {

1026

MatchChunkAt(pos, FALSE0, status);

1027

if (U_FAILURE(status)) {

1028

return FALSE0;

1029

}

1030

if (fMatch) {

1031

return TRUE1;

1032

}

1033

}

1034

if (startPos > testLen) {

1035

fMatch = FALSE0;

1036

fHitEnd = TRUE1;

1037

return FALSE0;

1038

}

1039

if (findProgressInterrupt(startPos, status))

1040

return FALSE0;

1041

}

1042

}

1043

UPRV_UNREACHABLE_EXITabort();

1044

1045

case START_STRING:

1046

case START_CHAR:

1047

{

1048

// Match starts on exactly one char.

1049

U_ASSERT(fPattern->fMinMatchLen > 0)(void)0;

1050

UChar32 theChar = fPattern->fInitialChar;

1051

for (;;) {

1052

int32_t pos = startPos;

1053

U16_NEXT(inputBuf, startPos, fActiveLimit, c)do { (c)=(inputBuf)[(startPos)++]; if((((c)&0xfffffc00)==
0xd800)) { uint16_t __c2; if((startPos)!=(fActiveLimit) &&
(((__c2=(inputBuf)[(startPos)])&0xfffffc00)==0xdc00)) { ++
(startPos); (c)=(((UChar32)((c))<<10UL)+(UChar32)(__c2)
-((0xd800<<10UL)+0xdc00-0x10000)); } } } while (false); // like c = inputBuf[startPos++];

1054

if (c == theChar) {

1055

MatchChunkAt(pos, FALSE0, status);

1056

if (U_FAILURE(status)) {

1057

return FALSE0;

1058

}

1059

if (fMatch) {

1060

return TRUE1;

1061

}

1062

}

1063

if (startPos > testLen) {

1064

fMatch = FALSE0;

1065

fHitEnd = TRUE1;

1066

return FALSE0;

1067

}

1068

if (findProgressInterrupt(startPos, status))

1069

return FALSE0;

1070

}

1071

}

1072

UPRV_UNREACHABLE_EXITabort();

1073

1074

case START_LINE:

1075

{

1076

UChar32 ch;

1077

if (startPos == fAnchorStart) {

1078

MatchChunkAt(startPos, FALSE0, status);

1079

if (U_FAILURE(status)) {

1080

return FALSE0;

1081

}

1082

if (fMatch) {

1083

return TRUE1;

1084

}

1085

U16_FWD_1(inputBuf, startPos, fActiveLimit)do { if(((((inputBuf)[(startPos)++])&0xfffffc00)==0xd800)
&& (startPos)!=(fActiveLimit) && ((((inputBuf
)[startPos])&0xfffffc00)==0xdc00)) { ++(startPos); } } while
(false);

1086

}

1087

1088

if (fPattern->fFlags & UREGEX_UNIX_LINES) {

1089

for (;;) {

1090

ch = inputBuf[startPos-1];

1091

if (ch == 0x0a) {

1092

MatchChunkAt(startPos, FALSE0, status);

1093

if (U_FAILURE(status)) {

1094

return FALSE0;

1095

}

1096

if (fMatch) {

1097

return TRUE1;

1098

}

1099

}

1100

if (startPos >= testLen) {

1101

fMatch = FALSE0;

1102

fHitEnd = TRUE1;

1103

return FALSE0;

1104

}

1105

U16_FWD_1(inputBuf, startPos, fActiveLimit)do { if(((((inputBuf)[(startPos)++])&0xfffffc00)==0xd800)
&& (startPos)!=(fActiveLimit) && ((((inputBuf
)[startPos])&0xfffffc00)==0xdc00)) { ++(startPos); } } while
(false);

1106

// Note that it's perfectly OK for a pattern to have a zero-length

1107

// match at the end of a string, so we must make sure that the loop

1108

// runs with startPos == testLen the last time through.

1109

if (findProgressInterrupt(startPos, status))

1110

return FALSE0;

1111

}

1112

} else {

1113

for (;;) {

1114

ch = inputBuf[startPos-1];

1115

if (isLineTerminator(ch)) {

1116

if (ch == 0x0d && startPos < fActiveLimit && inputBuf[startPos] == 0x0a) {

1117

startPos++;

1118

}

1119

MatchChunkAt(startPos, FALSE0, status);

1120

if (U_FAILURE(status)) {

1121

return FALSE0;

1122

}

1123

if (fMatch) {

1124

return TRUE1;

1125

}

1126

}

1127

if (startPos >= testLen) {

1128

fMatch = FALSE0;

1129

fHitEnd = TRUE1;

1130

return FALSE0;

1131

}

1132

U16_FWD_1(inputBuf, startPos, fActiveLimit)do { if(((((inputBuf)[(startPos)++])&0xfffffc00)==0xd800)
&& (startPos)!=(fActiveLimit) && ((((inputBuf
)[startPos])&0xfffffc00)==0xdc00)) { ++(startPos); } } while
(false);

1133

// Note that it's perfectly OK for a pattern to have a zero-length

1134

// match at the end of a string, so we must make sure that the loop

1135

// runs with startPos == testLen the last time through.

1136

if (findProgressInterrupt(startPos, status))

1137

return FALSE0;

1138

}

1139

}

1140

}

1141

1142

default:

1143

UPRV_UNREACHABLE_ASSERT(void)0;

1144

// Unknown value in fPattern->fStartType, should be from StartOfMatch enum. But

1145

// we have reports of this in production code, don't use UPRV_UNREACHABLE_EXIT.

1146

// See ICU-21669.

1147

status = U_INTERNAL_PROGRAM_ERROR;

1148

return FALSE0;

1149

}

1150

1151

UPRV_UNREACHABLE_EXITabort();

1152

}

1153

1154

1155

1156

//--------------------------------------------------------------------------------

1157

//

1158

// group()

1159

//

1160

//--------------------------------------------------------------------------------

1161

UnicodeString RegexMatcher::group(UErrorCode &status) const {

1162

return group(0, status);

1163

}

1164

1165

// Return immutable shallow clone

1166

UText *RegexMatcher::group(UText *dest, int64_t &group_len, UErrorCode &status) const {

1167

return group(0, dest, group_len, status);

1168

}

1169

1170

// Return immutable shallow clone

1171

UText *RegexMatcher::group(int32_t groupNum, UText *dest, int64_t &group_len, UErrorCode &status) const {

1172

group_len = 0;

1173

if (U_FAILURE(status)) {

1174

return dest;

1175

}

1176

if (U_FAILURE(fDeferredStatus)) {

1177

status = fDeferredStatus;

1178

} else if (fMatch == FALSE0) {

1179

status = U_REGEX_INVALID_STATE;

1180

} else if (groupNum < 0 || groupNum > fPattern->fGroupMap->size()) {

1181

status = U_INDEX_OUTOFBOUNDS_ERROR;

1182

}

1183

1184

if (U_FAILURE(status)) {

1185

return dest;

1186

}

1187

1188

int64_t s, e;

1189

if (groupNum == 0) {

1190

s = fMatchStart;

1191

e = fMatchEnd;

1192

} else {

1193

int32_t groupOffset = fPattern->fGroupMap->elementAti(groupNum-1);

1194

U_ASSERT(groupOffset < fPattern->fFrameSize)(void)0;

1195

U_ASSERT(groupOffset >= 0)(void)0;

1196

s = fFrame->fExtra[groupOffset];

1197

e = fFrame->fExtra[groupOffset+1];

1198

}

1199

1200

if (s < 0) {

1201

// A capture group wasn't part of the match

1202

return utext_cloneutext_clone_71(dest, fInputText, FALSE0, TRUE1, &status);

1203

}

1204

U_ASSERT(s <= e)(void)0;

1205

group_len = e - s;

1206

1207

dest = utext_cloneutext_clone_71(dest, fInputText, FALSE0, TRUE1, &status);

1208

if (dest)

1209

UTEXT_SETNATIVEINDEX(dest, s)do { int64_t __offset = (s) - (dest)->chunkNativeStart; if
(__offset>=0 && __offset<(int64_t)(dest)->nativeIndexingLimit
&& (dest)->chunkContents[__offset]<0xdc00) { (
dest)->chunkOffset=(int32_t)__offset; } else { utext_setNativeIndex_71
((dest), (s)); } } while (false);

1210

return dest;

1211

}

1212

1213

UnicodeString RegexMatcher::group(int32_t groupNum, UErrorCode &status) const {

1214

UnicodeString result;

1215

int64_t groupStart = start64(groupNum, status);

1216

int64_t groupEnd = end64(groupNum, status);

1217

if (U_FAILURE(status) || groupStart == -1 || groupStart == groupEnd) {

1218

return result;

1219

}

1220

1221

// Get the group length using a utext_extract preflight.

1222

// UText is actually pretty efficient at this when underlying encoding is UTF-16.

1223

int32_t length = utext_extractutext_extract_71(fInputText, groupStart, groupEnd, NULL__null, 0, &status);

1224

if (status != U_BUFFER_OVERFLOW_ERROR) {

1225

return result;

1226

}

1227

1228

status = U_ZERO_ERROR;

1229

UChar *buf = result.getBuffer(length);

1230

if (buf == NULL__null) {

1231

status = U_MEMORY_ALLOCATION_ERROR;

1232

} else {

1233

int32_t extractLength = utext_extractutext_extract_71(fInputText, groupStart, groupEnd, buf, length, &status);

1234

result.releaseBuffer(extractLength);

1235

U_ASSERT(length == extractLength)(void)0;

1236

}

1237

return result;

1238

}

1239

1240

1241

//--------------------------------------------------------------------------------

1242

//

1243

// appendGroup() -- currently internal only, appends a group to a UText rather

1244

// than replacing its contents

1245

//

1246

//--------------------------------------------------------------------------------

1247

1248

int64_t RegexMatcher::appendGroup(int32_t groupNum, UText *dest, UErrorCode &status) const {

1249

if (U_FAILURE(status)) {

1250

return 0;

1251

}

1252

if (U_FAILURE(fDeferredStatus)) {

1253

status = fDeferredStatus;

1254

return 0;

1255

}

1256

int64_t destLen = utext_nativeLengthutext_nativeLength_71(dest);

1257

1258

if (fMatch == FALSE0) {

1259

status = U_REGEX_INVALID_STATE;

1260

return utext_replaceutext_replace_71(dest, destLen, destLen, NULL__null, 0, &status);

1261

}

1262

if (groupNum < 0 || groupNum > fPattern->fGroupMap->size()) {

1263

status = U_INDEX_OUTOFBOUNDS_ERROR;

1264

return utext_replaceutext_replace_71(dest, destLen, destLen, NULL__null, 0, &status);

1265

}

1266

1267

int64_t s, e;

1268

if (groupNum == 0) {

1269

s = fMatchStart;

1270

e = fMatchEnd;

1271

} else {

1272

int32_t groupOffset = fPattern->fGroupMap->elementAti(groupNum-1);

1273

U_ASSERT(groupOffset < fPattern->fFrameSize)(void)0;

1274

U_ASSERT(groupOffset >= 0)(void)0;

1275

s = fFrame->fExtra[groupOffset];

1276

e = fFrame->fExtra[groupOffset+1];

1277

}

1278

1279

if (s < 0) {

1280

// A capture group wasn't part of the match

1281

return utext_replaceutext_replace_71(dest, destLen, destLen, NULL__null, 0, &status);

1282

}

1283

U_ASSERT(s <= e)(void)0;

1284

1285

int64_t deltaLen;

1286

if (UTEXT_FULL_TEXT_IN_CHUNK(fInputText, fInputLength)((0==((fInputText)->chunkNativeStart))&&((fInputLength
)==((fInputText)->chunkNativeLimit))&&((fInputLength
)==((fInputText)->nativeIndexingLimit)))) {

1287

U_ASSERT(e <= fInputLength)(void)0;

1288

deltaLen = utext_replaceutext_replace_71(dest, destLen, destLen, fInputText->chunkContents+s, (int32_t)(e-s), &status);

1289

} else {

1290

int32_t len16;

1291

if (UTEXT_USES_U16(fInputText)(__null==((fInputText)->pFuncs->mapNativeIndexToUTF16))) {

1292

len16 = (int32_t)(e-s);

1293

} else {

1294

UErrorCode lengthStatus = U_ZERO_ERROR;

1295

len16 = utext_extractutext_extract_71(fInputText, s, e, NULL__null, 0, &lengthStatus);

1296

}

1297

UChar *groupChars = (UChar *)uprv_mallocuprv_malloc_71(sizeof(UChar)*(len16+1));

1298

if (groupChars == NULL__null) {

1299

status = U_MEMORY_ALLOCATION_ERROR;

1300

return 0;

1301

}

1302

utext_extractutext_extract_71(fInputText, s, e, groupChars, len16+1, &status);

1303

1304

deltaLen = utext_replaceutext_replace_71(dest, destLen, destLen, groupChars, len16, &status);

1305

uprv_freeuprv_free_71(groupChars);

1306

}

1307

return deltaLen;

1308

}

1309

1310

1311

1312

//--------------------------------------------------------------------------------

1313

//

1314

// groupCount()

1315

//

1316

//--------------------------------------------------------------------------------

1317

int32_t RegexMatcher::groupCount() const {

1318

return fPattern->fGroupMap->size();

1319

}

1320

1321

//--------------------------------------------------------------------------------

1322

//

1323

// hasAnchoringBounds()

1324

//

1325

//--------------------------------------------------------------------------------

1326

UBool RegexMatcher::hasAnchoringBounds() const {

1327

return fAnchoringBounds;

1328

}

1329

1330

1331

//--------------------------------------------------------------------------------

1332

//

1333

// hasTransparentBounds()

1334

//

1335

//--------------------------------------------------------------------------------

1336

UBool RegexMatcher::hasTransparentBounds() const {

1337

return fTransparentBounds;

1338

}

1339

1340

1341

1342

//--------------------------------------------------------------------------------

1343

//

1344

// hitEnd()

1345

//

1346

//--------------------------------------------------------------------------------

1347

UBool RegexMatcher::hitEnd() const {

1348

return fHitEnd;

1349

}

1350

1351

1352

//--------------------------------------------------------------------------------

1353

//

1354

// input()

1355

//

1356

//--------------------------------------------------------------------------------

1357

const UnicodeString &RegexMatcher::input() const {

1358

if (!fInput) {

1359

UErrorCode status = U_ZERO_ERROR;

1360

int32_t len16;

1361

if (UTEXT_USES_U16(fInputText)(__null==((fInputText)->pFuncs->mapNativeIndexToUTF16))) {

1362

len16 = (int32_t)fInputLength;

1363

} else {

1364

len16 = utext_extractutext_extract_71(fInputText, 0, fInputLength, NULL__null, 0, &status);

1365

status = U_ZERO_ERROR; // overflow, length status

1366

}

1367

UnicodeString *result = new UnicodeString(len16, 0, 0);

1368

1369

UChar *inputChars = result->getBuffer(len16);

1370

utext_extractutext_extract_71(fInputText, 0, fInputLength, inputChars, len16, &status); // unterminated warning

1371

result->releaseBuffer(len16);

1372

1373

(*(const UnicodeString **)&fInput) = result; // pointer assignment, rather than operator=

1374

}

1375

1376

return *fInput;

1377

}

1378

1379

//--------------------------------------------------------------------------------

1380

//

1381

// inputText()

1382

//

1383

//--------------------------------------------------------------------------------

1384

UText *RegexMatcher::inputText() const {

1385

return fInputText;

1386

}

1387

1388

1389

//--------------------------------------------------------------------------------

1390

//

1391

// getInput() -- like inputText(), but makes a clone or copies into another UText

1392

//

1393

//--------------------------------------------------------------------------------

1394

UText *RegexMatcher::getInput (UText *dest, UErrorCode &status) const {

1395

if (U_FAILURE(status)) {

1396

return dest;

1397

}

1398

if (U_FAILURE(fDeferredStatus)) {

1399

status = fDeferredStatus;

1400

return dest;

1401

}

1402

1403

if (dest) {

1404

if (UTEXT_FULL_TEXT_IN_CHUNK(fInputText, fInputLength)((0==((fInputText)->chunkNativeStart))&&((fInputLength
)==((fInputText)->chunkNativeLimit))&&((fInputLength
)==((fInputText)->nativeIndexingLimit)))) {

1405

utext_replaceutext_replace_71(dest, 0, utext_nativeLengthutext_nativeLength_71(dest), fInputText->chunkContents, (int32_t)fInputLength, &status);

1406

} else {

1407

int32_t input16Len;

1408

if (UTEXT_USES_U16(fInputText)(__null==((fInputText)->pFuncs->mapNativeIndexToUTF16))) {

1409

input16Len = (int32_t)fInputLength;

1410

} else {

1411

UErrorCode lengthStatus = U_ZERO_ERROR;

1412

input16Len = utext_extractutext_extract_71(fInputText, 0, fInputLength, NULL__null, 0, &lengthStatus); // buffer overflow error

1413

}

1414

UChar *inputChars = (UChar *)uprv_mallocuprv_malloc_71(sizeof(UChar)*(input16Len));

1415

if (inputChars == NULL__null) {

1416

return dest;

1417

}

1418

1419

status = U_ZERO_ERROR;

1420

utext_extractutext_extract_71(fInputText, 0, fInputLength, inputChars, input16Len, &status); // not terminated warning

1421

status = U_ZERO_ERROR;

1422

utext_replaceutext_replace_71(dest, 0, utext_nativeLengthutext_nativeLength_71(dest), inputChars, input16Len, &status);

1423

1424

uprv_freeuprv_free_71(inputChars);

1425

}

1426

return dest;

1427

} else {

1428

return utext_cloneutext_clone_71(NULL__null, fInputText, FALSE0, TRUE1, &status);

1429

}

1430

}

1431

1432

1433

static UBool compat_SyncMutableUTextContents(UText *ut);

1434

static UBool compat_SyncMutableUTextContents(UText *ut) {

1435

UBool retVal = FALSE0;

1436

1437

// In the following test, we're really only interested in whether the UText should switch

1438

// between heap and stack allocation. If length hasn't changed, we won't, so the chunkContents

1439

// will still point to the correct data.

1440

if (utext_nativeLengthutext_nativeLength_71(ut) != ut->nativeIndexingLimit) {

1441

UnicodeString *us=(UnicodeString *)ut->context;

1442

1443

// Update to the latest length.

1444

// For example, (utext_nativeLength(ut) != ut->nativeIndexingLimit).

1445

int32_t newLength = us->length();

1446

1447

// Update the chunk description.

1448

// The buffer may have switched between stack- and heap-based.

1449

ut->chunkContents = us->getBuffer();

1450

ut->chunkLength = newLength;

1451

ut->chunkNativeLimit = newLength;

1452

ut->nativeIndexingLimit = newLength;

1453

retVal = TRUE1;

1454

}

1455

1456

return retVal;

1457

}

1458

1459

//--------------------------------------------------------------------------------

1460

//

1461

// lookingAt()

1462

//

1463

//--------------------------------------------------------------------------------

1464

UBool RegexMatcher::lookingAt(UErrorCode &status) {

1465

if (U_FAILURE(status)) {

1466

return FALSE0;

1467

}

1468

if (U_FAILURE(fDeferredStatus)) {

1469

status = fDeferredStatus;

1470

return FALSE0;

1471

}

1472

1473

if (fInputUniStrMaybeMutable) {

1474

if (compat_SyncMutableUTextContents(fInputText)) {

1475

fInputLength = utext_nativeLengthutext_nativeLength_71(fInputText);

1476

reset();

1477

}

1478

}

1479

else {

1480

resetPreserveRegion();

1481

}

1482

if (UTEXT_FULL_TEXT_IN_CHUNK(fInputText, fInputLength)((0==((fInputText)->chunkNativeStart))&&((fInputLength
)==((fInputText)->chunkNativeLimit))&&((fInputLength
)==((fInputText)->nativeIndexingLimit)))) {

1483

MatchChunkAt((int32_t)fActiveStart, FALSE0, status);

1484

} else {

1485

MatchAt(fActiveStart, FALSE0, status);

1486

}

1487

return fMatch;

1488

}

1489

1490

1491

UBool RegexMatcher::lookingAt(int64_t start, UErrorCode &status) {

1492

if (U_FAILURE(status)) {

1493

return FALSE0;

1494

}

1495

if (U_FAILURE(fDeferredStatus)) {

1496

status = fDeferredStatus;

1497

return FALSE0;

1498

}

1499

reset();

1500

1501

if (start < 0) {

1502

status = U_INDEX_OUTOFBOUNDS_ERROR;

1503

return FALSE0;

1504

}

1505

1506

if (fInputUniStrMaybeMutable) {

1507

if (compat_SyncMutableUTextContents(fInputText)) {

1508

fInputLength = utext_nativeLengthutext_nativeLength_71(fInputText);

1509

reset();

1510

}

1511

}

1512

1513

int64_t nativeStart;

1514

nativeStart = start;

1515

if (nativeStart < fActiveStart || nativeStart > fActiveLimit) {

1516

status = U_INDEX_OUTOFBOUNDS_ERROR;

1517

return FALSE0;

1518

}

1519

1520

if (UTEXT_FULL_TEXT_IN_CHUNK(fInputText, fInputLength)((0==((fInputText)->chunkNativeStart))&&((fInputLength
)==((fInputText)->chunkNativeLimit))&&((fInputLength
)==((fInputText)->nativeIndexingLimit)))) {

1521

MatchChunkAt((int32_t)nativeStart, FALSE0, status);

1522

} else {

1523

MatchAt(nativeStart, FALSE0, status);

1524

}

1525

return fMatch;

1526

}

1527

1528

1529

1530

//--------------------------------------------------------------------------------

1531

//

1532

// matches()

1533

//

1534

//--------------------------------------------------------------------------------

1535

UBool RegexMatcher::matches(UErrorCode &status) {

1536

if (U_FAILURE(status)) {

1537

return FALSE0;

1538

}

1539

if (U_FAILURE(fDeferredStatus)) {

1540

status = fDeferredStatus;

1541

return FALSE0;

1542

}

1543

1544

if (fInputUniStrMaybeMutable) {

1545

if (compat_SyncMutableUTextContents(fInputText)) {

1546

fInputLength = utext_nativeLengthutext_nativeLength_71(fInputText);

1547

reset();

1548

}

1549

}

1550

else {

1551

resetPreserveRegion();

1552

}

1553

1554

if (UTEXT_FULL_TEXT_IN_CHUNK(fInputText, fInputLength)((0==((fInputText)->chunkNativeStart))&&((fInputLength
)==((fInputText)->chunkNativeLimit))&&((fInputLength
)==((fInputText)->nativeIndexingLimit)))) {

1555

MatchChunkAt((int32_t)fActiveStart, TRUE1, status);

1556

} else {

1557

MatchAt(fActiveStart, TRUE1, status);

1558

}

1559

return fMatch;

1560

}

1561

1562

1563

UBool RegexMatcher::matches(int64_t start, UErrorCode &status) {

1564

if (U_FAILURE(status)) {

1565

return FALSE0;

1566

}

1567

if (U_FAILURE(fDeferredStatus)) {

1568

status = fDeferredStatus;

1569

return FALSE0;

1570

}

1571

reset();

1572

1573

if (start < 0) {

1574

status = U_INDEX_OUTOFBOUNDS_ERROR;

1575

return FALSE0;

1576

}

1577

1578

if (fInputUniStrMaybeMutable) {

1579

if (compat_SyncMutableUTextContents(fInputText)) {

1580

fInputLength = utext_nativeLengthutext_nativeLength_71(fInputText);

1581

reset();

1582

}

1583

}

1584

1585

int64_t nativeStart;

1586

nativeStart = start;

1587

if (nativeStart < fActiveStart || nativeStart > fActiveLimit) {

1588

status = U_INDEX_OUTOFBOUNDS_ERROR;

1589

return FALSE0;

1590

}

1591

1592

if (UTEXT_FULL_TEXT_IN_CHUNK(fInputText, fInputLength)((0==((fInputText)->chunkNativeStart))&&((fInputLength
)==((fInputText)->chunkNativeLimit))&&((fInputLength
)==((fInputText)->nativeIndexingLimit)))) {

1593

MatchChunkAt((int32_t)nativeStart, TRUE1, status);

1594

} else {

1595

MatchAt(nativeStart, TRUE1, status);

1596

}

1597

return fMatch;

1598

}

1599

1600

1601

1602

//--------------------------------------------------------------------------------

1603

//

1604

// pattern

1605

//

1606

//--------------------------------------------------------------------------------

1607

const RegexPattern &RegexMatcher::pattern() const {

1608

return *fPattern;

1609

}

1610

1611

1612

1613

//--------------------------------------------------------------------------------

1614

//

1615

// region

1616

//

1617

//--------------------------------------------------------------------------------

1618

RegexMatcher &RegexMatcher::region(int64_t regionStart, int64_t regionLimit, int64_t startIndex, UErrorCode &status) {

1619

if (U_FAILURE(status)) {

1620

return *this;

1621

}

1622

1623

if (regionStart>regionLimit || regionStart<0 || regionLimit<0) {

1624

status = U_ILLEGAL_ARGUMENT_ERROR;

1625

}

1626

1627

int64_t nativeStart = regionStart;

1628

int64_t nativeLimit = regionLimit;

1629

if (nativeStart > fInputLength || nativeLimit > fInputLength) {

1630

status = U_ILLEGAL_ARGUMENT_ERROR;

1631

}

1632

1633

if (startIndex == -1)

1634

this->reset();

1635

else

1636

resetPreserveRegion();

1637

1638

fRegionStart = nativeStart;

1639

fRegionLimit = nativeLimit;

1640

fActiveStart = nativeStart;

1641

fActiveLimit = nativeLimit;

1642

1643

if (startIndex != -1) {

1644

if (startIndex < fActiveStart || startIndex > fActiveLimit) {

1645

status = U_INDEX_OUTOFBOUNDS_ERROR;

1646

}

1647

fMatchEnd = startIndex;

1648

}

1649

1650

if (!fTransparentBounds) {

1651

fLookStart = nativeStart;

1652

fLookLimit = nativeLimit;

1653

}

1654

if (fAnchoringBounds) {

1655

fAnchorStart = nativeStart;

1656

fAnchorLimit = nativeLimit;

1657

}

1658

return *this;

1659

}

1660

1661

RegexMatcher &RegexMatcher::region(int64_t start, int64_t limit, UErrorCode &status) {

1662

return region(start, limit, -1, status);

1663

}

1664

1665

//--------------------------------------------------------------------------------

1666

//

1667

// regionEnd

1668

//

1669

//--------------------------------------------------------------------------------

1670

int32_t RegexMatcher::regionEnd() const {

1671

return (int32_t)fRegionLimit;

1672

}

1673

1674

int64_t RegexMatcher::regionEnd64() const {

1675

return fRegionLimit;

1676

}

1677

1678

//--------------------------------------------------------------------------------

1679

//

1680

// regionStart

1681

//

1682

//--------------------------------------------------------------------------------

1683

int32_t RegexMatcher::regionStart() const {

1684

return (int32_t)fRegionStart;

1685

}

1686

1687

int64_t RegexMatcher::regionStart64() const {

1688

return fRegionStart;

1689

}

1690

1691

1692

//--------------------------------------------------------------------------------

1693

//

1694

// replaceAll

1695

//

1696

//--------------------------------------------------------------------------------

1697

UnicodeString RegexMatcher::replaceAll(const UnicodeString &replacement, UErrorCode &status) {

1698

UText replacementText = UTEXT_INITIALIZER{ UTEXT_MAGIC, 0, 0, sizeof(UText), 0, 0, 0, 0, 0, 0, __null,
__null, __null, __null, __null, __null, __null, __null, 0, 0
, 0, 0, 0, 0 };

1699

UText resultText = UTEXT_INITIALIZER{ UTEXT_MAGIC, 0, 0, sizeof(UText), 0, 0, 0, 0, 0, 0, __null,
__null, __null, __null, __null, __null, __null, __null, 0, 0
, 0, 0, 0, 0 };

1700

UnicodeString resultString;

1701

if (U_FAILURE(status)) {

1702

return resultString;

1703

}

1704

1705

utext_openConstUnicodeStringutext_openConstUnicodeString_71(&replacementText, &replacement, &status);

1706

utext_openUnicodeStringutext_openUnicodeString_71(&resultText, &resultString, &status);

1707

1708

replaceAll(&replacementText, &resultText, status);

1709

1710

utext_closeutext_close_71(&resultText);

1711

utext_closeutext_close_71(&replacementText);

1712

1713

return resultString;

1714

}

1715

1716

1717

//

1718

// replaceAll, UText mode

1719

//

1720

UText *RegexMatcher::replaceAll(UText *replacement, UText *dest, UErrorCode &status) {

1721

if (U_FAILURE(status)) {

1722

return dest;

1723

}

1724

if (U_FAILURE(fDeferredStatus)) {

1725

status = fDeferredStatus;

1726

return dest;

1727

}

1728

1729

if (dest == NULL__null) {

1730

UnicodeString emptyString;

1731

UText empty = UTEXT_INITIALIZER{ UTEXT_MAGIC, 0, 0, sizeof(UText), 0, 0, 0, 0, 0, 0, __null,
__null, __null, __null, __null, __null, __null, __null, 0, 0
, 0, 0, 0, 0 };

1732

1733

utext_openUnicodeStringutext_openUnicodeString_71(&empty, &emptyString, &status);

1734

dest = utext_cloneutext_clone_71(NULL__null, &empty, TRUE1, FALSE0, &status);

1735

utext_closeutext_close_71(&empty);

1736

}

1737

1738

if (U_SUCCESS(status)) {

1739

reset();

1740

while (find()) {

1741

appendReplacement(dest, replacement, status);

1742

if (U_FAILURE(status)) {

1743

break;

1744

}

1745

}

1746

appendTail(dest, status);

1747

}

1748

1749

return dest;

1750

}

1751

1752

1753

//--------------------------------------------------------------------------------

1754

//

1755

// replaceFirst

1756

//

1757

//--------------------------------------------------------------------------------

1758

UnicodeString RegexMatcher::replaceFirst(const UnicodeString &replacement, UErrorCode &status) {

1759

UText replacementText = UTEXT_INITIALIZER{ UTEXT_MAGIC, 0, 0, sizeof(UText), 0, 0, 0, 0, 0, 0, __null,
__null, __null, __null, __null, __null, __null, __null, 0, 0
, 0, 0, 0, 0 };

1760

UText resultText = UTEXT_INITIALIZER{ UTEXT_MAGIC, 0, 0, sizeof(UText), 0, 0, 0, 0, 0, 0, __null,
__null, __null, __null, __null, __null, __null, __null, 0, 0
, 0, 0, 0, 0 };

1761

UnicodeString resultString;

1762

1763

utext_openConstUnicodeStringutext_openConstUnicodeString_71(&replacementText, &replacement, &status);

1764

utext_openUnicodeStringutext_openUnicodeString_71(&resultText, &resultString, &status);

1765

1766

replaceFirst(&replacementText, &resultText, status);

1767

1768

utext_closeutext_close_71(&resultText);

1769

utext_closeutext_close_71(&replacementText);

1770

1771

return resultString;

1772

}

1773

1774

//

1775

// replaceFirst, UText mode

1776

//

1777

UText *RegexMatcher::replaceFirst(UText *replacement, UText *dest, UErrorCode &status) {

1778

if (U_FAILURE(status)) {

1779

return dest;

1780

}

1781

if (U_FAILURE(fDeferredStatus)) {

1782

status = fDeferredStatus;

1783

return dest;

1784

}

1785

1786

reset();

1787

if (!find()) {

1788

return getInput(dest, status);

1789

}

1790

1791

if (dest == NULL__null) {

1792

UnicodeString emptyString;

1793

UText empty = UTEXT_INITIALIZER{ UTEXT_MAGIC, 0, 0, sizeof(UText), 0, 0, 0, 0, 0, 0, __null,
__null, __null, __null, __null, __null, __null, __null, 0, 0
, 0, 0, 0, 0 };

1794

1795

utext_openUnicodeStringutext_openUnicodeString_71(&empty, &emptyString, &status);

1796

dest = utext_cloneutext_clone_71(NULL__null, &empty, TRUE1, FALSE0, &status);

1797

utext_closeutext_close_71(&empty);

1798

}

1799

1800

appendReplacement(dest, replacement, status);

1801

appendTail(dest, status);

1802

1803

return dest;

1804

}

1805

1806

1807

//--------------------------------------------------------------------------------

1808

//

1809

// requireEnd

1810

//

1811

//--------------------------------------------------------------------------------

1812

UBool RegexMatcher::requireEnd() const {

1813

return fRequireEnd;

1814

}

1815

1816

1817

//--------------------------------------------------------------------------------

1818

//

1819

// reset

1820

//

1821

//--------------------------------------------------------------------------------

1822

RegexMatcher &RegexMatcher::reset() {

1823

fRegionStart = 0;

1824

fRegionLimit = fInputLength;

1825

fActiveStart = 0;

1826

fActiveLimit = fInputLength;

1827

fAnchorStart = 0;

1828

fAnchorLimit = fInputLength;

1829

fLookStart = 0;

1830

fLookLimit = fInputLength;

1831

resetPreserveRegion();

1832

return *this;

1833

}

1834

1835

1836

1837

void RegexMatcher::resetPreserveRegion() {

1838

fMatchStart = 0;

1839

fMatchEnd = 0;

1840

fLastMatchEnd = -1;

1841

fAppendPosition = 0;

1842

fMatch = FALSE0;

1843

fHitEnd = FALSE0;

1844

fRequireEnd = FALSE0;

1845

fTime = 0;

1846

fTickCounter = TIMER_INITIAL_VALUE;

1847

//resetStack(); // more expensive than it looks...

1848

}

1849

1850

1851

RegexMatcher &RegexMatcher::reset(const UnicodeString &input) {

1852

fInputText = utext_openConstUnicodeStringutext_openConstUnicodeString_71(fInputText, &input, &fDeferredStatus);

1853

if (fPattern->fNeedsAltInput) {

1854

fAltInputText = utext_cloneutext_clone_71(fAltInputText, fInputText, FALSE0, TRUE1, &fDeferredStatus);

1855

}

1856

if (U_FAILURE(fDeferredStatus)) {

1857

return *this;

1858

}

1859

fInputLength = utext_nativeLengthutext_nativeLength_71(fInputText);

1860

1861

reset();

1862

delete fInput;

1863

fInput = NULL__null;

1864

1865

// Do the following for any UnicodeString.

1866

// This is for compatibility for those clients who modify the input string "live" during regex operations.

1867

fInputUniStrMaybeMutable = TRUE1;

1868

1869

#if UCONFIG_NO_BREAK_ITERATION0==0

1870

if (fWordBreakItr) {

1871

fWordBreakItr->setText(fInputText, fDeferredStatus);

1872

}

1873

if (fGCBreakItr) {

1874

fGCBreakItr->setText(fInputText, fDeferredStatus);

1875

}

1876

#endif

1877

1878

return *this;

1879

}

1880

1881

1882

RegexMatcher &RegexMatcher::reset(UText *input) {

1883

if (fInputText != input) {

1884

fInputText = utext_cloneutext_clone_71(fInputText, input, FALSE0, TRUE1, &fDeferredStatus);

1885

if (fPattern->fNeedsAltInput) fAltInputText = utext_cloneutext_clone_71(fAltInputText, fInputText, FALSE0, TRUE1, &fDeferredStatus);

1886

if (U_FAILURE(fDeferredStatus)) {

1887

return *this;

1888

}

1889

fInputLength = utext_nativeLengthutext_nativeLength_71(fInputText);

1890

1891

delete fInput;

1892

fInput = NULL__null;

1893

1894

#if UCONFIG_NO_BREAK_ITERATION0==0

1895

if (fWordBreakItr) {

1896

fWordBreakItr->setText(input, fDeferredStatus);

1897

}

1898

if (fGCBreakItr) {

1899

fGCBreakItr->setText(fInputText, fDeferredStatus);

1900

}

1901

#endif

1902

}

1903

reset();

1904

fInputUniStrMaybeMutable = FALSE0;

1905

1906

return *this;

1907

}

1908

1909

/*RegexMatcher &RegexMatcher::reset(const UChar *) {

1910

fDeferredStatus = U_INTERNAL_PROGRAM_ERROR;

1911

return *this;

1912

}*/

1913

1914

RegexMatcher &RegexMatcher::reset(int64_t position, UErrorCode &status) {

1915

if (U_FAILURE(status)) {

1916

return *this;

1917

}

1918

reset(); // Reset also resets the region to be the entire string.

1919

1920

if (position < 0 || position > fActiveLimit) {

1921

status = U_INDEX_OUTOFBOUNDS_ERROR;

1922

return *this;

1923

}

1924

fMatchEnd = position;

1925

return *this;

1926

}

1927

1928

1929

//--------------------------------------------------------------------------------

1930

//

1931

// refresh

1932

//

1933

//--------------------------------------------------------------------------------

1934

RegexMatcher &RegexMatcher::refreshInputText(UText *input, UErrorCode &status) {

1935

if (U_FAILURE(status)) {

1936

return *this;

1937

}

1938

if (input == NULL__null) {

1939

status = U_ILLEGAL_ARGUMENT_ERROR;

1940

return *this;

1941

}

1942

if (utext_nativeLengthutext_nativeLength_71(fInputText) != utext_nativeLengthutext_nativeLength_71(input)) {

1943

status = U_ILLEGAL_ARGUMENT_ERROR;

1944

return *this;

1945

}

1946

int64_t pos = utext_getNativeIndexutext_getNativeIndex_71(fInputText);

1947

// Shallow read-only clone of the new UText into the existing input UText

1948

fInputText = utext_cloneutext_clone_71(fInputText, input, FALSE0, TRUE1, &status);

1949

if (U_FAILURE(status)) {

1950

return *this;

1951

}

1952

utext_setNativeIndexutext_setNativeIndex_71(fInputText, pos);

1953

1954

if (fAltInputText != NULL__null) {

1955

pos = utext_getNativeIndexutext_getNativeIndex_71(fAltInputText);

1956

fAltInputText = utext_cloneutext_clone_71(fAltInputText, input, FALSE0, TRUE1, &status);

1957

if (U_FAILURE(status)) {

1958

return *this;

1959

}

1960

utext_setNativeIndexutext_setNativeIndex_71(fAltInputText, pos);

1961

}

1962

return *this;

1963

}

1964

1965

1966

1967

//--------------------------------------------------------------------------------

1968

//

1969

// setTrace

1970

//

1971

//--------------------------------------------------------------------------------

1972

void RegexMatcher::setTrace(UBool state) {

1973

fTraceDebug = state;

1974

}

1975

1976

1977

1978

/**

1979

* UText, replace entire contents of the destination UText with a substring of the source UText.

1980

*

1981

* @param src The source UText

1982

* @param dest The destination UText. Must be writable.

1983

* May be NULL, in which case a new UText will be allocated.

1984

* @param start Start index of source substring.

1985

* @param limit Limit index of source substring.

1986

* @param status An error code.

1987

*/

1988

static UText *utext_extract_replace(UText *src, UText *dest, int64_t start, int64_t limit, UErrorCode *status) {

1989

if (U_FAILURE(*status)) {

1990

return dest;

1991

}

1992

if (start == limit) {

1993

if (dest) {

1994

utext_replaceutext_replace_71(dest, 0, utext_nativeLengthutext_nativeLength_71(dest), NULL__null, 0, status);

1995

return dest;

1996

} else {

1997

return utext_openUCharsutext_openUChars_71(NULL__null, NULL__null, 0, status);

1998

}

1999

}

2000

int32_t length = utext_extractutext_extract_71(src, start, limit, NULL__null, 0, status);

2001

if (*status != U_BUFFER_OVERFLOW_ERROR && U_FAILURE(*status)) {

2002

return dest;

2003

}

2004

*status = U_ZERO_ERROR;

2005

MaybeStackArray<UChar, 40> buffer;

2006

if (length >= buffer.getCapacity()) {

2007

UChar *newBuf = buffer.resize(length+1); // Leave space for terminating Nul.

2008

if (newBuf == NULL__null) {

2009

*status = U_MEMORY_ALLOCATION_ERROR;

2010

}

2011

}

2012

utext_extractutext_extract_71(src, start, limit, buffer.getAlias(), length+1, status);

2013

if (dest) {

2014

utext_replaceutext_replace_71(dest, 0, utext_nativeLengthutext_nativeLength_71(dest), buffer.getAlias(), length, status);

2015

return dest;

2016

}

2017

2018

// Caller did not provide a preexisting UText.

2019

// Open a new one, and have it adopt the text buffer storage.

2020

if (U_FAILURE(*status)) {

2021

return NULL__null;

2022

}

2023

int32_t ownedLength = 0;

2024

UChar *ownedBuf = buffer.orphanOrClone(length+1, ownedLength);

2025

if (ownedBuf == NULL__null) {

2026

*status = U_MEMORY_ALLOCATION_ERROR;

2027

return NULL__null;

2028

}

2029

UText *result = utext_openUCharsutext_openUChars_71(NULL__null, ownedBuf, length, status);

2030

if (U_FAILURE(*status)) {

2031

uprv_freeuprv_free_71(ownedBuf);

2032

return NULL__null;

2033

}

2034

result->providerProperties |= (1 << UTEXT_PROVIDER_OWNS_TEXT);

2035

return result;

2036

}

2037

2038

2039

//---------------------------------------------------------------------

2040

//

2041

// split

2042

//

2043

//---------------------------------------------------------------------

2044

int32_t RegexMatcher::split(const UnicodeString &input,

2045

UnicodeString dest[],

2046

int32_t destCapacity,

2047

UErrorCode &status)

2048

{

2049

UText inputText = UTEXT_INITIALIZER{ UTEXT_MAGIC, 0, 0, sizeof(UText), 0, 0, 0, 0, 0, 0, __null,
__null, __null, __null, __null, __null, __null, __null, 0, 0
, 0, 0, 0, 0 };

2050

utext_openConstUnicodeStringutext_openConstUnicodeString_71(&inputText, &input, &status);

2051

if (U_FAILURE(status)) {

2052

return 0;

2053

}

2054

2055

UText **destText = (UText **)uprv_mallocuprv_malloc_71(sizeof(UText*)*destCapacity);

2056

if (destText == NULL__null) {

2057

status = U_MEMORY_ALLOCATION_ERROR;

2058

return 0;

2059

}

2060

int32_t i;

2061

for (i = 0; i < destCapacity; i++) {

2062

destText[i] = utext_openUnicodeStringutext_openUnicodeString_71(NULL__null, &dest[i], &status);

2063

}

2064

2065

int32_t fieldCount = split(&inputText, destText, destCapacity, status);

2066

2067

for (i = 0; i < destCapacity; i++) {

2068

utext_closeutext_close_71(destText[i]);

2069

}

2070

2071

uprv_freeuprv_free_71(destText);

2072

utext_closeutext_close_71(&inputText);

2073

return fieldCount;

2074

}

2075

2076

//

2077

// split, UText mode

2078

//

2079

int32_t RegexMatcher::split(UText *input,

2080

UText *dest[],

2081

int32_t destCapacity,

2082

UErrorCode &status)

2083

{

2084

//

2085

// Check arguments for validity

2086

//

2087

if (U_FAILURE(status)) {

2088

return 0;

2089

}

2090

2091

if (destCapacity < 1) {

2092

status = U_ILLEGAL_ARGUMENT_ERROR;

2093

return 0;

2094

}

2095

2096

//

2097

// Reset for the input text

2098

//

2099

reset(input);

2100

int64_t nextOutputStringStart = 0;

2101

if (fActiveLimit == 0) {

2102

return 0;

2103

}

2104

2105

//

2106

// Loop through the input text, searching for the delimiter pattern

2107

//

2108

int32_t i;

2109

int32_t numCaptureGroups = fPattern->fGroupMap->size();

2110

for (i=0; ; i++) {

2111

if (i>=destCapacity-1) {

2112

// There is one or zero output string left.

2113

// Fill the last output string with whatever is left from the input, then exit the loop.

2114

// ( i will be == destCapacity if we filled the output array while processing

2115

// capture groups of the delimiter expression, in which case we will discard the

2116

// last capture group saved in favor of the unprocessed remainder of the

2117

// input string.)

2118

i = destCapacity-1;

2119

if (fActiveLimit > nextOutputStringStart) {

2120

if (UTEXT_FULL_TEXT_IN_CHUNK(input, fInputLength)((0==((input)->chunkNativeStart))&&((fInputLength)
==((input)->chunkNativeLimit))&&((fInputLength)==(
(input)->nativeIndexingLimit)))) {

2121

if (dest[i]) {

2122

utext_replaceutext_replace_71(dest[i], 0, utext_nativeLengthutext_nativeLength_71(dest[i]),

2123

input->chunkContents+nextOutputStringStart,

2124

(int32_t)(fActiveLimit-nextOutputStringStart), &status);

2125

} else {

2126

UText remainingText = UTEXT_INITIALIZER{ UTEXT_MAGIC, 0, 0, sizeof(UText), 0, 0, 0, 0, 0, 0, __null,
__null, __null, __null, __null, __null, __null, __null, 0, 0
, 0, 0, 0, 0 };

2127

utext_openUCharsutext_openUChars_71(&remainingText, input->chunkContents+nextOutputStringStart,

2128

fActiveLimit-nextOutputStringStart, &status);

2129

dest[i] = utext_cloneutext_clone_71(NULL__null, &remainingText, TRUE1, FALSE0, &status);

2130

utext_closeutext_close_71(&remainingText);

2131

}

2132

} else {

2133

UErrorCode lengthStatus = U_ZERO_ERROR;

2134

int32_t remaining16Length =

2135

utext_extractutext_extract_71(input, nextOutputStringStart, fActiveLimit, NULL__null, 0, &lengthStatus);

2136

UChar *remainingChars = (UChar *)uprv_mallocuprv_malloc_71(sizeof(UChar)*(remaining16Length+1));

2137

if (remainingChars == NULL__null) {

2138

status = U_MEMORY_ALLOCATION_ERROR;

2139

break;

2140

}

2141

2142

utext_extractutext_extract_71(input, nextOutputStringStart, fActiveLimit, remainingChars, remaining16Length+1, &status);

2143

if (dest[i]) {

2144

utext_replaceutext_replace_71(dest[i], 0, utext_nativeLengthutext_nativeLength_71(dest[i]), remainingChars, remaining16Length, &status);

2145

} else {

2146

UText remainingText = UTEXT_INITIALIZER{ UTEXT_MAGIC, 0, 0, sizeof(UText), 0, 0, 0, 0, 0, 0, __null,
__null, __null, __null, __null, __null, __null, __null, 0, 0
, 0, 0, 0, 0 };

2147

utext_openUCharsutext_openUChars_71(&remainingText, remainingChars, remaining16Length, &status);

2148

dest[i] = utext_cloneutext_clone_71(NULL__null, &remainingText, TRUE1, FALSE0, &status);

2149

utext_closeutext_close_71(&remainingText);

2150

}

2151

2152

uprv_freeuprv_free_71(remainingChars);

2153

}

2154

}

2155

break;

2156

}

2157

if (find()) {

2158

// We found another delimiter. Move everything from where we started looking

2159

// up until the start of the delimiter into the next output string.

2160

if (UTEXT_FULL_TEXT_IN_CHUNK(input, fInputLength)((0==((input)->chunkNativeStart))&&((fInputLength)
==((input)->chunkNativeLimit))&&((fInputLength)==(
(input)->nativeIndexingLimit)))) {

2161

if (dest[i]) {

2162

utext_replaceutext_replace_71(dest[i], 0, utext_nativeLengthutext_nativeLength_71(dest[i]),

2163

input->chunkContents+nextOutputStringStart,

2164

(int32_t)(fMatchStart-nextOutputStringStart), &status);

2165

} else {

2166

UText remainingText = UTEXT_INITIALIZER{ UTEXT_MAGIC, 0, 0, sizeof(UText), 0, 0, 0, 0, 0, 0, __null,
__null, __null, __null, __null, __null, __null, __null, 0, 0
, 0, 0, 0, 0 };

2167

utext_openUCharsutext_openUChars_71(&remainingText, input->chunkContents+nextOutputStringStart,

2168

fMatchStart-nextOutputStringStart, &status);

2169

dest[i] = utext_cloneutext_clone_71(NULL__null, &remainingText, TRUE1, FALSE0, &status);

2170

utext_closeutext_close_71(&remainingText);

2171

}

2172

} else {

2173

UErrorCode lengthStatus = U_ZERO_ERROR;

2174

int32_t remaining16Length = utext_extractutext_extract_71(input, nextOutputStringStart, fMatchStart, NULL__null, 0, &lengthStatus);

2175

UChar *remainingChars = (UChar *)uprv_mallocuprv_malloc_71(sizeof(UChar)*(remaining16Length+1));

2176

if (remainingChars == NULL__null) {

2177

status = U_MEMORY_ALLOCATION_ERROR;

2178

break;

2179

}

2180

utext_extractutext_extract_71(input, nextOutputStringStart, fMatchStart, remainingChars, remaining16Length+1, &status);

2181

if (dest[i]) {

2182

utext_replaceutext_replace_71(dest[i], 0, utext_nativeLengthutext_nativeLength_71(dest[i]), remainingChars, remaining16Length, &status);

2183

} else {

2184

UText remainingText = UTEXT_INITIALIZER{ UTEXT_MAGIC, 0, 0, sizeof(UText), 0, 0, 0, 0, 0, 0, __null,
__null, __null, __null, __null, __null, __null, __null, 0, 0
, 0, 0, 0, 0 };

2185

utext_openUCharsutext_openUChars_71(&remainingText, remainingChars, remaining16Length, &status);

2186

dest[i] = utext_cloneutext_clone_71(NULL__null, &remainingText, TRUE1, FALSE0, &status);

2187

utext_closeutext_close_71(&remainingText);

2188

}

2189

2190

uprv_freeuprv_free_71(remainingChars);

2191

}

2192

nextOutputStringStart = fMatchEnd;

2193

2194

// If the delimiter pattern has capturing parentheses, the captured

2195

// text goes out into the next n destination strings.

2196

int32_t groupNum;

2197

for (groupNum=1; groupNum<=numCaptureGroups; groupNum++) {

2198

if (i >= destCapacity-2) {

2199

// Never fill the last available output string with capture group text.

2200

// It will filled with the last field, the remainder of the

2201

// unsplit input text.

2202

break;

2203

}

2204

i++;

2205

dest[i] = utext_extract_replace(fInputText, dest[i],

2206

start64(groupNum, status), end64(groupNum, status), &status);

2207

}

2208

2209

if (nextOutputStringStart == fActiveLimit) {

2210

// The delimiter was at the end of the string. We're done, but first

2211

// we output one last empty string, for the empty field following

2212

// the delimiter at the end of input.

2213

if (i+1 < destCapacity) {

2214

++i;

2215

if (dest[i] == NULL__null) {

2216

dest[i] = utext_openUCharsutext_openUChars_71(NULL__null, NULL__null, 0, &status);

2217

} else {

2218

static const UChar emptyString[] = {(UChar)0};

2219

utext_replaceutext_replace_71(dest[i], 0, utext_nativeLengthutext_nativeLength_71(dest[i]), emptyString, 0, &status);

2220

}

2221

}

2222

break;

2223

2224

}

2225

}

2226

else

2227

{

2228

// We ran off the end of the input while looking for the next delimiter.

2229

// All the remaining text goes into the current output string.

2230

if (UTEXT_FULL_TEXT_IN_CHUNK(input, fInputLength)((0==((input)->chunkNativeStart))&&((fInputLength)
==((input)->chunkNativeLimit))&&((fInputLength)==(
(input)->nativeIndexingLimit)))) {

2231

if (dest[i]) {

2232

utext_replaceutext_replace_71(dest[i], 0, utext_nativeLengthutext_nativeLength_71(dest[i]),

2233

input->chunkContents+nextOutputStringStart,

2234

(int32_t)(fActiveLimit-nextOutputStringStart), &status);

2235

} else {

2236

UText remainingText = UTEXT_INITIALIZER{ UTEXT_MAGIC, 0, 0, sizeof(UText), 0, 0, 0, 0, 0, 0, __null,
__null, __null, __null, __null, __null, __null, __null, 0, 0
, 0, 0, 0, 0 };

2237

utext_openUCharsutext_openUChars_71(&remainingText, input->chunkContents+nextOutputStringStart,

2238

fActiveLimit-nextOutputStringStart, &status);

2239

dest[i] = utext_cloneutext_clone_71(NULL__null, &remainingText, TRUE1, FALSE0, &status);

2240

utext_closeutext_close_71(&remainingText);

2241

}

2242

} else {

2243

UErrorCode lengthStatus = U_ZERO_ERROR;

2244

int32_t remaining16Length = utext_extractutext_extract_71(input, nextOutputStringStart, fActiveLimit, NULL__null, 0, &lengthStatus);

2245

UChar *remainingChars = (UChar *)uprv_mallocuprv_malloc_71(sizeof(UChar)*(remaining16Length+1));

2246

if (remainingChars == NULL__null) {

2247

status = U_MEMORY_ALLOCATION_ERROR;

2248

break;

2249

}

2250

2251

utext_extractutext_extract_71(input, nextOutputStringStart, fActiveLimit, remainingChars, remaining16Length+1, &status);

2252

if (dest[i]) {

2253

utext_replaceutext_replace_71(dest[i], 0, utext_nativeLengthutext_nativeLength_71(dest[i]), remainingChars, remaining16Length, &status);

2254

} else {

2255

UText remainingText = UTEXT_INITIALIZER{ UTEXT_MAGIC, 0, 0, sizeof(UText), 0, 0, 0, 0, 0, 0, __null,
__null, __null, __null, __null, __null, __null, __null, 0, 0
, 0, 0, 0, 0 };

2256

utext_openUCharsutext_openUChars_71(&remainingText, remainingChars, remaining16Length, &status);

2257

dest[i] = utext_cloneutext_clone_71(NULL__null, &remainingText, TRUE1, FALSE0, &status);

2258

utext_closeutext_close_71(&remainingText);

2259

}

2260

2261

uprv_freeuprv_free_71(remainingChars);

2262

}

2263

break;

2264

}

2265

if (U_FAILURE(status)) {

2266

break;

2267

}

2268

} // end of for loop

2269

return i+1;

2270

}

2271

2272

2273

//--------------------------------------------------------------------------------

2274

//

2275

// start

2276

//

2277

//--------------------------------------------------------------------------------

2278

int32_t RegexMatcher::start(UErrorCode &status) const {

2279

return start(0, status);

2280

}

2281

2282

int64_t RegexMatcher::start64(UErrorCode &status) const {

2283

return start64(0, status);

2284

}

2285

2286

//--------------------------------------------------------------------------------

2287

//

2288

// start(int32_t group, UErrorCode &status)

2289

//

2290

//--------------------------------------------------------------------------------

2291

2292

int64_t RegexMatcher::start64(int32_t group, UErrorCode &status) const {

2293

if (U_FAILURE(status)) {

2294

return -1;

2295

}

2296

if (U_FAILURE(fDeferredStatus)) {

2297

status = fDeferredStatus;

2298

return -1;

2299

}

2300

if (fMatch == FALSE0) {

2301

status = U_REGEX_INVALID_STATE;

2302

return -1;

2303

}

2304

if (group < 0 || group > fPattern->fGroupMap->size()) {

2305

status = U_INDEX_OUTOFBOUNDS_ERROR;

2306

return -1;

2307

}

2308

int64_t s;

2309

if (group == 0) {

2310

s = fMatchStart;

2311

} else {

2312

int32_t groupOffset = fPattern->fGroupMap->elementAti(group-1);

2313

U_ASSERT(groupOffset < fPattern->fFrameSize)(void)0;

2314

U_ASSERT(groupOffset >= 0)(void)0;

2315

s = fFrame->fExtra[groupOffset];

2316

}

2317

2318

return s;

2319

}

2320

2321

2322

int32_t RegexMatcher::start(int32_t group, UErrorCode &status) const {

2323

return (int32_t)start64(group, status);

2324

}

2325

2326

//--------------------------------------------------------------------------------

2327

//

2328

// useAnchoringBounds

2329

//

2330

//--------------------------------------------------------------------------------

2331

RegexMatcher &RegexMatcher::useAnchoringBounds(UBool b) {

2332

fAnchoringBounds = b;

2333

fAnchorStart = (fAnchoringBounds ? fRegionStart : 0);

2334

fAnchorLimit = (fAnchoringBounds ? fRegionLimit : fInputLength);

2335

return *this;

2336

}

2337

2338

2339

//--------------------------------------------------------------------------------

2340

//

2341

// useTransparentBounds

2342

//

2343

//--------------------------------------------------------------------------------

2344

RegexMatcher &RegexMatcher::useTransparentBounds(UBool b) {

2345

fTransparentBounds = b;

2346

fLookStart = (fTransparentBounds ? 0 : fRegionStart);

2347

fLookLimit = (fTransparentBounds ? fInputLength : fRegionLimit);

2348

return *this;

2349

}

2350

2351

//--------------------------------------------------------------------------------

2352

//

2353

// setTimeLimit

2354

//

2355

//--------------------------------------------------------------------------------

2356

void RegexMatcher::setTimeLimit(int32_t limit, UErrorCode &status) {

2357

if (U_FAILURE(status)) {

2358

return;

2359

}

2360

if (U_FAILURE(fDeferredStatus)) {

2361

status = fDeferredStatus;

2362

return;

2363

}

2364

if (limit < 0) {

2365

status = U_ILLEGAL_ARGUMENT_ERROR;

2366

return;

2367

}

2368

fTimeLimit = limit;

2369

}

2370

2371

2372

//--------------------------------------------------------------------------------

2373

//

2374

// getTimeLimit

2375

//

2376

//--------------------------------------------------------------------------------

2377

int32_t RegexMatcher::getTimeLimit() const {

2378

return fTimeLimit;

2379

}

2380

2381

2382

//--------------------------------------------------------------------------------

2383

//

2384

// setStackLimit

2385

//

2386

//--------------------------------------------------------------------------------

2387

void RegexMatcher::setStackLimit(int32_t limit, UErrorCode &status) {

2388

if (U_FAILURE(status)) {

2389

return;

2390

}

2391

if (U_FAILURE(fDeferredStatus)) {

2392

status = fDeferredStatus;

2393

return;

2394

}

2395

if (limit < 0) {

2396

status = U_ILLEGAL_ARGUMENT_ERROR;

2397

return;

2398

}

2399

2400

// Reset the matcher. This is needed here in case there is a current match

2401

// whose final stack frame (containing the match results, pointed to by fFrame)

2402

// would be lost by resizing to a smaller stack size.

2403

reset();

2404

2405

if (limit == 0) {

2406

// Unlimited stack expansion

2407

fStack->setMaxCapacity(0);

2408

} else {

2409

// Change the units of the limit from bytes to ints, and bump the size up

2410

// to be big enough to hold at least one stack frame for the pattern,

2411

// if it isn't there already.

2412

int32_t adjustedLimit = limit / sizeof(int32_t);

2413

if (adjustedLimit < fPattern->fFrameSize) {

2414

adjustedLimit = fPattern->fFrameSize;

2415

}

2416

fStack->setMaxCapacity(adjustedLimit);

2417

}

2418

fStackLimit = limit;

2419

}

2420

2421

2422

//--------------------------------------------------------------------------------

2423

//

2424

// getStackLimit

2425

//

2426

//--------------------------------------------------------------------------------

2427

int32_t RegexMatcher::getStackLimit() const {

2428

return fStackLimit;

2429

}

2430

2431

2432

//--------------------------------------------------------------------------------

2433

//

2434

// setMatchCallback

2435

//

2436

//--------------------------------------------------------------------------------

2437

void RegexMatcher::setMatchCallback(URegexMatchCallback *callback,

2438

const void *context,

2439

UErrorCode &status) {

2440

if (U_FAILURE(status)) {

2441

return;

2442

}

2443

fCallbackFn = callback;

2444

fCallbackContext = context;

2445

}

2446

2447

2448

//--------------------------------------------------------------------------------

2449

//

2450

// getMatchCallback

2451

//

2452

//--------------------------------------------------------------------------------

2453

void RegexMatcher::getMatchCallback(URegexMatchCallback *&callback,

2454

const void *&context,

2455

UErrorCode &status) {

2456

if (U_FAILURE(status)) {

2457

return;

2458

}

2459

callback = fCallbackFn;

2460

context = fCallbackContext;

2461

}

2462

2463

2464

//--------------------------------------------------------------------------------

2465

//

2466

// setMatchCallback

2467

//

2468

//--------------------------------------------------------------------------------

2469

void RegexMatcher::setFindProgressCallback(URegexFindProgressCallback *callback,

2470

const void *context,

2471

UErrorCode &status) {

2472

if (U_FAILURE(status)) {

2473

return;

2474

}

2475

fFindProgressCallbackFn = callback;

2476

fFindProgressCallbackContext = context;

2477

}

2478

2479

2480

//--------------------------------------------------------------------------------

2481

//

2482

// getMatchCallback

2483

//

2484

//--------------------------------------------------------------------------------

2485

void RegexMatcher::getFindProgressCallback(URegexFindProgressCallback *&callback,

2486

const void *&context,

2487

UErrorCode &status) {

2488

if (U_FAILURE(status)) {

2489

return;

2490

}

2491

callback = fFindProgressCallbackFn;

2492

context = fFindProgressCallbackContext;

2493

}

2494

2495

2496

//================================================================================

2497

//

2498

// Code following this point in this file is the internal

2499

// Match Engine Implementation.

2500

//

2501

//================================================================================

2502

2503

2504

//--------------------------------------------------------------------------------

2505

//

2506

// resetStack

2507

// Discard any previous contents of the state save stack, and initialize a

2508

// new stack frame to all -1. The -1s are needed for capture group limits,

2509

// where they indicate that a group has not yet matched anything.

2510

//--------------------------------------------------------------------------------

2511

REStackFrame *RegexMatcher::resetStack() {

2512

// Discard any previous contents of the state save stack, and initialize a

2513

// new stack frame with all -1 data. The -1s are needed for capture group limits,

2514

// where they indicate that a group has not yet matched anything.

2515

fStack->removeAllElements();

2516

2517

REStackFrame *iFrame = (REStackFrame *)fStack->reserveBlock(fPattern->fFrameSize, fDeferredStatus);

2518

if(U_FAILURE(fDeferredStatus)) {

2519

return NULL__null;

2520

}

2521

2522

int32_t i;

2523

for (i=0; i<fPattern->fFrameSize-RESTACKFRAME_HDRCOUNT2; i++) {

2524

iFrame->fExtra[i] = -1;

2525

}

2526

return iFrame;

2527

}

2528

2529

2530

2531

//--------------------------------------------------------------------------------

2532

//

2533

// isWordBoundary

2534

// in perl, "xab..cd..", \b is true at positions 0,3,5,7

2535

// For us,

2536

// If the current char is a combining mark,

2537

// \b is FALSE.

2538

// Else Scan backwards to the first non-combining char.

2539

// We are at a boundary if the this char and the original chars are

2540

// opposite in membership in \w set

2541

//

2542

// parameters: pos - the current position in the input buffer

2543

//

2544

// TODO: double-check edge cases at region boundaries.

2545

//

2546

//--------------------------------------------------------------------------------

2547

UBool RegexMatcher::isWordBoundary(int64_t pos) {

2548

UBool isBoundary = FALSE0;

2549

UBool cIsWord = FALSE0;

2550

2551

if (pos >= fLookLimit) {

2552

fHitEnd = TRUE1;

2553

} else {

2554

// Determine whether char c at current position is a member of the word set of chars.

2555

// If we're off the end of the string, behave as though we're not at a word char.

2556

UTEXT_SETNATIVEINDEX(fInputText, pos)do { int64_t __offset = (pos) - (fInputText)->chunkNativeStart
; if (__offset>=0 && __offset<(int64_t)(fInputText
)->nativeIndexingLimit && (fInputText)->chunkContents
[__offset]<0xdc00) { (fInputText)->chunkOffset=(int32_t
)__offset; } else { utext_setNativeIndex_71((fInputText), (pos
)); } } while (false);

2557

UChar32 c = UTEXT_CURRENT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)] : utext_current32_71(fInputText));

2558

if (u_hasBinaryPropertyu_hasBinaryProperty_71(c, UCHAR_GRAPHEME_EXTEND) || u_charTypeu_charType_71(c) == U_FORMAT_CHAR) {

2559

// Current char is a combining one. Not a boundary.

2560

return FALSE0;

2561

}

2562

cIsWord = RegexStaticSets::gStaticSets->fPropSets[URX_ISWORD_SET].contains(c);

2563

}

2564

2565

// Back up until we come to a non-combining char, determine whether

2566

// that char is a word char.

2567

UBool prevCIsWord = FALSE0;

2568

for (;;) {

2569

if (UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText)) <= fLookStart) {

2570

break;

2571

}

2572

UChar32 prevChar = UTEXT_PREVIOUS32(fInputText)((fInputText)->chunkOffset > 0 && (fInputText)->
chunkContents[(fInputText)->chunkOffset-1] < 0xd800 ? (
fInputText)->chunkContents[--((fInputText)->chunkOffset
)] : utext_previous32_71(fInputText));

2573

if (!(u_hasBinaryPropertyu_hasBinaryProperty_71(prevChar, UCHAR_GRAPHEME_EXTEND)

2574

|| u_charTypeu_charType_71(prevChar) == U_FORMAT_CHAR)) {

2575

prevCIsWord = RegexStaticSets::gStaticSets->fPropSets[URX_ISWORD_SET].contains(prevChar);

2576

break;

2577

}

2578

}

2579

isBoundary = cIsWord ^ prevCIsWord;

2580

return isBoundary;

2581

}

2582

2583

UBool RegexMatcher::isChunkWordBoundary(int32_t pos) {

2584

UBool isBoundary = FALSE0;

2585

UBool cIsWord = FALSE0;

2586

2587

const UChar *inputBuf = fInputText->chunkContents;

2588

2589

if (pos >= fLookLimit) {

2590

fHitEnd = TRUE1;

2591

} else {

2592

// Determine whether char c at current position is a member of the word set of chars.

2593

// If we're off the end of the string, behave as though we're not at a word char.

2594

UChar32 c;

2595

U16_GET(inputBuf, fLookStart, pos, fLookLimit, c)do { (c)=(inputBuf)[pos]; if((((c)&0xfffff800)==0xd800)) {
uint16_t __c2; if((((c)&0x400)==0)) { if((pos)+1!=(fLookLimit
) && (((__c2=(inputBuf)[(pos)+1])&0xfffffc00)==0xdc00
)) { (c)=(((UChar32)((c))<<10UL)+(UChar32)(__c2)-((0xd800
<<10UL)+0xdc00-0x10000)); } } else { if((pos)>(fLookStart
) && (((__c2=(inputBuf)[(pos)-1])&0xfffffc00)==0xd800
)) { (c)=(((UChar32)(__c2)<<10UL)+(UChar32)((c))-((0xd800
<<10UL)+0xdc00-0x10000)); } } } } while (false);

2596

if (u_hasBinaryPropertyu_hasBinaryProperty_71(c, UCHAR_GRAPHEME_EXTEND) || u_charTypeu_charType_71(c) == U_FORMAT_CHAR) {

2597

// Current char is a combining one. Not a boundary.

2598

return FALSE0;

2599

}

2600

cIsWord = RegexStaticSets::gStaticSets->fPropSets[URX_ISWORD_SET].contains(c);

2601

}

2602

2603

// Back up until we come to a non-combining char, determine whether

2604

// that char is a word char.

2605

UBool prevCIsWord = FALSE0;

2606

for (;;) {

2607

if (pos <= fLookStart) {

2608

break;

2609

}

2610

UChar32 prevChar;

2611

U16_PREV(inputBuf, fLookStart, pos, prevChar)do { (prevChar)=(inputBuf)[--(pos)]; if((((prevChar)&0xfffffc00
)==0xdc00)) { uint16_t __c2; if((pos)>(fLookStart) &&
(((__c2=(inputBuf)[(pos)-1])&0xfffffc00)==0xd800)) { --(
pos); (prevChar)=(((UChar32)(__c2)<<10UL)+(UChar32)((prevChar
))-((0xd800<<10UL)+0xdc00-0x10000)); } } } while (false
);

2612

if (!(u_hasBinaryPropertyu_hasBinaryProperty_71(prevChar, UCHAR_GRAPHEME_EXTEND)

2613

|| u_charTypeu_charType_71(prevChar) == U_FORMAT_CHAR)) {

2614

prevCIsWord = RegexStaticSets::gStaticSets->fPropSets[URX_ISWORD_SET].contains(prevChar);

2615

break;

2616

}

2617

}

2618

isBoundary = cIsWord ^ prevCIsWord;

2619

return isBoundary;

2620

}

2621

2622

//--------------------------------------------------------------------------------

2623

//

2624

// isUWordBoundary

2625

//

2626

// Test for a word boundary using RBBI word break.

2627

//

2628

// parameters: pos - the current position in the input buffer

2629

//

2630

//--------------------------------------------------------------------------------

2631

UBool RegexMatcher::isUWordBoundary(int64_t pos, UErrorCode &status) {

2632

UBool returnVal = FALSE0;

2633

2634

#if UCONFIG_NO_BREAK_ITERATION0==0

2635

// Note: this point will never be reached if break iteration is configured out.

2636

// Regex patterns that would require this function will fail to compile.

2637

2638

// If we haven't yet created a break iterator for this matcher, do it now.

2639

if (fWordBreakItr == nullptr) {

2640

fWordBreakItr = BreakIterator::createWordInstance(Locale::getEnglish(), status);

2641

if (U_FAILURE(status)) {

2642

return FALSE0;

2643

}

2644

fWordBreakItr->setText(fInputText, status);

2645

}

2646

2647

// Note: zero width boundary tests like \b see through transparent region bounds,

2648

// which is why fLookLimit is used here, rather than fActiveLimit.

2649

if (pos >= fLookLimit) {

2650

fHitEnd = TRUE1;

2651

returnVal = TRUE1; // With Unicode word rules, only positions within the interior of "real"

2652

// words are not boundaries. All non-word chars stand by themselves,

2653

// with word boundaries on both sides.

2654

} else {

2655

returnVal = fWordBreakItr->isBoundary((int32_t)pos);

2656

}

2657

#endif

2658

return returnVal;

2659

}

2660

2661

2662

int64_t RegexMatcher::followingGCBoundary(int64_t pos, UErrorCode &status) {

2663

int64_t result = pos;

2664

2665

#if UCONFIG_NO_BREAK_ITERATION0==0

2666

// Note: this point will never be reached if break iteration is configured out.

2667

// Regex patterns that would require this function will fail to compile.

2668

2669

// If we haven't yet created a break iterator for this matcher, do it now.

2670

if (fGCBreakItr == nullptr) {

2671

fGCBreakItr = BreakIterator::createCharacterInstance(Locale::getEnglish(), status);

2672

if (U_FAILURE(status)) {

2673

return pos;

2674

}

2675

fGCBreakItr->setText(fInputText, status);

2676

}

2677

result = fGCBreakItr->following(pos);

2678

if (result == BreakIterator::DONE) {

2679

result = pos;

2680

}

2681

#endif

2682

return result;

2683

}

2684

2685

//--------------------------------------------------------------------------------

2686

//

2687

// IncrementTime This function is called once each TIMER_INITIAL_VALUE state

2688

// saves. Increment the "time" counter, and call the

2689

// user callback function if there is one installed.

2690

//

2691

// If the match operation needs to be aborted, either for a time-out

2692

// or because the user callback asked for it, just set an error status.

2693

// The engine will pick that up and stop in its outer loop.

2694

//

2695

//--------------------------------------------------------------------------------

2696

void RegexMatcher::IncrementTime(UErrorCode &status) {

2697

fTickCounter = TIMER_INITIAL_VALUE;

2698

fTime++;

2699

if (fCallbackFn != NULL__null) {

2700

if ((*fCallbackFn)(fCallbackContext, fTime) == FALSE0) {

2701

status = U_REGEX_STOPPED_BY_CALLER;

2702

return;

2703

}

2704

}

2705

if (fTimeLimit > 0 && fTime >= fTimeLimit) {

2706

status = U_REGEX_TIME_OUT;

2707

}

2708

}

2709

2710

//--------------------------------------------------------------------------------

2711

//

2712

// StateSave

2713

// Make a new stack frame, initialized as a copy of the current stack frame.

2714

// Set the pattern index in the original stack frame from the operand value

2715

// in the opcode. Execution of the engine continues with the state in

2716

// the newly created stack frame

2717

//

2718

// Note that reserveBlock() may grow the stack, resulting in the

2719

// whole thing being relocated in memory.

2720

//

2721

// Parameters:

2722

// fp The top frame pointer when called. At return, a new

2723

// fame will be present

2724

// savePatIdx An index into the compiled pattern. Goes into the original

2725

// (not new) frame. If execution ever back-tracks out of the

2726

// new frame, this will be where we continue from in the pattern.

2727

// Return

2728

// The new frame pointer.

2729

//

2730

//--------------------------------------------------------------------------------

2731

inline REStackFrame *RegexMatcher::StateSave(REStackFrame *fp, int64_t savePatIdx, UErrorCode &status) {

2732

if (U_FAILURE(status)) {

2733

return fp;

2734

}

2735

// push storage for a new frame.

2736

int64_t *newFP = fStack->reserveBlock(fFrameSize, status);

2737

if (U_FAILURE(status)) {

2738

// Failure on attempted stack expansion.

2739

// Stack function set some other error code, change it to a more

2740

// specific one for regular expressions.

2741

status = U_REGEX_STACK_OVERFLOW;

2742

// We need to return a writable stack frame, so just return the

2743

// previous frame. The match operation will stop quickly

2744

// because of the error status, after which the frame will never

2745

// be looked at again.

2746

return fp;

2747

}

2748

fp = (REStackFrame *)(newFP - fFrameSize); // in case of realloc of stack.

2749

2750

// New stack frame = copy of old top frame.

2751

int64_t *source = (int64_t *)fp;

2752

int64_t *dest = newFP;

2753

for (;;) {

2754

*dest++ = *source++;

2755

if (source == newFP) {

2756

break;

2757

}

2758

}

2759

2760

fTickCounter--;

2761

if (fTickCounter <= 0) {

2762

IncrementTime(status); // Re-initializes fTickCounter

2763

}

2764

fp->fPatIdx = savePatIdx;

2765

return (REStackFrame *)newFP;

2766

}

2767

2768

#if defined(REGEX_DEBUG)

2769

namespace {

2770

UnicodeString StringFromUText(UText *ut) {

2771

UnicodeString result;

2772

for (UChar32 c = utext_next32Fromutext_next32From_71(ut, 0); c != U_SENTINEL(-1); c = UTEXT_NEXT32(ut)((ut)->chunkOffset < (ut)->chunkLength && ((
ut)->chunkContents)[(ut)->chunkOffset]<0xd800 ? ((ut
)->chunkContents)[((ut)->chunkOffset)++] : utext_next32_71
(ut))) {

2773

result.append(c);

2774

}

2775

return result;

2776

}

2777

}

2778

#endif // REGEX_DEBUG

2779

2780

2781

//--------------------------------------------------------------------------------

2782

//

2783

// MatchAt This is the actual matching engine.

2784

//

2785

// startIdx: begin matching a this index.

2786

// toEnd: if true, match must extend to end of the input region

2787

//

2788

//--------------------------------------------------------------------------------

2789

void RegexMatcher::MatchAt(int64_t startIdx, UBool toEnd, UErrorCode &status) {

2790

UBool isMatch = FALSE0; // True if the we have a match.

2791

2792

int64_t backSearchIndex = U_INT64_MAX((int64_t)(9223372036854775807L)); // used after greedy single-character matches for searching backwards

2793

2794

int32_t op; // Operation from the compiled pattern, split into

2795

int32_t opType; // the opcode

2796

int32_t opValue; // and the operand value.

2797

2798

#ifdef REGEX_RUN_DEBUG

2799

if (fTraceDebug) {

2800

printf("MatchAt(startIdx=%ld)\n", startIdx);

2801

printf("Original Pattern: \"%s\"\n", CStr(StringFromUText(fPattern->fPattern))());

2802

printf("Input String: \"%s\"\n\n", CStr(StringFromUText(fInputText))());

2803

}

2804

#endif

2805

2806

if (U_FAILURE(status)) {

2807

return;

2808

}

2809

2810

// Cache frequently referenced items from the compiled pattern

2811

//

2812

int64_t *pat = fPattern->fCompiledPat->getBuffer();

2813

2814

const UChar *litText = fPattern->fLiteralText.getBuffer();

2815

UVector *fSets = fPattern->fSets;

2816

2817

fFrameSize = fPattern->fFrameSize;

2818

REStackFrame *fp = resetStack();

2819

if (U_FAILURE(fDeferredStatus)) {

2820

status = fDeferredStatus;

2821

return;

2822

}

2823

2824

fp->fPatIdx = 0;

2825

fp->fInputIdx = startIdx;

2826

2827

// Zero out the pattern's static data

2828

int32_t i;

2829

for (i = 0; i<fPattern->fDataSize; i++) {

2830

fData[i] = 0;

2831

}

2832

2833

//

2834

// Main loop for interpreting the compiled pattern.

2835

// One iteration of the loop per pattern operation performed.

2836

//

2837

for (;;) {

2838

op = (int32_t)pat[fp->fPatIdx];

2839

opType = URX_TYPE(op)((uint32_t)(op) >> 24);

2840

opValue = URX_VAL(op)((op) & 0xffffff);

2841

#ifdef REGEX_RUN_DEBUG

2842

if (fTraceDebug) {

2843

UTEXT_SETNATIVEINDEX(fInputText, fp->fInputIdx)do { int64_t __offset = (fp->fInputIdx) - (fInputText)->
chunkNativeStart; if (__offset>=0 && __offset<(
int64_t)(fInputText)->nativeIndexingLimit && (fInputText
)->chunkContents[__offset]<0xdc00) { (fInputText)->chunkOffset
=(int32_t)__offset; } else { utext_setNativeIndex_71((fInputText
), (fp->fInputIdx)); } } while (false);

2844

printf("inputIdx=%ld inputChar=%x sp=%3ld activeLimit=%ld ", fp->fInputIdx,

2845

UTEXT_CURRENT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)] : utext_current32_71(fInputText)), (int64_t *)fp-fStack->getBuffer(), fActiveLimit);

2846

fPattern->dumpOp(fp->fPatIdx);

2847

}

2848

#endif

2849

fp->fPatIdx++;

2850

2851

switch (opType) {

2852

2853

2854

case URX_NOP:

2855

break;

2856

2857

2858

case URX_BACKTRACK:

2859

// Force a backtrack. In some circumstances, the pattern compiler

2860

// will notice that the pattern can't possibly match anything, and will

2861

// emit one of these at that point.

2862

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

2863

break;

2864

2865

2866

case URX_ONECHAR:

2867

if (fp->fInputIdx < fActiveLimit) {

2868

UTEXT_SETNATIVEINDEX(fInputText, fp->fInputIdx)do { int64_t __offset = (fp->fInputIdx) - (fInputText)->
chunkNativeStart; if (__offset>=0 && __offset<(
int64_t)(fInputText)->nativeIndexingLimit && (fInputText
)->chunkContents[__offset]<0xdc00) { (fInputText)->chunkOffset
=(int32_t)__offset; } else { utext_setNativeIndex_71((fInputText
), (fp->fInputIdx)); } } while (false);

2869

UChar32 c = UTEXT_NEXT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)++] : utext_next32_71(fInputText));

2870

if (c == opValue) {

2871

fp->fInputIdx = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

2872

break;

2873

}

2874

} else {

2875

fHitEnd = TRUE1;

2876

}

2877

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

2878

break;

2879

2880

2881

case URX_STRING:

2882

{

2883

// Test input against a literal string.

2884

// Strings require two slots in the compiled pattern, one for the

2885

// offset to the string text, and one for the length.

2886

2887

int32_t stringStartIdx = opValue;

2888

op = (int32_t)pat[fp->fPatIdx]; // Fetch the second operand

2889

fp->fPatIdx++;

2890

opType = URX_TYPE(op)((uint32_t)(op) >> 24);

2891

int32_t stringLen = URX_VAL(op)((op) & 0xffffff);

2892

U_ASSERT(opType == URX_STRING_LEN)(void)0;

2893

U_ASSERT(stringLen >= 2)(void)0;

2894

2895

const UChar *patternString = litText+stringStartIdx;

2896

int32_t patternStringIndex = 0;

2897

UTEXT_SETNATIVEINDEX(fInputText, fp->fInputIdx)do { int64_t __offset = (fp->fInputIdx) - (fInputText)->
chunkNativeStart; if (__offset>=0 && __offset<(
int64_t)(fInputText)->nativeIndexingLimit && (fInputText
)->chunkContents[__offset]<0xdc00) { (fInputText)->chunkOffset
=(int32_t)__offset; } else { utext_setNativeIndex_71((fInputText
), (fp->fInputIdx)); } } while (false);

2898

UChar32 inputChar;

2899

UChar32 patternChar;

2900

UBool success = TRUE1;

2901

while (patternStringIndex < stringLen) {

2902

if (UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText)) >= fActiveLimit) {

2903

success = FALSE0;

2904

fHitEnd = TRUE1;

2905

break;

2906

}

2907

inputChar = UTEXT_NEXT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)++] : utext_next32_71(fInputText));

2908

U16_NEXT(patternString, patternStringIndex, stringLen, patternChar)do { (patternChar)=(patternString)[(patternStringIndex)++]; if
((((patternChar)&0xfffffc00)==0xd800)) { uint16_t __c2; if
((patternStringIndex)!=(stringLen) && (((__c2=(patternString
)[(patternStringIndex)])&0xfffffc00)==0xdc00)) { ++(patternStringIndex
); (patternChar)=(((UChar32)((patternChar))<<10UL)+(UChar32
)(__c2)-((0xd800<<10UL)+0xdc00-0x10000)); } } } while (
false);

2909

if (patternChar != inputChar) {

2910

success = FALSE0;

2911

break;

2912

}

2913

}

2914

2915

if (success) {

2916

fp->fInputIdx = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

2917

} else {

2918

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

2919

}

2920

}

2921

break;

2922

2923

2924

case URX_STATE_SAVE:

2925

fp = StateSave(fp, opValue, status);

2926

break;

2927

2928

2929

case URX_END:

2930

// The match loop will exit via this path on a successful match,

2931

// when we reach the end of the pattern.

2932

if (toEnd && fp->fInputIdx != fActiveLimit) {

2933

// The pattern matched, but not to the end of input. Try some more.

2934

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

2935

break;

2936

}

2937

isMatch = TRUE1;

2938

goto breakFromLoop;

2939

2940

// Start and End Capture stack frame variables are laid out out like this:

2941

// fp->fExtra[opValue] - The start of a completed capture group

2942

// opValue+1 - The end of a completed capture group

2943

// opValue+2 - the start of a capture group whose end

2944

// has not yet been reached (and might not ever be).

2945

case URX_START_CAPTURE:

2946

U_ASSERT(opValue >= 0 && opValue < fFrameSize-3)(void)0;

2947

fp->fExtra[opValue+2] = fp->fInputIdx;

2948

break;

2949

2950

2951

case URX_END_CAPTURE:

2952

U_ASSERT(opValue >= 0 && opValue < fFrameSize-3)(void)0;

2953

U_ASSERT(fp->fExtra[opValue+2] >= 0)(void)0; // Start pos for this group must be set.

2954

fp->fExtra[opValue] = fp->fExtra[opValue+2]; // Tentative start becomes real.

2955

fp->fExtra[opValue+1] = fp->fInputIdx; // End position

2956

U_ASSERT(fp->fExtra[opValue] <= fp->fExtra[opValue+1])(void)0;

2957

break;

2958

2959

2960

case URX_DOLLAR: // $, test for End of line

2961

// or for position before new line at end of input

2962

{

2963

if (fp->fInputIdx >= fAnchorLimit) {

2964

// We really are at the end of input. Success.

2965

fHitEnd = TRUE1;

2966

fRequireEnd = TRUE1;

2967

break;

2968

}

2969

2970

UTEXT_SETNATIVEINDEX(fInputText, fp->fInputIdx)do { int64_t __offset = (fp->fInputIdx) - (fInputText)->
chunkNativeStart; if (__offset>=0 && __offset<(
int64_t)(fInputText)->nativeIndexingLimit && (fInputText
)->chunkContents[__offset]<0xdc00) { (fInputText)->chunkOffset
=(int32_t)__offset; } else { utext_setNativeIndex_71((fInputText
), (fp->fInputIdx)); } } while (false);

2971

2972

// If we are positioned just before a new-line that is located at the

2973

// end of input, succeed.

2974

UChar32 c = UTEXT_NEXT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)++] : utext_next32_71(fInputText));

2975

if (UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText)) >= fAnchorLimit) {

2976

if (isLineTerminator(c)) {

2977

// If not in the middle of a CR/LF sequence

2978

if ( !(c==0x0a && fp->fInputIdx>fAnchorStart && ((void)UTEXT_PREVIOUS32(fInputText)((fInputText)->chunkOffset > 0 && (fInputText)->
chunkContents[(fInputText)->chunkOffset-1] < 0xd800 ? (
fInputText)->chunkContents[--((fInputText)->chunkOffset
)] : utext_previous32_71(fInputText)), UTEXT_PREVIOUS32(fInputText)((fInputText)->chunkOffset > 0 && (fInputText)->
chunkContents[(fInputText)->chunkOffset-1] < 0xd800 ? (
fInputText)->chunkContents[--((fInputText)->chunkOffset
)] : utext_previous32_71(fInputText)))==0x0d)) {

2979

// At new-line at end of input. Success

2980

fHitEnd = TRUE1;

2981

fRequireEnd = TRUE1;

2982

2983

break;

2984

}

2985

}

2986

} else {

2987

UChar32 nextC = UTEXT_NEXT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)++] : utext_next32_71(fInputText));

2988

if (c == 0x0d && nextC == 0x0a && UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText)) >= fAnchorLimit) {

2989

fHitEnd = TRUE1;

2990

fRequireEnd = TRUE1;

2991

break; // At CR/LF at end of input. Success

2992

}

2993

}

2994

2995

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

2996

}

2997

break;

2998

2999

3000

case URX_DOLLAR_D: // $, test for End of Line, in UNIX_LINES mode.

3001

if (fp->fInputIdx >= fAnchorLimit) {

3002

// Off the end of input. Success.

3003

fHitEnd = TRUE1;

3004

fRequireEnd = TRUE1;

3005

break;

3006

} else {

3007

UTEXT_SETNATIVEINDEX(fInputText, fp->fInputIdx)do { int64_t __offset = (fp->fInputIdx) - (fInputText)->
chunkNativeStart; if (__offset>=0 && __offset<(
int64_t)(fInputText)->nativeIndexingLimit && (fInputText
)->chunkContents[__offset]<0xdc00) { (fInputText)->chunkOffset
=(int32_t)__offset; } else { utext_setNativeIndex_71((fInputText
), (fp->fInputIdx)); } } while (false);

3008

UChar32 c = UTEXT_NEXT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)++] : utext_next32_71(fInputText));

3009

// Either at the last character of input, or off the end.

3010

if (c == 0x0a && UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText)) == fAnchorLimit) {

3011

fHitEnd = TRUE1;

3012

fRequireEnd = TRUE1;

3013

break;

3014

}

3015

}

3016

3017

// Not at end of input. Back-track out.

3018

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3019

break;

3020

3021

3022

case URX_DOLLAR_M: // $, test for End of line in multi-line mode

3023

{

3024

if (fp->fInputIdx >= fAnchorLimit) {

3025

// We really are at the end of input. Success.

3026

fHitEnd = TRUE1;

3027

fRequireEnd = TRUE1;

3028

break;

3029

}

3030

// If we are positioned just before a new-line, succeed.

3031

// It makes no difference where the new-line is within the input.

3032

UTEXT_SETNATIVEINDEX(fInputText, fp->fInputIdx)do { int64_t __offset = (fp->fInputIdx) - (fInputText)->
chunkNativeStart; if (__offset>=0 && __offset<(
int64_t)(fInputText)->nativeIndexingLimit && (fInputText
)->chunkContents[__offset]<0xdc00) { (fInputText)->chunkOffset
=(int32_t)__offset; } else { utext_setNativeIndex_71((fInputText
), (fp->fInputIdx)); } } while (false);

3033

UChar32 c = UTEXT_CURRENT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)] : utext_current32_71(fInputText));

3034

if (isLineTerminator(c)) {

3035

// At a line end, except for the odd chance of being in the middle of a CR/LF sequence

3036

// In multi-line mode, hitting a new-line just before the end of input does not

3037

// set the hitEnd or requireEnd flags

3038

if ( !(c==0x0a && fp->fInputIdx>fAnchorStart && UTEXT_PREVIOUS32(fInputText)((fInputText)->chunkOffset > 0 && (fInputText)->
chunkContents[(fInputText)->chunkOffset-1] < 0xd800 ? (
fInputText)->chunkContents[--((fInputText)->chunkOffset
)] : utext_previous32_71(fInputText))==0x0d)) {

3039

break;

3040

}

3041

}

3042

// not at a new line. Fail.

3043

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3044

}

3045

break;

3046

3047

3048

case URX_DOLLAR_MD: // $, test for End of line in multi-line and UNIX_LINES mode

3049

{

3050

if (fp->fInputIdx >= fAnchorLimit) {

3051

// We really are at the end of input. Success.

3052

fHitEnd = TRUE1;

3053

fRequireEnd = TRUE1; // Java set requireEnd in this case, even though

3054

break; // adding a new-line would not lose the match.

3055

}

3056

// If we are not positioned just before a new-line, the test fails; backtrack out.

3057

// It makes no difference where the new-line is within the input.

3058

UTEXT_SETNATIVEINDEX(fInputText, fp->fInputIdx)do { int64_t __offset = (fp->fInputIdx) - (fInputText)->
chunkNativeStart; if (__offset>=0 && __offset<(
int64_t)(fInputText)->nativeIndexingLimit && (fInputText
)->chunkContents[__offset]<0xdc00) { (fInputText)->chunkOffset
=(int32_t)__offset; } else { utext_setNativeIndex_71((fInputText
), (fp->fInputIdx)); } } while (false);

3059

if (UTEXT_CURRENT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)] : utext_current32_71(fInputText)) != 0x0a) {

3060

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3061

}

3062

}

3063

break;

3064

3065

3066

case URX_CARET: // ^, test for start of line

3067

if (fp->fInputIdx != fAnchorStart) {

3068

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3069

}

3070

break;

3071

3072

3073

case URX_CARET_M: // ^, test for start of line in mulit-line mode

3074

{

3075

if (fp->fInputIdx == fAnchorStart) {

3076

// We are at the start input. Success.

3077

break;

3078

}

3079

// Check whether character just before the current pos is a new-line

3080

// unless we are at the end of input

3081

UTEXT_SETNATIVEINDEX(fInputText, fp->fInputIdx)do { int64_t __offset = (fp->fInputIdx) - (fInputText)->
chunkNativeStart; if (__offset>=0 && __offset<(
int64_t)(fInputText)->nativeIndexingLimit && (fInputText
)->chunkContents[__offset]<0xdc00) { (fInputText)->chunkOffset
=(int32_t)__offset; } else { utext_setNativeIndex_71((fInputText
), (fp->fInputIdx)); } } while (false);

3082

UChar32 c = UTEXT_PREVIOUS32(fInputText)((fInputText)->chunkOffset > 0 && (fInputText)->
chunkContents[(fInputText)->chunkOffset-1] < 0xd800 ? (
fInputText)->chunkContents[--((fInputText)->chunkOffset
)] : utext_previous32_71(fInputText));

3083

if ((fp->fInputIdx < fAnchorLimit) && isLineTerminator(c)) {

3084

// It's a new-line. ^ is true. Success.

3085

// TODO: what should be done with positions between a CR and LF?

3086

break;

3087

}

3088

// Not at the start of a line. Fail.

3089

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3090

}

3091

break;

3092

3093

3094

case URX_CARET_M_UNIX: // ^, test for start of line in mulit-line + Unix-line mode

3095

{

3096

U_ASSERT(fp->fInputIdx >= fAnchorStart)(void)0;

3097

if (fp->fInputIdx <= fAnchorStart) {

3098

// We are at the start input. Success.

3099

break;

3100

}

3101

// Check whether character just before the current pos is a new-line

3102

U_ASSERT(fp->fInputIdx <= fAnchorLimit)(void)0;

3103

UTEXT_SETNATIVEINDEX(fInputText, fp->fInputIdx)do { int64_t __offset = (fp->fInputIdx) - (fInputText)->
chunkNativeStart; if (__offset>=0 && __offset<(
int64_t)(fInputText)->nativeIndexingLimit && (fInputText
)->chunkContents[__offset]<0xdc00) { (fInputText)->chunkOffset
=(int32_t)__offset; } else { utext_setNativeIndex_71((fInputText
), (fp->fInputIdx)); } } while (false);

3104

UChar32 c = UTEXT_PREVIOUS32(fInputText)((fInputText)->chunkOffset > 0 && (fInputText)->
chunkContents[(fInputText)->chunkOffset-1] < 0xd800 ? (
fInputText)->chunkContents[--((fInputText)->chunkOffset
)] : utext_previous32_71(fInputText));

3105

if (c != 0x0a) {

3106

// Not at the start of a line. Back-track out.

3107

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3108

}

3109

}

3110

break;

3111

3112

case URX_BACKSLASH_B: // Test for word boundaries

3113

{

3114

UBool success = isWordBoundary(fp->fInputIdx);

3115

success ^= (UBool)(opValue != 0); // flip sense for \B

3116

if (!success) {

3117

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3118

}

3119

}

3120

break;

3121

3122

3123

case URX_BACKSLASH_BU: // Test for word boundaries, Unicode-style

3124

{

3125

UBool success = isUWordBoundary(fp->fInputIdx, status);

3126

success ^= (UBool)(opValue != 0); // flip sense for \B

3127

if (!success) {

3128

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3129

}

3130

}

3131

break;

3132

3133

3134

case URX_BACKSLASH_D: // Test for decimal digit

3135

{

3136

if (fp->fInputIdx >= fActiveLimit) {

3137

fHitEnd = TRUE1;

3138

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3139

break;

3140

}

3141

3142

UTEXT_SETNATIVEINDEX(fInputText, fp->fInputIdx)do { int64_t __offset = (fp->fInputIdx) - (fInputText)->
chunkNativeStart; if (__offset>=0 && __offset<(
int64_t)(fInputText)->nativeIndexingLimit && (fInputText
)->chunkContents[__offset]<0xdc00) { (fInputText)->chunkOffset
=(int32_t)__offset; } else { utext_setNativeIndex_71((fInputText
), (fp->fInputIdx)); } } while (false);

3143

3144

UChar32 c = UTEXT_NEXT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)++] : utext_next32_71(fInputText));

3145

int8_t ctype = u_charTypeu_charType_71(c); // TODO: make a unicode set for this. Will be faster.

3146

UBool success = (ctype == U_DECIMAL_DIGIT_NUMBER);

3147

success ^= (UBool)(opValue != 0); // flip sense for \D

3148

if (success) {

3149

fp->fInputIdx = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

3150

} else {

3151

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3152

}

3153

}

3154

break;

3155

3156

3157

case URX_BACKSLASH_G: // Test for position at end of previous match

3158

if (!((fMatch && fp->fInputIdx==fMatchEnd) || (fMatch==FALSE0 && fp->fInputIdx==fActiveStart))) {

3159

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3160

}

3161

break;

3162

3163

3164

case URX_BACKSLASH_H: // Test for \h, horizontal white space.

3165

{

3166

if (fp->fInputIdx >= fActiveLimit) {

3167

fHitEnd = TRUE1;

3168

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3169

break;

3170

}

3171

UTEXT_SETNATIVEINDEX(fInputText, fp->fInputIdx)do { int64_t __offset = (fp->fInputIdx) - (fInputText)->
chunkNativeStart; if (__offset>=0 && __offset<(
int64_t)(fInputText)->nativeIndexingLimit && (fInputText
)->chunkContents[__offset]<0xdc00) { (fInputText)->chunkOffset
=(int32_t)__offset; } else { utext_setNativeIndex_71((fInputText
), (fp->fInputIdx)); } } while (false);

3172

UChar32 c = UTEXT_NEXT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)++] : utext_next32_71(fInputText));

3173

int8_t ctype = u_charTypeu_charType_71(c);

3174

UBool success = (ctype == U_SPACE_SEPARATOR || c == 9); // SPACE_SEPARATOR || TAB

3175

success ^= (UBool)(opValue != 0); // flip sense for \H

3176

if (success) {

3177

fp->fInputIdx = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

3178

} else {

3179

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3180

}

3181

}

3182

break;

3183

3184

3185

case URX_BACKSLASH_R: // Test for \R, any line break sequence.

3186

{

3187

if (fp->fInputIdx >= fActiveLimit) {

3188

fHitEnd = TRUE1;

3189

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3190

break;

3191

}

3192

UTEXT_SETNATIVEINDEX(fInputText, fp->fInputIdx)do { int64_t __offset = (fp->fInputIdx) - (fInputText)->
chunkNativeStart; if (__offset>=0 && __offset<(
int64_t)(fInputText)->nativeIndexingLimit && (fInputText
)->chunkContents[__offset]<0xdc00) { (fInputText)->chunkOffset
=(int32_t)__offset; } else { utext_setNativeIndex_71((fInputText
), (fp->fInputIdx)); } } while (false);

3193

UChar32 c = UTEXT_NEXT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)++] : utext_next32_71(fInputText));

3194

if (isLineTerminator(c)) {

3195

if (c == 0x0d && utext_current32utext_current32_71(fInputText) == 0x0a) {

3196

utext_next32utext_next32_71(fInputText);

3197

}

3198

fp->fInputIdx = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

3199

} else {

3200

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3201

}

3202

}

3203

break;

3204

3205

3206

case URX_BACKSLASH_V: // \v, any single line ending character.

3207

{

3208

if (fp->fInputIdx >= fActiveLimit) {

3209

fHitEnd = TRUE1;

3210

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3211

break;

3212

}

3213

UTEXT_SETNATIVEINDEX(fInputText, fp->fInputIdx)do { int64_t __offset = (fp->fInputIdx) - (fInputText)->
chunkNativeStart; if (__offset>=0 && __offset<(
int64_t)(fInputText)->nativeIndexingLimit && (fInputText
)->chunkContents[__offset]<0xdc00) { (fInputText)->chunkOffset
=(int32_t)__offset; } else { utext_setNativeIndex_71((fInputText
), (fp->fInputIdx)); } } while (false);

3214

UChar32 c = UTEXT_NEXT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)++] : utext_next32_71(fInputText));

3215

UBool success = isLineTerminator(c);

3216

success ^= (UBool)(opValue != 0); // flip sense for \V

3217

if (success) {

3218

fp->fInputIdx = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

3219

} else {

3220

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3221

}

3222

}

3223

break;

3224

3225

3226

case URX_BACKSLASH_X:

3227

// Match a Grapheme, as defined by Unicode UAX 29.

3228

3229

// Fail if at end of input

3230

if (fp->fInputIdx >= fActiveLimit) {

3231

fHitEnd = TRUE1;

3232

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3233

break;

3234

}

3235

3236

fp->fInputIdx = followingGCBoundary(fp->fInputIdx, status);

3237

if (fp->fInputIdx >= fActiveLimit) {

3238

fHitEnd = TRUE1;

3239

fp->fInputIdx = fActiveLimit;

3240

}

3241

break;

3242

3243

3244

case URX_BACKSLASH_Z: // Test for end of Input

3245

if (fp->fInputIdx < fAnchorLimit) {

3246

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3247

} else {

3248

fHitEnd = TRUE1;

3249

fRequireEnd = TRUE1;

3250

}

3251

break;

3252

3253

3254

3255

case URX_STATIC_SETREF:

3256

{

3257

// Test input character against one of the predefined sets

3258

// (Word Characters, for example)

3259

// The high bit of the op value is a flag for the match polarity.

3260

// 0: success if input char is in set.

3261

// 1: success if input char is not in set.

3262

if (fp->fInputIdx >= fActiveLimit) {

3263

fHitEnd = TRUE1;

3264

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3265

break;

3266

}

3267

3268

UBool success = ((opValue & URX_NEG_SET) == URX_NEG_SET);

3269

opValue &= ~URX_NEG_SET;

3270

U_ASSERT(opValue > 0 && opValue < URX_LAST_SET)(void)0;

3271

3272

UTEXT_SETNATIVEINDEX(fInputText, fp->fInputIdx)do { int64_t __offset = (fp->fInputIdx) - (fInputText)->
chunkNativeStart; if (__offset>=0 && __offset<(
int64_t)(fInputText)->nativeIndexingLimit && (fInputText
)->chunkContents[__offset]<0xdc00) { (fInputText)->chunkOffset
=(int32_t)__offset; } else { utext_setNativeIndex_71((fInputText
), (fp->fInputIdx)); } } while (false);

3273

UChar32 c = UTEXT_NEXT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)++] : utext_next32_71(fInputText));

3274

if (c < 256) {

3275

Regex8BitSet &s8 = RegexStaticSets::gStaticSets->fPropSets8[opValue];

3276

if (s8.contains(c)) {

3277

success = !success;

3278

}

3279

} else {

3280

const UnicodeSet &s = RegexStaticSets::gStaticSets->fPropSets[opValue];

3281

if (s.contains(c)) {

3282

success = !success;

3283

}

3284

}

3285

if (success) {

3286

fp->fInputIdx = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

3287

} else {

3288

// the character wasn't in the set.

3289

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3290

}

3291

}

3292

break;

3293

3294

3295

case URX_STAT_SETREF_N:

3296

{

3297

// Test input character for NOT being a member of one of

3298

// the predefined sets (Word Characters, for example)

3299

if (fp->fInputIdx >= fActiveLimit) {

3300

fHitEnd = TRUE1;

3301

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3302

break;

3303

}

3304

3305

U_ASSERT(opValue > 0 && opValue < URX_LAST_SET)(void)0;

3306

3307

UTEXT_SETNATIVEINDEX(fInputText, fp->fInputIdx)do { int64_t __offset = (fp->fInputIdx) - (fInputText)->
chunkNativeStart; if (__offset>=0 && __offset<(
int64_t)(fInputText)->nativeIndexingLimit && (fInputText
)->chunkContents[__offset]<0xdc00) { (fInputText)->chunkOffset
=(int32_t)__offset; } else { utext_setNativeIndex_71((fInputText
), (fp->fInputIdx)); } } while (false);

3308

3309

UChar32 c = UTEXT_NEXT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)++] : utext_next32_71(fInputText));

3310

if (c < 256) {

3311

Regex8BitSet &s8 = RegexStaticSets::gStaticSets->fPropSets8[opValue];

3312

if (s8.contains(c) == FALSE0) {

3313

fp->fInputIdx = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

3314

break;

3315

}

3316

} else {

3317

const UnicodeSet &s = RegexStaticSets::gStaticSets->fPropSets[opValue];

3318

if (s.contains(c) == FALSE0) {

3319

fp->fInputIdx = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

3320

break;

3321

}

3322

}

3323

// the character wasn't in the set.

3324

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3325

}

3326

break;

3327

3328

3329

case URX_SETREF:

3330

if (fp->fInputIdx >= fActiveLimit) {

3331

fHitEnd = TRUE1;

3332

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3333

break;

3334

} else {

3335

UTEXT_SETNATIVEINDEX(fInputText, fp->fInputIdx)do { int64_t __offset = (fp->fInputIdx) - (fInputText)->
chunkNativeStart; if (__offset>=0 && __offset<(
int64_t)(fInputText)->nativeIndexingLimit && (fInputText
)->chunkContents[__offset]<0xdc00) { (fInputText)->chunkOffset
=(int32_t)__offset; } else { utext_setNativeIndex_71((fInputText
), (fp->fInputIdx)); } } while (false);

3336

3337

// There is input left. Pick up one char and test it for set membership.

3338

UChar32 c = UTEXT_NEXT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)++] : utext_next32_71(fInputText));

3339

U_ASSERT(opValue > 0 && opValue < fSets->size())(void)0;

3340

if (c<256) {

3341

Regex8BitSet *s8 = &fPattern->fSets8[opValue];

3342

if (s8->contains(c)) {

3343

fp->fInputIdx = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

3344

break;

3345

}

3346

} else {

3347

UnicodeSet *s = (UnicodeSet *)fSets->elementAt(opValue);

3348

if (s->contains(c)) {

3349

// The character is in the set. A Match.

3350

fp->fInputIdx = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

3351

break;

3352

}

3353

}

3354

3355

// the character wasn't in the set.

3356

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3357

}

3358

break;

3359

3360

3361

case URX_DOTANY:

3362

{

3363

// . matches anything, but stops at end-of-line.

3364

if (fp->fInputIdx >= fActiveLimit) {

3365

// At end of input. Match failed. Backtrack out.

3366

fHitEnd = TRUE1;

3367

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3368

break;

3369

}

3370

3371

UTEXT_SETNATIVEINDEX(fInputText, fp->fInputIdx)do { int64_t __offset = (fp->fInputIdx) - (fInputText)->
chunkNativeStart; if (__offset>=0 && __offset<(
int64_t)(fInputText)->nativeIndexingLimit && (fInputText
)->chunkContents[__offset]<0xdc00) { (fInputText)->chunkOffset
=(int32_t)__offset; } else { utext_setNativeIndex_71((fInputText
), (fp->fInputIdx)); } } while (false);

3372

3373

// There is input left. Advance over one char, unless we've hit end-of-line

3374

UChar32 c = UTEXT_NEXT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)++] : utext_next32_71(fInputText));

3375

if (isLineTerminator(c)) {

3376

// End of line in normal mode. . does not match.

3377

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3378

break;

3379

}

3380

fp->fInputIdx = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

3381

}

3382

break;

3383

3384

3385

case URX_DOTANY_ALL:

3386

{

3387

// ., in dot-matches-all (including new lines) mode

3388

if (fp->fInputIdx >= fActiveLimit) {

3389

// At end of input. Match failed. Backtrack out.

3390

fHitEnd = TRUE1;

3391

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3392

break;

3393

}

3394

3395

UTEXT_SETNATIVEINDEX(fInputText, fp->fInputIdx)do { int64_t __offset = (fp->fInputIdx) - (fInputText)->
chunkNativeStart; if (__offset>=0 && __offset<(
int64_t)(fInputText)->nativeIndexingLimit && (fInputText
)->chunkContents[__offset]<0xdc00) { (fInputText)->chunkOffset
=(int32_t)__offset; } else { utext_setNativeIndex_71((fInputText
), (fp->fInputIdx)); } } while (false);

3396

3397

// There is input left. Advance over one char, except if we are

3398

// at a cr/lf, advance over both of them.

3399

UChar32 c;

3400

c = UTEXT_NEXT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)++] : utext_next32_71(fInputText));

3401

fp->fInputIdx = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

3402

if (c==0x0d && fp->fInputIdx < fActiveLimit) {

3403

// In the case of a CR/LF, we need to advance over both.

3404

UChar32 nextc = UTEXT_CURRENT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)] : utext_current32_71(fInputText));

3405

if (nextc == 0x0a) {

3406

(void)UTEXT_NEXT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)++] : utext_next32_71(fInputText));

3407

fp->fInputIdx = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

3408

}

3409

}

3410

}

3411

break;

3412

3413

3414

case URX_DOTANY_UNIX:

3415

{

3416

// '.' operator, matches all, but stops at end-of-line.

3417

// UNIX_LINES mode, so 0x0a is the only recognized line ending.

3418

if (fp->fInputIdx >= fActiveLimit) {

3419

// At end of input. Match failed. Backtrack out.

3420

fHitEnd = TRUE1;

3421

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3422

break;

3423

}

3424

3425

UTEXT_SETNATIVEINDEX(fInputText, fp->fInputIdx)do { int64_t __offset = (fp->fInputIdx) - (fInputText)->
chunkNativeStart; if (__offset>=0 && __offset<(
int64_t)(fInputText)->nativeIndexingLimit && (fInputText
)->chunkContents[__offset]<0xdc00) { (fInputText)->chunkOffset
=(int32_t)__offset; } else { utext_setNativeIndex_71((fInputText
), (fp->fInputIdx)); } } while (false);

3426

3427

// There is input left. Advance over one char, unless we've hit end-of-line

3428

UChar32 c = UTEXT_NEXT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)++] : utext_next32_71(fInputText));

3429

if (c == 0x0a) {

3430

// End of line in normal mode. '.' does not match the \n

3431

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3432

} else {

3433

fp->fInputIdx = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

3434

}

3435

}

3436

break;

3437

3438

3439

case URX_JMP:

3440

fp->fPatIdx = opValue;

3441

break;

3442

3443

case URX_FAIL:

3444

isMatch = FALSE0;

3445

goto breakFromLoop;

3446

3447

case URX_JMP_SAV:

3448

U_ASSERT(opValue < fPattern->fCompiledPat->size())(void)0;

3449

fp = StateSave(fp, fp->fPatIdx, status); // State save to loc following current

3450

fp->fPatIdx = opValue; // Then JMP.

3451

break;

3452

3453

case URX_JMP_SAV_X:

3454

// This opcode is used with (x)+, when x can match a zero length string.

3455

// Same as JMP_SAV, except conditional on the match having made forward progress.

3456

// Destination of the JMP must be a URX_STO_INP_LOC, from which we get the

3457

// data address of the input position at the start of the loop.

3458

{

3459

U_ASSERT(opValue > 0 && opValue < fPattern->fCompiledPat->size())(void)0;

3460

int32_t stoOp = (int32_t)pat[opValue-1];

3461

U_ASSERT(URX_TYPE(stoOp) == URX_STO_INP_LOC)(void)0;

3462

int32_t frameLoc = URX_VAL(stoOp)((stoOp) & 0xffffff);

3463

U_ASSERT(frameLoc >= 0 && frameLoc < fFrameSize)(void)0;

3464

int64_t prevInputIdx = fp->fExtra[frameLoc];

3465

U_ASSERT(prevInputIdx <= fp->fInputIdx)(void)0;

3466

if (prevInputIdx < fp->fInputIdx) {

3467

// The match did make progress. Repeat the loop.

3468

fp = StateSave(fp, fp->fPatIdx, status); // State save to loc following current

3469

fp->fPatIdx = opValue;

3470

fp->fExtra[frameLoc] = fp->fInputIdx;

3471

}

3472

// If the input position did not advance, we do nothing here,

3473

// execution will fall out of the loop.

3474

}

3475

break;

3476

3477

case URX_CTR_INIT:

3478

{

3479

U_ASSERT(opValue >= 0 && opValue < fFrameSize-2)(void)0;

3480

fp->fExtra[opValue] = 0; // Set the loop counter variable to zero

3481

3482

// Pick up the three extra operands that CTR_INIT has, and

3483

// skip the pattern location counter past

3484

int32_t instrOperandLoc = (int32_t)fp->fPatIdx;

3485

fp->fPatIdx += 3;

3486

int32_t loopLoc = URX_VAL(pat[instrOperandLoc])((pat[instrOperandLoc]) & 0xffffff);

3487

int32_t minCount = (int32_t)pat[instrOperandLoc+1];

3488

int32_t maxCount = (int32_t)pat[instrOperandLoc+2];

3489

U_ASSERT(minCount>=0)(void)0;

3490

U_ASSERT(maxCount>=minCount || maxCount==-1)(void)0;

3491

U_ASSERT(loopLoc>=fp->fPatIdx)(void)0;

3492

3493

if (minCount == 0) {

3494

fp = StateSave(fp, loopLoc+1, status);

3495

}

3496

if (maxCount == -1) {

3497

fp->fExtra[opValue+1] = fp->fInputIdx; // For loop breaking.

3498

} else if (maxCount == 0) {

3499

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3500

}

3501

}

3502

break;

3503

3504

case URX_CTR_LOOP:

3505

{

3506

U_ASSERT(opValue>0 && opValue < fp->fPatIdx-2)(void)0;

3507

int32_t initOp = (int32_t)pat[opValue];

3508

U_ASSERT(URX_TYPE(initOp) == URX_CTR_INIT)(void)0;

3509

int64_t *pCounter = &fp->fExtra[URX_VAL(initOp)((initOp) & 0xffffff)];

3510

int32_t minCount = (int32_t)pat[opValue+2];

3511

int32_t maxCount = (int32_t)pat[opValue+3];

3512

(*pCounter)++;

3513

if ((uint64_t)*pCounter >= (uint32_t)maxCount && maxCount != -1) {

3514

U_ASSERT(*pCounter == maxCount)(void)0;

3515

break;

3516

}

3517

if (*pCounter >= minCount) {

3518

if (maxCount == -1) {

3519

// Loop has no hard upper bound.

3520

// Check that it is progressing through the input, break if it is not.

3521

int64_t *pLastInputIdx = &fp->fExtra[URX_VAL(initOp)((initOp) & 0xffffff) + 1];

3522

if (fp->fInputIdx == *pLastInputIdx) {

3523

break;

3524

} else {

3525

*pLastInputIdx = fp->fInputIdx;

3526

}

3527

}

3528

fp = StateSave(fp, fp->fPatIdx, status);

3529

} else {

3530

// Increment time-out counter. (StateSave() does it if count >= minCount)

3531

fTickCounter--;

3532

if (fTickCounter <= 0) {

3533

IncrementTime(status); // Re-initializes fTickCounter

3534

}

3535

}

3536

3537

fp->fPatIdx = opValue + 4; // Loop back.

3538

}

3539

break;

3540

3541

case URX_CTR_INIT_NG:

3542

{

3543

// Initialize a non-greedy loop

3544

U_ASSERT(opValue >= 0 && opValue < fFrameSize-2)(void)0;

3545

fp->fExtra[opValue] = 0; // Set the loop counter variable to zero

3546

3547

// Pick up the three extra operands that CTR_INIT_NG has, and

3548

// skip the pattern location counter past

3549

int32_t instrOperandLoc = (int32_t)fp->fPatIdx;

3550

fp->fPatIdx += 3;

3551

int32_t loopLoc = URX_VAL(pat[instrOperandLoc])((pat[instrOperandLoc]) & 0xffffff);

3552

int32_t minCount = (int32_t)pat[instrOperandLoc+1];

3553

int32_t maxCount = (int32_t)pat[instrOperandLoc+2];

3554

U_ASSERT(minCount>=0)(void)0;

3555

U_ASSERT(maxCount>=minCount || maxCount==-1)(void)0;

3556

U_ASSERT(loopLoc>fp->fPatIdx)(void)0;

3557

if (maxCount == -1) {

3558

fp->fExtra[opValue+1] = fp->fInputIdx; // Save initial input index for loop breaking.

3559

}

3560

3561

if (minCount == 0) {

3562

if (maxCount != 0) {

3563

fp = StateSave(fp, fp->fPatIdx, status);

3564

}

3565

fp->fPatIdx = loopLoc+1; // Continue with stuff after repeated block

3566

}

3567

}

3568

break;

3569

3570

case URX_CTR_LOOP_NG:

3571

{

3572

// Non-greedy {min, max} loops

3573

U_ASSERT(opValue>0 && opValue < fp->fPatIdx-2)(void)0;

3574

int32_t initOp = (int32_t)pat[opValue];

3575

U_ASSERT(URX_TYPE(initOp) == URX_CTR_INIT_NG)(void)0;

3576

int64_t *pCounter = &fp->fExtra[URX_VAL(initOp)((initOp) & 0xffffff)];

3577

int32_t minCount = (int32_t)pat[opValue+2];

3578

int32_t maxCount = (int32_t)pat[opValue+3];

3579

3580

(*pCounter)++;

3581

if ((uint64_t)*pCounter >= (uint32_t)maxCount && maxCount != -1) {

3582

// The loop has matched the maximum permitted number of times.

3583

// Break out of here with no action. Matching will

3584

// continue with the following pattern.

3585

U_ASSERT(*pCounter == maxCount)(void)0;

3586

break;

3587

}

3588

3589

if (*pCounter < minCount) {

3590

// We haven't met the minimum number of matches yet.

3591

// Loop back for another one.

3592

fp->fPatIdx = opValue + 4; // Loop back.

3593

// Increment time-out counter. (StateSave() does it if count >= minCount)

3594

fTickCounter--;

3595

if (fTickCounter <= 0) {

3596

IncrementTime(status); // Re-initializes fTickCounter

3597

}

3598

} else {

3599

// We do have the minimum number of matches.

3600

3601

// If there is no upper bound on the loop iterations, check that the input index

3602

// is progressing, and stop the loop if it is not.

3603

if (maxCount == -1) {

3604

int64_t *pLastInputIdx = &fp->fExtra[URX_VAL(initOp)((initOp) & 0xffffff) + 1];

3605

if (fp->fInputIdx == *pLastInputIdx) {

3606

break;

3607

}

3608

*pLastInputIdx = fp->fInputIdx;

3609

}

3610

3611

// Loop Continuation: we will fall into the pattern following the loop

3612

// (non-greedy, don't execute loop body first), but first do

3613

// a state save to the top of the loop, so that a match failure

3614

// in the following pattern will try another iteration of the loop.

3615

fp = StateSave(fp, opValue + 4, status);

3616

}

3617

}

3618

break;

3619

3620

case URX_STO_SP:

3621

U_ASSERT(opValue >= 0 && opValue < fPattern->fDataSize)(void)0;

3622

fData[opValue] = fStack->size();

3623

break;

3624

3625

case URX_LD_SP:

3626

{

3627

U_ASSERT(opValue >= 0 && opValue < fPattern->fDataSize)(void)0;

3628

int32_t newStackSize = (int32_t)fData[opValue];

3629

U_ASSERT(newStackSize <= fStack->size())(void)0;

3630

int64_t *newFP = fStack->getBuffer() + newStackSize - fFrameSize;

3631

if (newFP == (int64_t *)fp) {

3632

break;

3633

}

3634

int32_t j;

3635

for (j=0; j<fFrameSize; j++) {

3636

newFP[j] = ((int64_t *)fp)[j];

3637

}

3638

fp = (REStackFrame *)newFP;

3639

fStack->setSize(newStackSize);

3640

}

3641

break;

3642

3643

case URX_BACKREF:

3644

{

3645

U_ASSERT(opValue < fFrameSize)(void)0;

3646

int64_t groupStartIdx = fp->fExtra[opValue];

3647

int64_t groupEndIdx = fp->fExtra[opValue+1];

3648

U_ASSERT(groupStartIdx <= groupEndIdx)(void)0;

3649

if (groupStartIdx < 0) {

3650

// This capture group has not participated in the match thus far,

3651

fp = (REStackFrame *)fStack->popFrame(fFrameSize); // FAIL, no match.

3652

break;

3653

}

3654

UTEXT_SETNATIVEINDEX(fAltInputText, groupStartIdx)do { int64_t __offset = (groupStartIdx) - (fAltInputText)->
chunkNativeStart; if (__offset>=0 && __offset<(
int64_t)(fAltInputText)->nativeIndexingLimit && (fAltInputText
)->chunkContents[__offset]<0xdc00) { (fAltInputText)->
chunkOffset=(int32_t)__offset; } else { utext_setNativeIndex_71
((fAltInputText), (groupStartIdx)); } } while (false);

3655

UTEXT_SETNATIVEINDEX(fInputText, fp->fInputIdx)do { int64_t __offset = (fp->fInputIdx) - (fInputText)->
chunkNativeStart; if (__offset>=0 && __offset<(
int64_t)(fInputText)->nativeIndexingLimit && (fInputText
)->chunkContents[__offset]<0xdc00) { (fInputText)->chunkOffset
=(int32_t)__offset; } else { utext_setNativeIndex_71((fInputText
), (fp->fInputIdx)); } } while (false);

3656

3657

// Note: if the capture group match was of an empty string the backref

3658

// match succeeds. Verified by testing: Perl matches succeed

3659

// in this case, so we do too.

3660

3661

UBool success = TRUE1;

3662

for (;;) {

3663

if (utext_getNativeIndexutext_getNativeIndex_71(fAltInputText) >= groupEndIdx) {

3664

success = TRUE1;

3665

break;

3666

}

3667

if (utext_getNativeIndexutext_getNativeIndex_71(fInputText) >= fActiveLimit) {

3668

success = FALSE0;

3669

fHitEnd = TRUE1;

3670

break;

3671

}

3672

UChar32 captureGroupChar = utext_next32utext_next32_71(fAltInputText);

3673

UChar32 inputChar = utext_next32utext_next32_71(fInputText);

3674

if (inputChar != captureGroupChar) {

3675

success = FALSE0;

3676

break;

3677

}

3678

}

3679

3680

if (success) {

3681

fp->fInputIdx = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

3682

} else {

3683

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3684

}

3685

}

3686

break;

3687

3688

3689

3690

case URX_BACKREF_I:

3691

{

3692

U_ASSERT(opValue < fFrameSize)(void)0;

3693

int64_t groupStartIdx = fp->fExtra[opValue];

3694

int64_t groupEndIdx = fp->fExtra[opValue+1];

3695

U_ASSERT(groupStartIdx <= groupEndIdx)(void)0;

3696

if (groupStartIdx < 0) {

3697

// This capture group has not participated in the match thus far,

3698

fp = (REStackFrame *)fStack->popFrame(fFrameSize); // FAIL, no match.

3699

break;

3700

}

3701

utext_setNativeIndexutext_setNativeIndex_71(fAltInputText, groupStartIdx);

3702

utext_setNativeIndexutext_setNativeIndex_71(fInputText, fp->fInputIdx);

3703

CaseFoldingUTextIterator captureGroupItr(*fAltInputText);

3704

CaseFoldingUTextIterator inputItr(*fInputText);

3705

3706

// Note: if the capture group match was of an empty string the backref

3707

// match succeeds. Verified by testing: Perl matches succeed

3708

// in this case, so we do too.

3709

3710

UBool success = TRUE1;

3711

for (;;) {

3712

if (!captureGroupItr.inExpansion() && utext_getNativeIndexutext_getNativeIndex_71(fAltInputText) >= groupEndIdx) {

3713

success = TRUE1;

3714

break;

3715

}

3716

if (!inputItr.inExpansion() && utext_getNativeIndexutext_getNativeIndex_71(fInputText) >= fActiveLimit) {

3717

success = FALSE0;

3718

fHitEnd = TRUE1;

3719

break;

3720

}

3721

UChar32 captureGroupChar = captureGroupItr.next();

3722

UChar32 inputChar = inputItr.next();

3723

if (inputChar != captureGroupChar) {

3724

success = FALSE0;

3725

break;

3726

}

3727

}

3728

3729

if (success && inputItr.inExpansion()) {

3730

// We obtained a match by consuming part of a string obtained from

3731

// case-folding a single code point of the input text.

3732

// This does not count as an overall match.

3733

success = FALSE0;

3734

}

3735

3736

if (success) {

3737

fp->fInputIdx = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

3738

} else {

3739

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3740

}

3741

3742

}

3743

break;

3744

3745

case URX_STO_INP_LOC:

3746

{

3747

U_ASSERT(opValue >= 0 && opValue < fFrameSize)(void)0;

3748

fp->fExtra[opValue] = fp->fInputIdx;

3749

}

3750

break;

3751

3752

case URX_JMPX:

3753

{

3754

int32_t instrOperandLoc = (int32_t)fp->fPatIdx;

3755

fp->fPatIdx += 1;

3756

int32_t dataLoc = URX_VAL(pat[instrOperandLoc])((pat[instrOperandLoc]) & 0xffffff);

3757

U_ASSERT(dataLoc >= 0 && dataLoc < fFrameSize)(void)0;

3758

int64_t savedInputIdx = fp->fExtra[dataLoc];

3759

U_ASSERT(savedInputIdx <= fp->fInputIdx)(void)0;

3760

if (savedInputIdx < fp->fInputIdx) {

3761

fp->fPatIdx = opValue; // JMP

3762

} else {

3763

fp = (REStackFrame *)fStack->popFrame(fFrameSize); // FAIL, no progress in loop.

3764

}

3765

}

3766

break;

3767

3768

case URX_LA_START:

3769

{

3770

// Entering a look around block.

3771

// Save Stack Ptr, Input Pos.

3772

U_ASSERT(opValue>=0 && opValue+3<fPattern->fDataSize)(void)0;

3773

fData[opValue] = fStack->size();

3774

fData[opValue+1] = fp->fInputIdx;

3775

fData[opValue+2] = fActiveStart;

3776

fData[opValue+3] = fActiveLimit;

3777

fActiveStart = fLookStart; // Set the match region change for

3778

fActiveLimit = fLookLimit; // transparent bounds.

3779

}

3780

break;

3781

3782

case URX_LA_END:

3783

{

3784

// Leaving a look-ahead block.

3785

// restore Stack Ptr, Input Pos to positions they had on entry to block.

3786

U_ASSERT(opValue>=0 && opValue+3<fPattern->fDataSize)(void)0;

3787

int32_t stackSize = fStack->size();

3788

int32_t newStackSize =(int32_t)fData[opValue];

3789

U_ASSERT(stackSize >= newStackSize)(void)0;

3790

if (stackSize > newStackSize) {

3791

// Copy the current top frame back to the new (cut back) top frame.

3792

// This makes the capture groups from within the look-ahead

3793

// expression available.

3794

int64_t *newFP = fStack->getBuffer() + newStackSize - fFrameSize;

3795

int32_t j;

3796

for (j=0; j<fFrameSize; j++) {

3797

newFP[j] = ((int64_t *)fp)[j];

3798

}

3799

fp = (REStackFrame *)newFP;

3800

fStack->setSize(newStackSize);

3801

}

3802

fp->fInputIdx = fData[opValue+1];

3803

3804

// Restore the active region bounds in the input string; they may have

3805

// been changed because of transparent bounds on a Region.

3806

fActiveStart = fData[opValue+2];

3807

fActiveLimit = fData[opValue+3];

3808

U_ASSERT(fActiveStart >= 0)(void)0;

3809

U_ASSERT(fActiveLimit <= fInputLength)(void)0;

3810

}

3811

break;

3812

3813

case URX_ONECHAR_I:

3814

// Case insensitive one char. The char from the pattern is already case folded.

3815

// Input text is not, but case folding the input can not reduce two or more code

3816

// points to one.

3817

if (fp->fInputIdx < fActiveLimit) {

3818

UTEXT_SETNATIVEINDEX(fInputText, fp->fInputIdx)do { int64_t __offset = (fp->fInputIdx) - (fInputText)->
chunkNativeStart; if (__offset>=0 && __offset<(
int64_t)(fInputText)->nativeIndexingLimit && (fInputText
)->chunkContents[__offset]<0xdc00) { (fInputText)->chunkOffset
=(int32_t)__offset; } else { utext_setNativeIndex_71((fInputText
), (fp->fInputIdx)); } } while (false);

3819

3820

UChar32 c = UTEXT_NEXT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)++] : utext_next32_71(fInputText));

3821

if (u_foldCaseu_foldCase_71(c, U_FOLD_CASE_DEFAULT0) == opValue) {

3822

fp->fInputIdx = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

3823

break;

3824

}

3825

} else {

3826

fHitEnd = TRUE1;

3827

}

3828

3829

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3830

break;

3831

3832

case URX_STRING_I:

3833

{

3834

// Case-insensitive test input against a literal string.

3835

// Strings require two slots in the compiled pattern, one for the

3836

// offset to the string text, and one for the length.

3837

// The compiled string has already been case folded.

3838

{

3839

const UChar *patternString = litText + opValue;

3840

int32_t patternStringIdx = 0;

3841

3842

op = (int32_t)pat[fp->fPatIdx];

3843

fp->fPatIdx++;

3844

opType = URX_TYPE(op)((uint32_t)(op) >> 24);

3845

opValue = URX_VAL(op)((op) & 0xffffff);

3846

U_ASSERT(opType == URX_STRING_LEN)(void)0;

3847

int32_t patternStringLen = opValue; // Length of the string from the pattern.

3848

3849

3850

UChar32 cPattern;

3851

UChar32 cText;

3852

UBool success = TRUE1;

3853

3854

UTEXT_SETNATIVEINDEX(fInputText, fp->fInputIdx)do { int64_t __offset = (fp->fInputIdx) - (fInputText)->
chunkNativeStart; if (__offset>=0 && __offset<(
int64_t)(fInputText)->nativeIndexingLimit && (fInputText
)->chunkContents[__offset]<0xdc00) { (fInputText)->chunkOffset
=(int32_t)__offset; } else { utext_setNativeIndex_71((fInputText
), (fp->fInputIdx)); } } while (false);

3855

CaseFoldingUTextIterator inputIterator(*fInputText);

3856

while (patternStringIdx < patternStringLen) {

3857

if (!inputIterator.inExpansion() && UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText)) >= fActiveLimit) {

3858

success = FALSE0;

3859

fHitEnd = TRUE1;

3860

break;

3861

}

3862

U16_NEXT(patternString, patternStringIdx, patternStringLen, cPattern)do { (cPattern)=(patternString)[(patternStringIdx)++]; if((((
cPattern)&0xfffffc00)==0xd800)) { uint16_t __c2; if((patternStringIdx
)!=(patternStringLen) && (((__c2=(patternString)[(patternStringIdx
)])&0xfffffc00)==0xdc00)) { ++(patternStringIdx); (cPattern
)=(((UChar32)((cPattern))<<10UL)+(UChar32)(__c2)-((0xd800
<<10UL)+0xdc00-0x10000)); } } } while (false);

3863

cText = inputIterator.next();

3864

if (cText != cPattern) {

3865

success = FALSE0;

3866

break;

3867

}

3868

}

3869

if (inputIterator.inExpansion()) {

3870

success = FALSE0;

3871

}

3872

3873

if (success) {

3874

fp->fInputIdx = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

3875

} else {

3876

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3877

}

3878

}

3879

}

3880

break;

3881

3882

case URX_LB_START:

3883

{

3884

// Entering a look-behind block.

3885

// Save Stack Ptr, Input Pos and active input region.

3886

// TODO: implement transparent bounds. Ticket #6067

3887

U_ASSERT(opValue>=0 && opValue+4<fPattern->fDataSize)(void)0;

3888

fData[opValue] = fStack->size();

3889

fData[opValue+1] = fp->fInputIdx;

3890

// Save input string length, then reset to pin any matches to end at

3891

// the current position.

3892

fData[opValue+2] = fActiveStart;

3893

fData[opValue+3] = fActiveLimit;

3894

fActiveStart = fRegionStart;

3895

fActiveLimit = fp->fInputIdx;

3896

// Init the variable containing the start index for attempted matches.

3897

fData[opValue+4] = -1;

3898

}

3899

break;

3900

3901

3902

case URX_LB_CONT:

3903

{

3904

// Positive Look-Behind, at top of loop checking for matches of LB expression

3905

// at all possible input starting positions.

3906

3907

// Fetch the min and max possible match lengths. They are the operands

3908

// of this op in the pattern.

3909

int32_t minML = (int32_t)pat[fp->fPatIdx++];

3910

int32_t maxML = (int32_t)pat[fp->fPatIdx++];

3911

if (!UTEXT_USES_U16(fInputText)(__null==((fInputText)->pFuncs->mapNativeIndexToUTF16))) {

3912

// utf-8 fix to maximum match length. The pattern compiler assumes utf-16.

3913

// The max length need not be exact; it just needs to be >= actual maximum.

3914

maxML *= 3;

3915

}

3916

U_ASSERT(minML <= maxML)(void)0;

3917

U_ASSERT(minML >= 0)(void)0;

3918

3919

// Fetch (from data) the last input index where a match was attempted.

3920

U_ASSERT(opValue>=0 && opValue+4<fPattern->fDataSize)(void)0;

3921

int64_t &lbStartIdx = fData[opValue+4];

3922

if (lbStartIdx < 0) {

3923

// First time through loop.

3924

lbStartIdx = fp->fInputIdx - minML;

3925

if (lbStartIdx > 0) {

3926

// move index to a code point boundary, if it's not on one already.

3927

UTEXT_SETNATIVEINDEX(fInputText, lbStartIdx)do { int64_t __offset = (lbStartIdx) - (fInputText)->chunkNativeStart
; if (__offset>=0 && __offset<(int64_t)(fInputText
)->nativeIndexingLimit && (fInputText)->chunkContents
[__offset]<0xdc00) { (fInputText)->chunkOffset=(int32_t
)__offset; } else { utext_setNativeIndex_71((fInputText), (lbStartIdx
)); } } while (false);

3928

lbStartIdx = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

3929

}

3930

} else {

3931

// 2nd through nth time through the loop.

3932

// Back up start position for match by one.

3933

if (lbStartIdx == 0) {

3934

(lbStartIdx)--;

3935

} else {

3936

UTEXT_SETNATIVEINDEX(fInputText, lbStartIdx)do { int64_t __offset = (lbStartIdx) - (fInputText)->chunkNativeStart
; if (__offset>=0 && __offset<(int64_t)(fInputText
)->nativeIndexingLimit && (fInputText)->chunkContents
[__offset]<0xdc00) { (fInputText)->chunkOffset=(int32_t
)__offset; } else { utext_setNativeIndex_71((fInputText), (lbStartIdx
)); } } while (false);

3937

(void)UTEXT_PREVIOUS32(fInputText)((fInputText)->chunkOffset > 0 && (fInputText)->
chunkContents[(fInputText)->chunkOffset-1] < 0xd800 ? (
fInputText)->chunkContents[--((fInputText)->chunkOffset
)] : utext_previous32_71(fInputText));

3938

lbStartIdx = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

3939

}

3940

}

3941

3942

if (lbStartIdx < 0 || lbStartIdx < fp->fInputIdx - maxML) {

3943

// We have tried all potential match starting points without

3944

// getting a match. Backtrack out, and out of the

3945

// Look Behind altogether.

3946

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3947

fActiveStart = fData[opValue+2];

3948

fActiveLimit = fData[opValue+3];

3949

U_ASSERT(fActiveStart >= 0)(void)0;

3950

U_ASSERT(fActiveLimit <= fInputLength)(void)0;

3951

break;

3952

}

3953

3954

// Save state to this URX_LB_CONT op, so failure to match will repeat the loop.

3955

// (successful match will fall off the end of the loop.)

3956

fp = StateSave(fp, fp->fPatIdx-3, status);

3957

fp->fInputIdx = lbStartIdx;

3958

}

3959

break;

3960

3961

case URX_LB_END:

3962

// End of a look-behind block, after a successful match.

3963

{

3964

U_ASSERT(opValue>=0 && opValue+4<fPattern->fDataSize)(void)0;

3965

if (fp->fInputIdx != fActiveLimit) {

3966

// The look-behind expression matched, but the match did not

3967

// extend all the way to the point that we are looking behind from.

3968

// FAIL out of here, which will take us back to the LB_CONT, which

3969

// will retry the match starting at another position or fail

3970

// the look-behind altogether, whichever is appropriate.

3971

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

3972

break;

3973

}

3974

3975

// Look-behind match is good. Restore the original input string region,

3976

// which had been truncated to pin the end of the lookbehind match to the

3977

// position being looked-behind.

3978

fActiveStart = fData[opValue+2];

3979

fActiveLimit = fData[opValue+3];

3980

U_ASSERT(fActiveStart >= 0)(void)0;

3981

U_ASSERT(fActiveLimit <= fInputLength)(void)0;

3982

}

3983

break;

3984

3985

3986

case URX_LBN_CONT:

3987

{

3988

// Negative Look-Behind, at top of loop checking for matches of LB expression

3989

// at all possible input starting positions.

3990

3991

// Fetch the extra parameters of this op.

3992

int32_t minML = (int32_t)pat[fp->fPatIdx++];

3993

int32_t maxML = (int32_t)pat[fp->fPatIdx++];

3994

if (!UTEXT_USES_U16(fInputText)(__null==((fInputText)->pFuncs->mapNativeIndexToUTF16))) {

3995

// utf-8 fix to maximum match length. The pattern compiler assumes utf-16.

3996

// The max length need not be exact; it just needs to be >= actual maximum.

3997

maxML *= 3;

3998

}

3999

int32_t continueLoc = (int32_t)pat[fp->fPatIdx++];

4000

continueLoc = URX_VAL(continueLoc)((continueLoc) & 0xffffff);

4001

U_ASSERT(minML <= maxML)(void)0;

4002

U_ASSERT(minML >= 0)(void)0;

4003

U_ASSERT(continueLoc > fp->fPatIdx)(void)0;

4004

4005

// Fetch (from data) the last input index where a match was attempted.

4006

U_ASSERT(opValue>=0 && opValue+4<fPattern->fDataSize)(void)0;

4007

int64_t &lbStartIdx = fData[opValue+4];

4008

if (lbStartIdx < 0) {

4009

// First time through loop.

4010

lbStartIdx = fp->fInputIdx - minML;

4011

if (lbStartIdx > 0) {

4012

// move index to a code point boundary, if it's not on one already.

4013

UTEXT_SETNATIVEINDEX(fInputText, lbStartIdx)do { int64_t __offset = (lbStartIdx) - (fInputText)->chunkNativeStart
; if (__offset>=0 && __offset<(int64_t)(fInputText
)->nativeIndexingLimit && (fInputText)->chunkContents
[__offset]<0xdc00) { (fInputText)->chunkOffset=(int32_t
)__offset; } else { utext_setNativeIndex_71((fInputText), (lbStartIdx
)); } } while (false);

4014

lbStartIdx = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

4015

}

4016

} else {

4017

// 2nd through nth time through the loop.

4018

// Back up start position for match by one.

4019

if (lbStartIdx == 0) {

4020

(lbStartIdx)--;

4021

} else {

4022

UTEXT_SETNATIVEINDEX(fInputText, lbStartIdx)do { int64_t __offset = (lbStartIdx) - (fInputText)->chunkNativeStart
; if (__offset>=0 && __offset<(int64_t)(fInputText
)->nativeIndexingLimit && (fInputText)->chunkContents
[__offset]<0xdc00) { (fInputText)->chunkOffset=(int32_t
)__offset; } else { utext_setNativeIndex_71((fInputText), (lbStartIdx
)); } } while (false);

4023

(void)UTEXT_PREVIOUS32(fInputText)((fInputText)->chunkOffset > 0 && (fInputText)->
chunkContents[(fInputText)->chunkOffset-1] < 0xd800 ? (
fInputText)->chunkContents[--((fInputText)->chunkOffset
)] : utext_previous32_71(fInputText));

4024

lbStartIdx = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

4025

}

4026

}

4027

4028

if (lbStartIdx < 0 || lbStartIdx < fp->fInputIdx - maxML) {

4029

// We have tried all potential match starting points without

4030

// getting a match, which means that the negative lookbehind as

4031

// a whole has succeeded. Jump forward to the continue location

4032

fActiveStart = fData[opValue+2];

4033

fActiveLimit = fData[opValue+3];

4034

U_ASSERT(fActiveStart >= 0)(void)0;

4035

U_ASSERT(fActiveLimit <= fInputLength)(void)0;

4036

fp->fPatIdx = continueLoc;

4037

break;

4038

}

4039

4040

// Save state to this URX_LB_CONT op, so failure to match will repeat the loop.

4041

// (successful match will cause a FAIL out of the loop altogether.)

4042

fp = StateSave(fp, fp->fPatIdx-4, status);

4043

fp->fInputIdx = lbStartIdx;

4044

}

4045

break;

4046

4047

case URX_LBN_END:

4048

// End of a negative look-behind block, after a successful match.

4049

{

4050

U_ASSERT(opValue>=0 && opValue+4<fPattern->fDataSize)(void)0;

4051

if (fp->fInputIdx != fActiveLimit) {

4052

// The look-behind expression matched, but the match did not

4053

// extend all the way to the point that we are looking behind from.

4054

// FAIL out of here, which will take us back to the LB_CONT, which

4055

// will retry the match starting at another position or succeed

4056

// the look-behind altogether, whichever is appropriate.

4057

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4058

break;

4059

}

4060

4061

// Look-behind expression matched, which means look-behind test as

4062

// a whole Fails

4063

4064

// Restore the original input string length, which had been truncated

4065

// inorder to pin the end of the lookbehind match

4066

// to the position being looked-behind.

4067

fActiveStart = fData[opValue+2];

4068

fActiveLimit = fData[opValue+3];

4069

U_ASSERT(fActiveStart >= 0)(void)0;

4070

U_ASSERT(fActiveLimit <= fInputLength)(void)0;

4071

4072

// Restore original stack position, discarding any state saved

4073

// by the successful pattern match.

4074

U_ASSERT(opValue>=0 && opValue+1<fPattern->fDataSize)(void)0;

4075

int32_t newStackSize = (int32_t)fData[opValue];

4076

U_ASSERT(fStack->size() > newStackSize)(void)0;

4077

fStack->setSize(newStackSize);

4078

4079

// FAIL, which will take control back to someplace

4080

// prior to entering the look-behind test.

4081

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4082

}

4083

break;

4084

4085

4086

case URX_LOOP_SR_I:

4087

// Loop Initialization for the optimized implementation of

4088

// [some character set]*

4089

// This op scans through all matching input.

4090

// The following LOOP_C op emulates stack unwinding if the following pattern fails.

4091

{

4092

U_ASSERT(opValue > 0 && opValue < fSets->size())(void)0;

4093

Regex8BitSet *s8 = &fPattern->fSets8[opValue];

4094

UnicodeSet *s = (UnicodeSet *)fSets->elementAt(opValue);

4095

4096

// Loop through input, until either the input is exhausted or

4097

// we reach a character that is not a member of the set.

4098

int64_t ix = fp->fInputIdx;

4099

UTEXT_SETNATIVEINDEX(fInputText, ix)do { int64_t __offset = (ix) - (fInputText)->chunkNativeStart
; if (__offset>=0 && __offset<(int64_t)(fInputText
)->nativeIndexingLimit && (fInputText)->chunkContents
[__offset]<0xdc00) { (fInputText)->chunkOffset=(int32_t
)__offset; } else { utext_setNativeIndex_71((fInputText), (ix
)); } } while (false);

4100

for (;;) {

4101

if (ix >= fActiveLimit) {

4102

fHitEnd = TRUE1;

4103

break;

4104

}

4105

UChar32 c = UTEXT_NEXT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)++] : utext_next32_71(fInputText));

4106

if (c<256) {

4107

if (s8->contains(c) == FALSE0) {

4108

break;

4109

}

4110

} else {

4111

if (s->contains(c) == FALSE0) {

4112

break;

4113

}

4114

}

4115

ix = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

4116

}

4117

4118

// If there were no matching characters, skip over the loop altogether.

4119

// The loop doesn't run at all, a * op always succeeds.

4120

if (ix == fp->fInputIdx) {

4121

fp->fPatIdx++; // skip the URX_LOOP_C op.

4122

break;

4123

}

4124

4125

// Peek ahead in the compiled pattern, to the URX_LOOP_C that

4126

// must follow. It's operand is the stack location

4127

// that holds the starting input index for the match of this [set]*

4128

int32_t loopcOp = (int32_t)pat[fp->fPatIdx];

4129

U_ASSERT(URX_TYPE(loopcOp) == URX_LOOP_C)(void)0;

4130

int32_t stackLoc = URX_VAL(loopcOp)((loopcOp) & 0xffffff);

4131

U_ASSERT(stackLoc >= 0 && stackLoc < fFrameSize)(void)0;

4132

fp->fExtra[stackLoc] = fp->fInputIdx;

4133

fp->fInputIdx = ix;

4134

4135

// Save State to the URX_LOOP_C op that follows this one,

4136

// so that match failures in the following code will return to there.

4137

// Then bump the pattern idx so the LOOP_C is skipped on the way out of here.

4138

fp = StateSave(fp, fp->fPatIdx, status);

4139

fp->fPatIdx++;

4140

}

4141

break;

4142

4143

4144

case URX_LOOP_DOT_I:

4145

// Loop Initialization for the optimized implementation of .*

4146

// This op scans through all remaining input.

4147

// The following LOOP_C op emulates stack unwinding if the following pattern fails.

4148

{

4149

// Loop through input until the input is exhausted (we reach an end-of-line)

4150

// In DOTALL mode, we can just go straight to the end of the input.

4151

int64_t ix;

4152

if ((opValue & 1) == 1) {

4153

// Dot-matches-All mode. Jump straight to the end of the string.

4154

ix = fActiveLimit;

4155

fHitEnd = TRUE1;

4156

} else {

4157

// NOT DOT ALL mode. Line endings do not match '.'

4158

// Scan forward until a line ending or end of input.

4159

ix = fp->fInputIdx;

4160

UTEXT_SETNATIVEINDEX(fInputText, ix)do { int64_t __offset = (ix) - (fInputText)->chunkNativeStart
; if (__offset>=0 && __offset<(int64_t)(fInputText
)->nativeIndexingLimit && (fInputText)->chunkContents
[__offset]<0xdc00) { (fInputText)->chunkOffset=(int32_t
)__offset; } else { utext_setNativeIndex_71((fInputText), (ix
)); } } while (false);

4161

for (;;) {

4162

if (ix >= fActiveLimit) {

4163

fHitEnd = TRUE1;

4164

break;

4165

}

4166

UChar32 c = UTEXT_NEXT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)++] : utext_next32_71(fInputText));

4167

if ((c & 0x7f) <= 0x29) { // Fast filter of non-new-line-s

4168

if ((c == 0x0a) || // 0x0a is newline in both modes.

4169

(((opValue & 2) == 0) && // IF not UNIX_LINES mode

4170

isLineTerminator(c))) {

4171

// char is a line ending. Exit the scanning loop.

4172

break;

4173

}

4174

}

4175

ix = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

4176

}

4177

}

4178

4179

// If there were no matching characters, skip over the loop altogether.

4180

// The loop doesn't run at all, a * op always succeeds.

4181

if (ix == fp->fInputIdx) {

4182

fp->fPatIdx++; // skip the URX_LOOP_C op.

4183

break;

4184

}

4185

4186

// Peek ahead in the compiled pattern, to the URX_LOOP_C that

4187

// must follow. It's operand is the stack location

4188

// that holds the starting input index for the match of this .*

4189

int32_t loopcOp = (int32_t)pat[fp->fPatIdx];

4190

U_ASSERT(URX_TYPE(loopcOp) == URX_LOOP_C)(void)0;

4191

int32_t stackLoc = URX_VAL(loopcOp)((loopcOp) & 0xffffff);

4192

U_ASSERT(stackLoc >= 0 && stackLoc < fFrameSize)(void)0;

4193

fp->fExtra[stackLoc] = fp->fInputIdx;

4194

fp->fInputIdx = ix;

4195

4196

// Save State to the URX_LOOP_C op that follows this one,

4197

// so that match failures in the following code will return to there.

4198

// Then bump the pattern idx so the LOOP_C is skipped on the way out of here.

4199

fp = StateSave(fp, fp->fPatIdx, status);

4200

fp->fPatIdx++;

4201

}

4202

break;

4203

4204

4205

case URX_LOOP_C:

4206

{

4207

U_ASSERT(opValue>=0 && opValue<fFrameSize)(void)0;

4208

backSearchIndex = fp->fExtra[opValue];

4209

U_ASSERT(backSearchIndex <= fp->fInputIdx)(void)0;

4210

if (backSearchIndex == fp->fInputIdx) {

4211

// We've backed up the input idx to the point that the loop started.

4212

// The loop is done. Leave here without saving state.

4213

// Subsequent failures won't come back here.

4214

break;

4215

}

4216

// Set up for the next iteration of the loop, with input index

4217

// backed up by one from the last time through,

4218

// and a state save to this instruction in case the following code fails again.

4219

// (We're going backwards because this loop emulates stack unwinding, not

4220

// the initial scan forward.)

4221

U_ASSERT(fp->fInputIdx > 0)(void)0;

4222

UTEXT_SETNATIVEINDEX(fInputText, fp->fInputIdx)do { int64_t __offset = (fp->fInputIdx) - (fInputText)->
chunkNativeStart; if (__offset>=0 && __offset<(
int64_t)(fInputText)->nativeIndexingLimit && (fInputText
)->chunkContents[__offset]<0xdc00) { (fInputText)->chunkOffset
=(int32_t)__offset; } else { utext_setNativeIndex_71((fInputText
), (fp->fInputIdx)); } } while (false);

4223

UChar32 prevC = UTEXT_PREVIOUS32(fInputText)((fInputText)->chunkOffset > 0 && (fInputText)->
chunkContents[(fInputText)->chunkOffset-1] < 0xd800 ? (
fInputText)->chunkContents[--((fInputText)->chunkOffset
)] : utext_previous32_71(fInputText));

4224

fp->fInputIdx = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

4225

4226

UChar32 twoPrevC = UTEXT_PREVIOUS32(fInputText)((fInputText)->chunkOffset > 0 && (fInputText)->
chunkContents[(fInputText)->chunkOffset-1] < 0xd800 ? (
fInputText)->chunkContents[--((fInputText)->chunkOffset
)] : utext_previous32_71(fInputText));

4227

if (prevC == 0x0a &&

4228

fp->fInputIdx > backSearchIndex &&

4229

twoPrevC == 0x0d) {

4230

int32_t prevOp = (int32_t)pat[fp->fPatIdx-2];

4231

if (URX_TYPE(prevOp)((uint32_t)(prevOp) >> 24) == URX_LOOP_DOT_I) {

4232

// .*, stepping back over CRLF pair.

4233

fp->fInputIdx = UTEXT_GETNATIVEINDEX(fInputText)((fInputText)->chunkOffset <= (fInputText)->nativeIndexingLimit
? (fInputText)->chunkNativeStart+(fInputText)->chunkOffset
: (fInputText)->pFuncs->mapOffsetToNative(fInputText));

4234

}

4235

}

4236

4237

4238

fp = StateSave(fp, fp->fPatIdx-1, status);

4239

}

4240

break;

4241

4242

4243

4244

default:

4245

// Trouble. The compiled pattern contains an entry with an

4246

// unrecognized type tag.

4247

UPRV_UNREACHABLE_ASSERT(void)0;

4248

// Unknown opcode type in opType = URX_TYPE(pat[fp->fPatIdx]). But we have

4249

// reports of this in production code, don't use UPRV_UNREACHABLE_EXIT.

4250

// See ICU-21669.

4251

status = U_INTERNAL_PROGRAM_ERROR;

4252

}

4253

4254

if (U_FAILURE(status)) {

4255

isMatch = FALSE0;

4256

break;

4257

}

4258

}

4259

4260

breakFromLoop:

4261

fMatch = isMatch;

4262

if (isMatch) {

4263

fLastMatchEnd = fMatchEnd;

4264

fMatchStart = startIdx;

4265

fMatchEnd = fp->fInputIdx;

4266

}

4267

4268

#ifdef REGEX_RUN_DEBUG

4269

if (fTraceDebug) {

4270

if (isMatch) {

4271

printf("Match. start=%ld end=%ld\n\n", fMatchStart, fMatchEnd);

4272

} else {

4273

printf("No match\n\n");

4274

}

4275

}

4276

#endif

4277

4278

fFrame = fp; // The active stack frame when the engine stopped.

4279

// Contains the capture group results that we need to

4280

// access later.

4281

return;

4282

}

4283

4284

4285

//--------------------------------------------------------------------------------

4286

//

4287

// MatchChunkAt This is the actual matching engine. Like MatchAt, but with the

4288

// assumption that the entire string is available in the UText's

4289

// chunk buffer. For now, that means we can use int32_t indexes,

4290

// except for anything that needs to be saved (like group starts

4291

// and ends).

4292

//

4293

// startIdx: begin matching a this index.

4294

// toEnd: if true, match must extend to end of the input region

4295

//

4296

//--------------------------------------------------------------------------------

4297

void RegexMatcher::MatchChunkAt(int32_t startIdx, UBool toEnd, UErrorCode &status) {

4298

UBool isMatch = FALSE0; // True if the we have a match.

4299

4300

int32_t backSearchIndex = INT32_MAX(2147483647); // used after greedy single-character matches for searching backwards

4301

4302

int32_t op; // Operation from the compiled pattern, split into

4303

int32_t opType; // the opcode

4304

int32_t opValue; // and the operand value.

4305

4306

#ifdef REGEX_RUN_DEBUG

4307

if (fTraceDebug) {

4308

printf("MatchAt(startIdx=%d)\n", startIdx);

4309

printf("Original Pattern: \"%s\"\n", CStr(StringFromUText(fPattern->fPattern))());

4310

printf("Input String: \"%s\"\n\n", CStr(StringFromUText(fInputText))());

4311

}

4312

#endif

4313

4314

if (U_FAILURE(status)) {

4315

return;

4316

}

4317

4318

// Cache frequently referenced items from the compiled pattern

4319

//

4320

int64_t *pat = fPattern->fCompiledPat->getBuffer();

4321

4322

const UChar *litText = fPattern->fLiteralText.getBuffer();

4323

UVector *fSets = fPattern->fSets;

4324

4325

const UChar *inputBuf = fInputText->chunkContents;

4326

4327

fFrameSize = fPattern->fFrameSize;

4328

REStackFrame *fp = resetStack();

4329

if (U_FAILURE(fDeferredStatus)) {

4330

status = fDeferredStatus;

4331

return;

4332

}

4333

4334

fp->fPatIdx = 0;

4335

fp->fInputIdx = startIdx;

4336

4337

// Zero out the pattern's static data

4338

int32_t i;

4339

for (i = 0; i<fPattern->fDataSize; i++) {

4340

fData[i] = 0;

4341

}

4342

4343

//

4344

// Main loop for interpreting the compiled pattern.

4345

// One iteration of the loop per pattern operation performed.

4346

//

4347

for (;;) {

4348

op = (int32_t)pat[fp->fPatIdx];

4349

opType = URX_TYPE(op)((uint32_t)(op) >> 24);

4350

opValue = URX_VAL(op)((op) & 0xffffff);

4351

#ifdef REGEX_RUN_DEBUG

4352

if (fTraceDebug) {

4353

UTEXT_SETNATIVEINDEX(fInputText, fp->fInputIdx)do { int64_t __offset = (fp->fInputIdx) - (fInputText)->
chunkNativeStart; if (__offset>=0 && __offset<(
int64_t)(fInputText)->nativeIndexingLimit && (fInputText
)->chunkContents[__offset]<0xdc00) { (fInputText)->chunkOffset
=(int32_t)__offset; } else { utext_setNativeIndex_71((fInputText
), (fp->fInputIdx)); } } while (false);

4354

printf("inputIdx=%ld inputChar=%x sp=%3ld activeLimit=%ld ", fp->fInputIdx,

4355

UTEXT_CURRENT32(fInputText)((fInputText)->chunkOffset < (fInputText)->chunkLength
&& ((fInputText)->chunkContents)[(fInputText)->
chunkOffset]<0xd800 ? ((fInputText)->chunkContents)[((fInputText
)->chunkOffset)] : utext_current32_71(fInputText)), (int64_t *)fp-fStack->getBuffer(), fActiveLimit);

4356

fPattern->dumpOp(fp->fPatIdx);

4357

}

4358

#endif

4359

fp->fPatIdx++;

4360

4361

switch (opType) {

4362

4363

4364

case URX_NOP:

4365

break;

4366

4367

4368

case URX_BACKTRACK:

4369

// Force a backtrack. In some circumstances, the pattern compiler

4370

// will notice that the pattern can't possibly match anything, and will

4371

// emit one of these at that point.

4372

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4373

break;

4374

4375

4376

case URX_ONECHAR:

4377

if (fp->fInputIdx < fActiveLimit) {

4378

UChar32 c;

4379

U16_NEXT(inputBuf, fp->fInputIdx, fActiveLimit, c)do { (c)=(inputBuf)[(fp->fInputIdx)++]; if((((c)&0xfffffc00
)==0xd800)) { uint16_t __c2; if((fp->fInputIdx)!=(fActiveLimit
) && (((__c2=(inputBuf)[(fp->fInputIdx)])&0xfffffc00
)==0xdc00)) { ++(fp->fInputIdx); (c)=(((UChar32)((c))<<
10UL)+(UChar32)(__c2)-((0xd800<<10UL)+0xdc00-0x10000));
} } } while (false);

4380

if (c == opValue) {

4381

break;

4382

}

4383

} else {

4384

fHitEnd = TRUE1;

4385

}

4386

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4387

break;

4388

4389

4390

case URX_STRING:

4391

{

4392

// Test input against a literal string.

4393

// Strings require two slots in the compiled pattern, one for the

4394

// offset to the string text, and one for the length.

4395

int32_t stringStartIdx = opValue;

4396

int32_t stringLen;

4397

4398

op = (int32_t)pat[fp->fPatIdx]; // Fetch the second operand

4399

fp->fPatIdx++;

4400

opType = URX_TYPE(op)((uint32_t)(op) >> 24);

4401

stringLen = URX_VAL(op)((op) & 0xffffff);

4402

U_ASSERT(opType == URX_STRING_LEN)(void)0;

4403

U_ASSERT(stringLen >= 2)(void)0;

4404

4405

const UChar * pInp = inputBuf + fp->fInputIdx;

4406

const UChar * pInpLimit = inputBuf + fActiveLimit;

4407

const UChar * pPat = litText+stringStartIdx;

4408

const UChar * pEnd = pInp + stringLen;

4409

UBool success = TRUE1;

4410

while (pInp < pEnd) {

4411

if (pInp >= pInpLimit) {

4412

fHitEnd = TRUE1;

4413

success = FALSE0;

4414

break;

4415

}

4416

if (*pInp++ != *pPat++) {

4417

success = FALSE0;

4418

break;

4419

}

4420

}

4421

4422

if (success) {

4423

fp->fInputIdx += stringLen;

4424

} else {

4425

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4426

}

4427

}

4428

break;

4429

4430

4431

case URX_STATE_SAVE:

4432

fp = StateSave(fp, opValue, status);

4433

break;

4434

4435

4436

case URX_END:

4437

// The match loop will exit via this path on a successful match,

4438

// when we reach the end of the pattern.

4439

if (toEnd && fp->fInputIdx != fActiveLimit) {

4440

// The pattern matched, but not to the end of input. Try some more.

4441

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4442

break;

4443

}

4444

isMatch = TRUE1;

4445

goto breakFromLoop;

4446

4447

// Start and End Capture stack frame variables are laid out out like this:

4448

// fp->fExtra[opValue] - The start of a completed capture group

4449

// opValue+1 - The end of a completed capture group

4450

// opValue+2 - the start of a capture group whose end

4451

// has not yet been reached (and might not ever be).

4452

case URX_START_CAPTURE:

4453

U_ASSERT(opValue >= 0 && opValue < fFrameSize-3)(void)0;

4454

fp->fExtra[opValue+2] = fp->fInputIdx;

4455

break;

4456

4457

4458

case URX_END_CAPTURE:

4459

U_ASSERT(opValue >= 0 && opValue < fFrameSize-3)(void)0;

4460

U_ASSERT(fp->fExtra[opValue+2] >= 0)(void)0; // Start pos for this group must be set.

4461

fp->fExtra[opValue] = fp->fExtra[opValue+2]; // Tentative start becomes real.

4462

fp->fExtra[opValue+1] = fp->fInputIdx; // End position

4463

U_ASSERT(fp->fExtra[opValue] <= fp->fExtra[opValue+1])(void)0;

4464

break;

4465

4466

4467

case URX_DOLLAR: // $, test for End of line

4468

// or for position before new line at end of input

4469

if (fp->fInputIdx < fAnchorLimit-2) {

4470

// We are no where near the end of input. Fail.

4471

// This is the common case. Keep it first.

4472

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4473

break;

4474

}

4475

if (fp->fInputIdx >= fAnchorLimit) {

4476

// We really are at the end of input. Success.

4477

fHitEnd = TRUE1;

4478

fRequireEnd = TRUE1;

4479

break;

4480

}

4481

4482

// If we are positioned just before a new-line that is located at the

4483

// end of input, succeed.

4484

if (fp->fInputIdx == fAnchorLimit-1) {

4485

UChar32 c;

4486

U16_GET(inputBuf, fAnchorStart, fp->fInputIdx, fAnchorLimit, c)do { (c)=(inputBuf)[fp->fInputIdx]; if((((c)&0xfffff800
)==0xd800)) { uint16_t __c2; if((((c)&0x400)==0)) { if((fp
->fInputIdx)+1!=(fAnchorLimit) && (((__c2=(inputBuf
)[(fp->fInputIdx)+1])&0xfffffc00)==0xdc00)) { (c)=(((UChar32
)((c))<<10UL)+(UChar32)(__c2)-((0xd800<<10UL)+0xdc00
-0x10000)); } } else { if((fp->fInputIdx)>(fAnchorStart
) && (((__c2=(inputBuf)[(fp->fInputIdx)-1])&0xfffffc00
)==0xd800)) { (c)=(((UChar32)(__c2)<<10UL)+(UChar32)((c
))-((0xd800<<10UL)+0xdc00-0x10000)); } } } } while (false
);

4487

4488

if (isLineTerminator(c)) {

4489

if ( !(c==0x0a && fp->fInputIdx>fAnchorStart && inputBuf[fp->fInputIdx-1]==0x0d)) {

4490

// At new-line at end of input. Success

4491

fHitEnd = TRUE1;

4492

fRequireEnd = TRUE1;

4493

break;

4494

}

4495

}

4496

} else if (fp->fInputIdx == fAnchorLimit-2 &&

4497

inputBuf[fp->fInputIdx]==0x0d && inputBuf[fp->fInputIdx+1]==0x0a) {

4498

fHitEnd = TRUE1;

4499

fRequireEnd = TRUE1;

4500

break; // At CR/LF at end of input. Success

4501

}

4502

4503

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4504

4505

break;

4506

4507

4508

case URX_DOLLAR_D: // $, test for End of Line, in UNIX_LINES mode.

4509

if (fp->fInputIdx >= fAnchorLimit-1) {

4510

// Either at the last character of input, or off the end.

4511

if (fp->fInputIdx == fAnchorLimit-1) {

4512

// At last char of input. Success if it's a new line.

4513

if (inputBuf[fp->fInputIdx] == 0x0a) {

4514

fHitEnd = TRUE1;

4515

fRequireEnd = TRUE1;

4516

break;

4517

}

4518

} else {

4519

// Off the end of input. Success.

4520

fHitEnd = TRUE1;

4521

fRequireEnd = TRUE1;

4522

break;

4523

}

4524

}

4525

4526

// Not at end of input. Back-track out.

4527

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4528

break;

4529

4530

4531

case URX_DOLLAR_M: // $, test for End of line in multi-line mode

4532

{

4533

if (fp->fInputIdx >= fAnchorLimit) {

4534

// We really are at the end of input. Success.

4535

fHitEnd = TRUE1;

4536

fRequireEnd = TRUE1;

4537

break;

4538

}

4539

// If we are positioned just before a new-line, succeed.

4540

// It makes no difference where the new-line is within the input.

4541

UChar32 c = inputBuf[fp->fInputIdx];

4542

if (isLineTerminator(c)) {

4543

// At a line end, except for the odd chance of being in the middle of a CR/LF sequence

4544

// In multi-line mode, hitting a new-line just before the end of input does not

4545

// set the hitEnd or requireEnd flags

4546

if ( !(c==0x0a && fp->fInputIdx>fAnchorStart && inputBuf[fp->fInputIdx-1]==0x0d)) {

4547

break;

4548

}

4549

}

4550

// not at a new line. Fail.

4551

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4552

}

4553

break;

4554

4555

4556

case URX_DOLLAR_MD: // $, test for End of line in multi-line and UNIX_LINES mode

4557

{

4558

if (fp->fInputIdx >= fAnchorLimit) {

4559

// We really are at the end of input. Success.

4560

fHitEnd = TRUE1;

4561

fRequireEnd = TRUE1; // Java set requireEnd in this case, even though

4562

break; // adding a new-line would not lose the match.

4563

}

4564

// If we are not positioned just before a new-line, the test fails; backtrack out.

4565

// It makes no difference where the new-line is within the input.

4566

if (inputBuf[fp->fInputIdx] != 0x0a) {

4567

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4568

}

4569

}

4570

break;

4571

4572

4573

case URX_CARET: // ^, test for start of line

4574

if (fp->fInputIdx != fAnchorStart) {

4575

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4576

}

4577

break;

4578

4579

4580

case URX_CARET_M: // ^, test for start of line in mulit-line mode

4581

{

4582

if (fp->fInputIdx == fAnchorStart) {

4583

// We are at the start input. Success.

4584

break;

4585

}

4586

// Check whether character just before the current pos is a new-line

4587

// unless we are at the end of input

4588

UChar c = inputBuf[fp->fInputIdx - 1];

4589

if ((fp->fInputIdx < fAnchorLimit) &&

4590

isLineTerminator(c)) {

4591

// It's a new-line. ^ is true. Success.

4592

// TODO: what should be done with positions between a CR and LF?

4593

break;

4594

}

4595

// Not at the start of a line. Fail.

4596

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4597

}

4598

break;

4599

4600

4601

case URX_CARET_M_UNIX: // ^, test for start of line in mulit-line + Unix-line mode

4602

{

4603

U_ASSERT(fp->fInputIdx >= fAnchorStart)(void)0;

4604

if (fp->fInputIdx <= fAnchorStart) {

4605

// We are at the start input. Success.

4606

break;

4607

}

4608

// Check whether character just before the current pos is a new-line

4609

U_ASSERT(fp->fInputIdx <= fAnchorLimit)(void)0;

4610

UChar c = inputBuf[fp->fInputIdx - 1];

4611

if (c != 0x0a) {

4612

// Not at the start of a line. Back-track out.

4613

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4614

}

4615

}

4616

break;

4617

4618

case URX_BACKSLASH_B: // Test for word boundaries

4619

{

4620

UBool success = isChunkWordBoundary((int32_t)fp->fInputIdx);

4621

success ^= (UBool)(opValue != 0); // flip sense for \B

4622

if (!success) {

4623

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4624

}

4625

}

4626

break;

4627

4628

4629

case URX_BACKSLASH_BU: // Test for word boundaries, Unicode-style

4630

{

4631

UBool success = isUWordBoundary(fp->fInputIdx, status);

4632

success ^= (UBool)(opValue != 0); // flip sense for \B

4633

if (!success) {

4634

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4635

}

4636

}

4637

break;

4638

4639

4640

case URX_BACKSLASH_D: // Test for decimal digit

4641

{

4642

if (fp->fInputIdx >= fActiveLimit) {

4643

fHitEnd = TRUE1;

4644

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4645

break;

4646

}

4647

4648

UChar32 c;

4649

U16_NEXT(inputBuf, fp->fInputIdx, fActiveLimit, c)do { (c)=(inputBuf)[(fp->fInputIdx)++]; if((((c)&0xfffffc00
)==0xd800)) { uint16_t __c2; if((fp->fInputIdx)!=(fActiveLimit
) && (((__c2=(inputBuf)[(fp->fInputIdx)])&0xfffffc00
)==0xdc00)) { ++(fp->fInputIdx); (c)=(((UChar32)((c))<<
10UL)+(UChar32)(__c2)-((0xd800<<10UL)+0xdc00-0x10000));
} } } while (false);

4650

int8_t ctype = u_charTypeu_charType_71(c); // TODO: make a unicode set for this. Will be faster.

4651

UBool success = (ctype == U_DECIMAL_DIGIT_NUMBER);

4652

success ^= (UBool)(opValue != 0); // flip sense for \D

4653

if (!success) {

4654

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4655

}

4656

}

4657

break;

4658

4659

4660

case URX_BACKSLASH_G: // Test for position at end of previous match

4661

if (!((fMatch && fp->fInputIdx==fMatchEnd) || (fMatch==FALSE0 && fp->fInputIdx==fActiveStart))) {

4662

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4663

}

4664

break;

4665

4666

4667

case URX_BACKSLASH_H: // Test for \h, horizontal white space.

4668

{

4669

if (fp->fInputIdx >= fActiveLimit) {

4670

fHitEnd = TRUE1;

4671

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4672

break;

4673

}

4674

UChar32 c;

4675

U16_NEXT(inputBuf, fp->fInputIdx, fActiveLimit, c)do { (c)=(inputBuf)[(fp->fInputIdx)++]; if((((c)&0xfffffc00
)==0xd800)) { uint16_t __c2; if((fp->fInputIdx)!=(fActiveLimit
) && (((__c2=(inputBuf)[(fp->fInputIdx)])&0xfffffc00
)==0xdc00)) { ++(fp->fInputIdx); (c)=(((UChar32)((c))<<
10UL)+(UChar32)(__c2)-((0xd800<<10UL)+0xdc00-0x10000));
} } } while (false);

4676

int8_t ctype = u_charTypeu_charType_71(c);

4677

UBool success = (ctype == U_SPACE_SEPARATOR || c == 9); // SPACE_SEPARATOR || TAB

4678

success ^= (UBool)(opValue != 0); // flip sense for \H

4679

if (!success) {

4680

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4681

}

4682

}

4683

break;

4684

4685

4686

case URX_BACKSLASH_R: // Test for \R, any line break sequence.

4687

{

4688

if (fp->fInputIdx >= fActiveLimit) {

4689

fHitEnd = TRUE1;

4690

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4691

break;

4692

}

4693

UChar32 c;

4694

U16_NEXT(inputBuf, fp->fInputIdx, fActiveLimit, c)do { (c)=(inputBuf)[(fp->fInputIdx)++]; if((((c)&0xfffffc00
)==0xd800)) { uint16_t __c2; if((fp->fInputIdx)!=(fActiveLimit
) && (((__c2=(inputBuf)[(fp->fInputIdx)])&0xfffffc00
)==0xdc00)) { ++(fp->fInputIdx); (c)=(((UChar32)((c))<<
10UL)+(UChar32)(__c2)-((0xd800<<10UL)+0xdc00-0x10000));
} } } while (false);

4695

if (isLineTerminator(c)) {

4696

if (c == 0x0d && fp->fInputIdx < fActiveLimit) {

4697

// Check for CR/LF sequence. Consume both together when found.

4698

UChar c2;

4699

U16_NEXT(inputBuf, fp->fInputIdx, fActiveLimit, c2)do { (c2)=(inputBuf)[(fp->fInputIdx)++]; if((((c2)&0xfffffc00
)==0xd800)) { uint16_t __c2; if((fp->fInputIdx)!=(fActiveLimit
) && (((__c2=(inputBuf)[(fp->fInputIdx)])&0xfffffc00
)==0xdc00)) { ++(fp->fInputIdx); (c2)=(((UChar32)((c2))<<
10UL)+(UChar32)(__c2)-((0xd800<<10UL)+0xdc00-0x10000));
} } } while (false);

4700

if (c2 != 0x0a) {

4701

U16_PREV(inputBuf, 0, fp->fInputIdx, c2)do { (c2)=(inputBuf)[--(fp->fInputIdx)]; if((((c2)&0xfffffc00
)==0xdc00)) { uint16_t __c2; if((fp->fInputIdx)>(0) &&
(((__c2=(inputBuf)[(fp->fInputIdx)-1])&0xfffffc00)==0xd800
)) { --(fp->fInputIdx); (c2)=(((UChar32)(__c2)<<10UL
)+(UChar32)((c2))-((0xd800<<10UL)+0xdc00-0x10000)); } }
} while (false);

4702

}

4703

}

4704

} else {

4705

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4706

}

4707

}

4708

break;

4709

4710

4711

case URX_BACKSLASH_V: // Any single code point line ending.

4712

{

4713

if (fp->fInputIdx >= fActiveLimit) {

4714

fHitEnd = TRUE1;

4715

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4716

break;

4717

}

4718

UChar32 c;

4719

U16_NEXT(inputBuf, fp->fInputIdx, fActiveLimit, c)do { (c)=(inputBuf)[(fp->fInputIdx)++]; if((((c)&0xfffffc00
)==0xd800)) { uint16_t __c2; if((fp->fInputIdx)!=(fActiveLimit
) && (((__c2=(inputBuf)[(fp->fInputIdx)])&0xfffffc00
)==0xdc00)) { ++(fp->fInputIdx); (c)=(((UChar32)((c))<<
10UL)+(UChar32)(__c2)-((0xd800<<10UL)+0xdc00-0x10000));
} } } while (false);

4720

UBool success = isLineTerminator(c);

4721

success ^= (UBool)(opValue != 0); // flip sense for \V

4722

if (!success) {

4723

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4724

}

4725

}

4726

break;

4727

4728

4729

case URX_BACKSLASH_X:

4730

// Match a Grapheme, as defined by Unicode UAX 29.

4731

4732

// Fail if at end of input

4733

if (fp->fInputIdx >= fActiveLimit) {

4734

fHitEnd = TRUE1;

4735

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4736

break;

4737

}

4738

4739

fp->fInputIdx = followingGCBoundary(fp->fInputIdx, status);

4740

if (fp->fInputIdx >= fActiveLimit) {

4741

fHitEnd = TRUE1;

4742

fp->fInputIdx = fActiveLimit;

4743

}

4744

break;

4745

4746

4747

case URX_BACKSLASH_Z: // Test for end of Input

4748

if (fp->fInputIdx < fAnchorLimit) {

4749

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4750

} else {

4751

fHitEnd = TRUE1;

4752

fRequireEnd = TRUE1;

4753

}

4754

break;

4755

4756

4757

4758

case URX_STATIC_SETREF:

4759

{

4760

// Test input character against one of the predefined sets

4761

// (Word Characters, for example)

4762

// The high bit of the op value is a flag for the match polarity.

4763

// 0: success if input char is in set.

4764

// 1: success if input char is not in set.

4765

if (fp->fInputIdx >= fActiveLimit) {

4766

fHitEnd = TRUE1;

4767

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4768

break;

4769

}

4770

4771

UBool success = ((opValue & URX_NEG_SET) == URX_NEG_SET);

4772

opValue &= ~URX_NEG_SET;

4773

U_ASSERT(opValue > 0 && opValue < URX_LAST_SET)(void)0;

4774

4775

UChar32 c;

4776

U16_NEXT(inputBuf, fp->fInputIdx, fActiveLimit, c)do { (c)=(inputBuf)[(fp->fInputIdx)++]; if((((c)&0xfffffc00
)==0xd800)) { uint16_t __c2; if((fp->fInputIdx)!=(fActiveLimit
) && (((__c2=(inputBuf)[(fp->fInputIdx)])&0xfffffc00
)==0xdc00)) { ++(fp->fInputIdx); (c)=(((UChar32)((c))<<
10UL)+(UChar32)(__c2)-((0xd800<<10UL)+0xdc00-0x10000));
} } } while (false);

4777

if (c < 256) {

4778

Regex8BitSet &s8 = RegexStaticSets::gStaticSets->fPropSets8[opValue];

4779

if (s8.contains(c)) {

4780

success = !success;

4781

}

4782

} else {

4783

const UnicodeSet &s = RegexStaticSets::gStaticSets->fPropSets[opValue];

4784

if (s.contains(c)) {

4785

success = !success;

4786

}

4787

}

4788

if (!success) {

4789

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4790

}

4791

}

4792

break;

4793

4794

4795

case URX_STAT_SETREF_N:

4796

{

4797

// Test input character for NOT being a member of one of

4798

// the predefined sets (Word Characters, for example)

4799

if (fp->fInputIdx >= fActiveLimit) {

4800

fHitEnd = TRUE1;

4801

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4802

break;

4803

}

4804

4805

U_ASSERT(opValue > 0 && opValue < URX_LAST_SET)(void)0;

4806

4807

UChar32 c;

4808

U16_NEXT(inputBuf, fp->fInputIdx, fActiveLimit, c)do { (c)=(inputBuf)[(fp->fInputIdx)++]; if((((c)&0xfffffc00
)==0xd800)) { uint16_t __c2; if((fp->fInputIdx)!=(fActiveLimit
) && (((__c2=(inputBuf)[(fp->fInputIdx)])&0xfffffc00
)==0xdc00)) { ++(fp->fInputIdx); (c)=(((UChar32)((c))<<
10UL)+(UChar32)(__c2)-((0xd800<<10UL)+0xdc00-0x10000));
} } } while (false);

4809

if (c < 256) {

4810

Regex8BitSet &s8 = RegexStaticSets::gStaticSets->fPropSets8[opValue];

4811

if (s8.contains(c) == FALSE0) {

4812

break;

4813

}

4814

} else {

4815

const UnicodeSet &s = RegexStaticSets::gStaticSets->fPropSets[opValue];

4816

if (s.contains(c) == FALSE0) {

4817

break;

4818

}

4819

}

4820

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4821

}

4822

break;

4823

4824

4825

case URX_SETREF:

4826

{

4827

if (fp->fInputIdx >= fActiveLimit) {

4828

fHitEnd = TRUE1;

4829

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4830

break;

4831

}

4832

4833

U_ASSERT(opValue > 0 && opValue < fSets->size())(void)0;

4834

4835

// There is input left. Pick up one char and test it for set membership.

4836

UChar32 c;

4837

U16_NEXT(inputBuf, fp->fInputIdx, fActiveLimit, c)do { (c)=(inputBuf)[(fp->fInputIdx)++]; if((((c)&0xfffffc00
)==0xd800)) { uint16_t __c2; if((fp->fInputIdx)!=(fActiveLimit
) && (((__c2=(inputBuf)[(fp->fInputIdx)])&0xfffffc00
)==0xdc00)) { ++(fp->fInputIdx); (c)=(((UChar32)((c))<<
10UL)+(UChar32)(__c2)-((0xd800<<10UL)+0xdc00-0x10000));
} } } while (false);

4838

if (c<256) {

4839

Regex8BitSet *s8 = &fPattern->fSets8[opValue];

4840

if (s8->contains(c)) {

4841

// The character is in the set. A Match.

4842

break;

4843

}

4844

} else {

4845

UnicodeSet *s = (UnicodeSet *)fSets->elementAt(opValue);

4846

if (s->contains(c)) {

4847

// The character is in the set. A Match.

4848

break;

4849

}

4850

}

4851

4852

// the character wasn't in the set.

4853

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4854

}

4855

break;

4856

4857

4858

case URX_DOTANY:

4859

{

4860

// . matches anything, but stops at end-of-line.

4861

if (fp->fInputIdx >= fActiveLimit) {

4862

// At end of input. Match failed. Backtrack out.

4863

fHitEnd = TRUE1;

4864

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4865

break;

4866

}

4867

4868

// There is input left. Advance over one char, unless we've hit end-of-line

4869

UChar32 c;

4870

U16_NEXT(inputBuf, fp->fInputIdx, fActiveLimit, c)do { (c)=(inputBuf)[(fp->fInputIdx)++]; if((((c)&0xfffffc00
)==0xd800)) { uint16_t __c2; if((fp->fInputIdx)!=(fActiveLimit
) && (((__c2=(inputBuf)[(fp->fInputIdx)])&0xfffffc00
)==0xdc00)) { ++(fp->fInputIdx); (c)=(((UChar32)((c))<<
10UL)+(UChar32)(__c2)-((0xd800<<10UL)+0xdc00-0x10000));
} } } while (false);

4871

if (isLineTerminator(c)) {

4872

// End of line in normal mode. . does not match.

4873

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4874

break;

4875

}

4876

}

4877

break;

4878

4879

4880

case URX_DOTANY_ALL:

4881

{

4882

// . in dot-matches-all (including new lines) mode

4883

if (fp->fInputIdx >= fActiveLimit) {

4884

// At end of input. Match failed. Backtrack out.

4885

fHitEnd = TRUE1;

4886

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4887

break;

4888

}

4889

4890

// There is input left. Advance over one char, except if we are

4891

// at a cr/lf, advance over both of them.

4892

UChar32 c;

4893

U16_NEXT(inputBuf, fp->fInputIdx, fActiveLimit, c)do { (c)=(inputBuf)[(fp->fInputIdx)++]; if((((c)&0xfffffc00
)==0xd800)) { uint16_t __c2; if((fp->fInputIdx)!=(fActiveLimit
) && (((__c2=(inputBuf)[(fp->fInputIdx)])&0xfffffc00
)==0xdc00)) { ++(fp->fInputIdx); (c)=(((UChar32)((c))<<
10UL)+(UChar32)(__c2)-((0xd800<<10UL)+0xdc00-0x10000));
} } } while (false);

4894

if (c==0x0d && fp->fInputIdx < fActiveLimit) {

4895

// In the case of a CR/LF, we need to advance over both.

4896

if (inputBuf[fp->fInputIdx] == 0x0a) {

4897

U16_FWD_1(inputBuf, fp->fInputIdx, fActiveLimit)do { if(((((inputBuf)[(fp->fInputIdx)++])&0xfffffc00)==
0xd800) && (fp->fInputIdx)!=(fActiveLimit) &&
((((inputBuf)[fp->fInputIdx])&0xfffffc00)==0xdc00)) {
++(fp->fInputIdx); } } while (false);

4898

}

4899

}

4900

}

4901

break;

4902

4903

4904

case URX_DOTANY_UNIX:

4905

{

4906

// '.' operator, matches all, but stops at end-of-line.

4907

// UNIX_LINES mode, so 0x0a is the only recognized line ending.

4908

if (fp->fInputIdx >= fActiveLimit) {

4909

// At end of input. Match failed. Backtrack out.

4910

fHitEnd = TRUE1;

4911

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4912

break;

4913

}

4914

4915

// There is input left. Advance over one char, unless we've hit end-of-line

4916

UChar32 c;

4917

U16_NEXT(inputBuf, fp->fInputIdx, fActiveLimit, c)do { (c)=(inputBuf)[(fp->fInputIdx)++]; if((((c)&0xfffffc00
)==0xd800)) { uint16_t __c2; if((fp->fInputIdx)!=(fActiveLimit
) && (((__c2=(inputBuf)[(fp->fInputIdx)])&0xfffffc00
)==0xdc00)) { ++(fp->fInputIdx); (c)=(((UChar32)((c))<<
10UL)+(UChar32)(__c2)-((0xd800<<10UL)+0xdc00-0x10000));
} } } while (false);

4918

if (c == 0x0a) {

4919

// End of line in normal mode. '.' does not match the \n

4920

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4921

}

4922

}

4923

break;

4924

4925

4926

case URX_JMP:

4927

fp->fPatIdx = opValue;

4928

break;

4929

4930

case URX_FAIL:

4931

isMatch = FALSE0;

4932

goto breakFromLoop;

4933

4934

case URX_JMP_SAV:

4935

U_ASSERT(opValue < fPattern->fCompiledPat->size())(void)0;

4936

fp = StateSave(fp, fp->fPatIdx, status); // State save to loc following current

4937

fp->fPatIdx = opValue; // Then JMP.

4938

break;

4939

4940

case URX_JMP_SAV_X:

4941

// This opcode is used with (x)+, when x can match a zero length string.

4942

// Same as JMP_SAV, except conditional on the match having made forward progress.

4943

// Destination of the JMP must be a URX_STO_INP_LOC, from which we get the

4944

// data address of the input position at the start of the loop.

4945

{

4946

U_ASSERT(opValue > 0 && opValue < fPattern->fCompiledPat->size())(void)0;

4947

int32_t stoOp = (int32_t)pat[opValue-1];

4948

U_ASSERT(URX_TYPE(stoOp) == URX_STO_INP_LOC)(void)0;

4949

int32_t frameLoc = URX_VAL(stoOp)((stoOp) & 0xffffff);

4950

U_ASSERT(frameLoc >= 0 && frameLoc < fFrameSize)(void)0;

4951

int32_t prevInputIdx = (int32_t)fp->fExtra[frameLoc];

4952

U_ASSERT(prevInputIdx <= fp->fInputIdx)(void)0;

4953

if (prevInputIdx < fp->fInputIdx) {

4954

// The match did make progress. Repeat the loop.

4955

fp = StateSave(fp, fp->fPatIdx, status); // State save to loc following current

4956

fp->fPatIdx = opValue;

4957

fp->fExtra[frameLoc] = fp->fInputIdx;

4958

}

4959

// If the input position did not advance, we do nothing here,

4960

// execution will fall out of the loop.

4961

}

4962

break;

4963

4964

case URX_CTR_INIT:

4965

{

4966

U_ASSERT(opValue >= 0 && opValue < fFrameSize-2)(void)0;

4967

fp->fExtra[opValue] = 0; // Set the loop counter variable to zero

4968

4969

// Pick up the three extra operands that CTR_INIT has, and

4970

// skip the pattern location counter past

4971

int32_t instrOperandLoc = (int32_t)fp->fPatIdx;

4972

fp->fPatIdx += 3;

4973

int32_t loopLoc = URX_VAL(pat[instrOperandLoc])((pat[instrOperandLoc]) & 0xffffff);

4974

int32_t minCount = (int32_t)pat[instrOperandLoc+1];

4975

int32_t maxCount = (int32_t)pat[instrOperandLoc+2];

4976

U_ASSERT(minCount>=0)(void)0;

4977

U_ASSERT(maxCount>=minCount || maxCount==-1)(void)0;

4978

U_ASSERT(loopLoc>=fp->fPatIdx)(void)0;

4979

4980

if (minCount == 0) {

4981

fp = StateSave(fp, loopLoc+1, status);

4982

}

4983

if (maxCount == -1) {

4984

fp->fExtra[opValue+1] = fp->fInputIdx; // For loop breaking.

4985

} else if (maxCount == 0) {

4986

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

4987

}

4988

}

4989

break;

4990

4991

case URX_CTR_LOOP:

4992

{

4993

U_ASSERT(opValue>0 && opValue < fp->fPatIdx-2)(void)0;

4994

int32_t initOp = (int32_t)pat[opValue];

4995

U_ASSERT(URX_TYPE(initOp) == URX_CTR_INIT)(void)0;

4996

int64_t *pCounter = &fp->fExtra[URX_VAL(initOp)((initOp) & 0xffffff)];

4997

int32_t minCount = (int32_t)pat[opValue+2];

4998

int32_t maxCount = (int32_t)pat[opValue+3];

4999

(*pCounter)++;

5000

if ((uint64_t)*pCounter >= (uint32_t)maxCount && maxCount != -1) {

5001

U_ASSERT(*pCounter == maxCount)(void)0;

5002

break;

5003

}

5004

if (*pCounter >= minCount) {

5005

if (maxCount == -1) {

5006

// Loop has no hard upper bound.

5007

// Check that it is progressing through the input, break if it is not.

5008

int64_t *pLastInputIdx = &fp->fExtra[URX_VAL(initOp)((initOp) & 0xffffff) + 1];

5009

if (fp->fInputIdx == *pLastInputIdx) {

5010

break;

5011

} else {

5012

*pLastInputIdx = fp->fInputIdx;

5013

}

5014

}

5015

fp = StateSave(fp, fp->fPatIdx, status);

5016

} else {

5017

// Increment time-out counter. (StateSave() does it if count >= minCount)

5018

fTickCounter--;

5019

if (fTickCounter <= 0) {

5020

IncrementTime(status); // Re-initializes fTickCounter

5021

}

5022

}

5023

fp->fPatIdx = opValue + 4; // Loop back.

5024

}

5025

break;

5026

5027

case URX_CTR_INIT_NG:

5028

{

5029

// Initialize a non-greedy loop

5030

U_ASSERT(opValue >= 0 && opValue < fFrameSize-2)(void)0;

5031

fp->fExtra[opValue] = 0; // Set the loop counter variable to zero

5032

5033

// Pick up the three extra operands that CTR_INIT_NG has, and

5034

// skip the pattern location counter past

5035

int32_t instrOperandLoc = (int32_t)fp->fPatIdx;

5036

fp->fPatIdx += 3;

5037

int32_t loopLoc = URX_VAL(pat[instrOperandLoc])((pat[instrOperandLoc]) & 0xffffff);

5038

int32_t minCount = (int32_t)pat[instrOperandLoc+1];

5039

int32_t maxCount = (int32_t)pat[instrOperandLoc+2];

5040

U_ASSERT(minCount>=0)(void)0;

5041

U_ASSERT(maxCount>=minCount || maxCount==-1)(void)0;

5042

U_ASSERT(loopLoc>fp->fPatIdx)(void)0;

5043

if (maxCount == -1) {

5044

fp->fExtra[opValue+1] = fp->fInputIdx; // Save initial input index for loop breaking.

5045

}

5046

5047

if (minCount == 0) {

5048

if (maxCount != 0) {

5049

fp = StateSave(fp, fp->fPatIdx, status);

5050

}

5051

fp->fPatIdx = loopLoc+1; // Continue with stuff after repeated block

5052

}

5053

}

5054

break;

5055

5056

case URX_CTR_LOOP_NG:

5057

{

5058

// Non-greedy {min, max} loops

5059

U_ASSERT(opValue>0 && opValue < fp->fPatIdx-2)(void)0;

5060

int32_t initOp = (int32_t)pat[opValue];

5061

U_ASSERT(URX_TYPE(initOp) == URX_CTR_INIT_NG)(void)0;

5062

int64_t *pCounter = &fp->fExtra[URX_VAL(initOp)((initOp) & 0xffffff)];

5063

int32_t minCount = (int32_t)pat[opValue+2];

5064

int32_t maxCount = (int32_t)pat[opValue+3];

5065

5066

(*pCounter)++;

5067

if ((uint64_t)*pCounter >= (uint32_t)maxCount && maxCount != -1) {

5068

// The loop has matched the maximum permitted number of times.

5069

// Break out of here with no action. Matching will

5070

// continue with the following pattern.

5071

U_ASSERT(*pCounter == maxCount)(void)0;

5072

break;

5073

}

5074

5075

if (*pCounter < minCount) {

5076

// We haven't met the minimum number of matches yet.

5077

// Loop back for another one.

5078

fp->fPatIdx = opValue + 4; // Loop back.

5079

fTickCounter--;

5080

if (fTickCounter <= 0) {

5081

IncrementTime(status); // Re-initializes fTickCounter

5082

}

5083

} else {

5084

// We do have the minimum number of matches.

5085

5086

// If there is no upper bound on the loop iterations, check that the input index

5087

// is progressing, and stop the loop if it is not.

5088

if (maxCount == -1) {

5089

int64_t *pLastInputIdx = &fp->fExtra[URX_VAL(initOp)((initOp) & 0xffffff) + 1];

5090

if (fp->fInputIdx == *pLastInputIdx) {

5091

break;

5092

}

5093

*pLastInputIdx = fp->fInputIdx;

5094

}

5095

5096

// Loop Continuation: we will fall into the pattern following the loop

5097

// (non-greedy, don't execute loop body first), but first do

5098

// a state save to the top of the loop, so that a match failure

5099

// in the following pattern will try another iteration of the loop.

5100

fp = StateSave(fp, opValue + 4, status);

5101

}

5102

}

5103

break;

5104

5105

case URX_STO_SP:

5106

U_ASSERT(opValue >= 0 && opValue < fPattern->fDataSize)(void)0;

5107

fData[opValue] = fStack->size();

5108

break;

5109

5110

case URX_LD_SP:

5111

{

5112

U_ASSERT(opValue >= 0 && opValue < fPattern->fDataSize)(void)0;

5113

int32_t newStackSize = (int32_t)fData[opValue];

5114

U_ASSERT(newStackSize <= fStack->size())(void)0;

5115

int64_t *newFP = fStack->getBuffer() + newStackSize - fFrameSize;

5116

if (newFP == (int64_t *)fp) {

5117

break;

5118

}

5119

int32_t j;

5120

for (j=0; j<fFrameSize; j++) {

5121

newFP[j] = ((int64_t *)fp)[j];

5122

}

5123

fp = (REStackFrame *)newFP;

5124

fStack->setSize(newStackSize);

5125

}

5126

break;

5127

5128

case URX_BACKREF:

5129

{

5130

U_ASSERT(opValue < fFrameSize)(void)0;

5131

int64_t groupStartIdx = fp->fExtra[opValue];

5132

int64_t groupEndIdx = fp->fExtra[opValue+1];

5133

U_ASSERT(groupStartIdx <= groupEndIdx)(void)0;

5134

int64_t inputIndex = fp->fInputIdx;

5135

if (groupStartIdx < 0) {

5136

// This capture group has not participated in the match thus far,

5137

fp = (REStackFrame *)fStack->popFrame(fFrameSize); // FAIL, no match.

5138

break;

5139

}

5140

UBool success = TRUE1;

5141

for (int64_t groupIndex = groupStartIdx; groupIndex < groupEndIdx; ++groupIndex,++inputIndex) {

5142

if (inputIndex >= fActiveLimit) {

5143

success = FALSE0;

5144

fHitEnd = TRUE1;

5145

break;

5146

}

5147

if (inputBuf[groupIndex] != inputBuf[inputIndex]) {

5148

success = FALSE0;

5149

break;

5150

}

5151

}

5152

if (success && groupStartIdx < groupEndIdx && U16_IS_LEAD(inputBuf[groupEndIdx-1])(((inputBuf[groupEndIdx-1])&0xfffffc00)==0xd800) &&

5153

inputIndex < fActiveLimit && U16_IS_TRAIL(inputBuf[inputIndex])(((inputBuf[inputIndex])&0xfffffc00)==0xdc00)) {

5154

// Capture group ended with an unpaired lead surrogate.

5155

// Back reference is not permitted to match lead only of a surrogatge pair.

5156

success = FALSE0;

5157

}

5158

if (success) {

5159

fp->fInputIdx = inputIndex;

5160

} else {

5161

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

5162

}

5163

}

5164

break;

5165

5166

case URX_BACKREF_I:

5167

{

5168

U_ASSERT(opValue < fFrameSize)(void)0;

5169

int64_t groupStartIdx = fp->fExtra[opValue];

5170

int64_t groupEndIdx = fp->fExtra[opValue+1];

5171

U_ASSERT(groupStartIdx <= groupEndIdx)(void)0;

5172

if (groupStartIdx < 0) {

5173

// This capture group has not participated in the match thus far,

5174

fp = (REStackFrame *)fStack->popFrame(fFrameSize); // FAIL, no match.

5175

break;

5176

}

5177

CaseFoldingUCharIterator captureGroupItr(inputBuf, groupStartIdx, groupEndIdx);

5178

CaseFoldingUCharIterator inputItr(inputBuf, fp->fInputIdx, fActiveLimit);

5179

5180

// Note: if the capture group match was of an empty string the backref

5181

// match succeeds. Verified by testing: Perl matches succeed

5182

// in this case, so we do too.

5183

5184

UBool success = TRUE1;

5185

for (;;) {

5186

UChar32 captureGroupChar = captureGroupItr.next();

5187

if (captureGroupChar == U_SENTINEL(-1)) {

5188

success = TRUE1;

5189

break;

5190

}

5191

UChar32 inputChar = inputItr.next();

5192

if (inputChar == U_SENTINEL(-1)) {

5193

success = FALSE0;

5194

fHitEnd = TRUE1;

5195

break;

5196

}

5197

if (inputChar != captureGroupChar) {

5198

success = FALSE0;

5199

break;

5200

}

5201

}

5202

5203

if (success && inputItr.inExpansion()) {

5204

// We obtained a match by consuming part of a string obtained from

5205

// case-folding a single code point of the input text.

5206

// This does not count as an overall match.

5207

success = FALSE0;

5208

}

5209

5210

if (success) {

5211

fp->fInputIdx = inputItr.getIndex();

5212

} else {

5213

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

5214

}

5215

}

5216

break;

5217

5218

case URX_STO_INP_LOC:

5219

{

5220

U_ASSERT(opValue >= 0 && opValue < fFrameSize)(void)0;

5221

fp->fExtra[opValue] = fp->fInputIdx;

5222

}

5223

break;

5224

5225

case URX_JMPX:

5226

{

5227

int32_t instrOperandLoc = (int32_t)fp->fPatIdx;

5228

fp->fPatIdx += 1;

5229

int32_t dataLoc = URX_VAL(pat[instrOperandLoc])((pat[instrOperandLoc]) & 0xffffff);

5230

U_ASSERT(dataLoc >= 0 && dataLoc < fFrameSize)(void)0;

5231

int32_t savedInputIdx = (int32_t)fp->fExtra[dataLoc];

5232

U_ASSERT(savedInputIdx <= fp->fInputIdx)(void)0;

5233

if (savedInputIdx < fp->fInputIdx) {

5234

fp->fPatIdx = opValue; // JMP

5235

} else {

5236

fp = (REStackFrame *)fStack->popFrame(fFrameSize); // FAIL, no progress in loop.

5237

}

5238

}

5239

break;

5240

5241

case URX_LA_START:

5242

{

5243

// Entering a look around block.

5244

// Save Stack Ptr, Input Pos.

5245

U_ASSERT(opValue>=0 && opValue+3<fPattern->fDataSize)(void)0;

5246

fData[opValue] = fStack->size();

5247

fData[opValue+1] = fp->fInputIdx;

5248

fData[opValue+2] = fActiveStart;

5249

fData[opValue+3] = fActiveLimit;

5250

fActiveStart = fLookStart; // Set the match region change for

5251

fActiveLimit = fLookLimit; // transparent bounds.

5252

}

5253

break;

5254

5255

case URX_LA_END:

5256

{

5257

// Leaving a look around block.

5258

// restore Stack Ptr, Input Pos to positions they had on entry to block.

5259

U_ASSERT(opValue>=0 && opValue+3<fPattern->fDataSize)(void)0;

5260

int32_t stackSize = fStack->size();

5261

int32_t newStackSize = (int32_t)fData[opValue];

5262

U_ASSERT(stackSize >= newStackSize)(void)0;

5263

if (stackSize > newStackSize) {

5264

// Copy the current top frame back to the new (cut back) top frame.

5265

// This makes the capture groups from within the look-ahead

5266

// expression available.

5267

int64_t *newFP = fStack->getBuffer() + newStackSize - fFrameSize;

5268

int32_t j;

5269

for (j=0; j<fFrameSize; j++) {

5270

newFP[j] = ((int64_t *)fp)[j];

5271

}

5272

fp = (REStackFrame *)newFP;

5273

fStack->setSize(newStackSize);

5274

}

5275

fp->fInputIdx = fData[opValue+1];

5276

5277

// Restore the active region bounds in the input string; they may have

5278

// been changed because of transparent bounds on a Region.

5279

fActiveStart = fData[opValue+2];

5280

fActiveLimit = fData[opValue+3];

5281

U_ASSERT(fActiveStart >= 0)(void)0;

5282

U_ASSERT(fActiveLimit <= fInputLength)(void)0;

5283

}

5284

break;

5285

5286

case URX_ONECHAR_I:

5287

if (fp->fInputIdx < fActiveLimit) {

5288

UChar32 c;

5289

U16_NEXT(inputBuf, fp->fInputIdx, fActiveLimit, c)do { (c)=(inputBuf)[(fp->fInputIdx)++]; if((((c)&0xfffffc00
)==0xd800)) { uint16_t __c2; if((fp->fInputIdx)!=(fActiveLimit
) && (((__c2=(inputBuf)[(fp->fInputIdx)])&0xfffffc00
)==0xdc00)) { ++(fp->fInputIdx); (c)=(((UChar32)((c))<<
10UL)+(UChar32)(__c2)-((0xd800<<10UL)+0xdc00-0x10000));
} } } while (false);

5290

if (u_foldCaseu_foldCase_71(c, U_FOLD_CASE_DEFAULT0) == opValue) {

5291

break;

5292

}

5293

} else {

5294

fHitEnd = TRUE1;

5295

}

5296

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

5297

break;

5298

5299

case URX_STRING_I:

5300

// Case-insensitive test input against a literal string.

5301

// Strings require two slots in the compiled pattern, one for the

5302

// offset to the string text, and one for the length.

5303

// The compiled string has already been case folded.

5304

{

5305

const UChar *patternString = litText + opValue;

5306

5307

op = (int32_t)pat[fp->fPatIdx];

5308

fp->fPatIdx++;

5309

opType = URX_TYPE(op)((uint32_t)(op) >> 24);

5310

opValue = URX_VAL(op)((op) & 0xffffff);

5311

U_ASSERT(opType == URX_STRING_LEN)(void)0;

5312

int32_t patternStringLen = opValue; // Length of the string from the pattern.

5313

5314

UChar32 cText;

5315

UChar32 cPattern;

5316

UBool success = TRUE1;

5317

int32_t patternStringIdx = 0;

5318

CaseFoldingUCharIterator inputIterator(inputBuf, fp->fInputIdx, fActiveLimit);

5319

while (patternStringIdx < patternStringLen) {

5320

U16_NEXT(patternString, patternStringIdx, patternStringLen, cPattern)do { (cPattern)=(patternString)[(patternStringIdx)++]; if((((
cPattern)&0xfffffc00)==0xd800)) { uint16_t __c2; if((patternStringIdx
)!=(patternStringLen) && (((__c2=(patternString)[(patternStringIdx
)])&0xfffffc00)==0xdc00)) { ++(patternStringIdx); (cPattern
)=(((UChar32)((cPattern))<<10UL)+(UChar32)(__c2)-((0xd800
<<10UL)+0xdc00-0x10000)); } } } while (false);

5321

cText = inputIterator.next();

5322

if (cText != cPattern) {

5323

success = FALSE0;

5324

if (cText == U_SENTINEL(-1)) {

5325

fHitEnd = TRUE1;

5326

}

5327

break;

5328

}

5329

}

5330

if (inputIterator.inExpansion()) {

5331

success = FALSE0;

5332

}

5333

5334

if (success) {

5335

fp->fInputIdx = inputIterator.getIndex();

5336

} else {

5337

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

5338

}

5339

}

5340

break;

5341

5342

case URX_LB_START:

5343

{

5344

// Entering a look-behind block.

5345

// Save Stack Ptr, Input Pos and active input region.

5346

// TODO: implement transparent bounds. Ticket #6067

5347

U_ASSERT(opValue>=0 && opValue+4<fPattern->fDataSize)(void)0;

5348

fData[opValue] = fStack->size();

5349

fData[opValue+1] = fp->fInputIdx;

5350

// Save input string length, then reset to pin any matches to end at

5351

// the current position.

5352

fData[opValue+2] = fActiveStart;

5353

fData[opValue+3] = fActiveLimit;

5354

fActiveStart = fRegionStart;

5355

fActiveLimit = fp->fInputIdx;

5356

// Init the variable containing the start index for attempted matches.

5357

fData[opValue+4] = -1;

5358

}

5359

break;

5360

5361

5362

case URX_LB_CONT:

5363

{

5364

// Positive Look-Behind, at top of loop checking for matches of LB expression

5365

// at all possible input starting positions.

5366

5367

// Fetch the min and max possible match lengths. They are the operands

5368

// of this op in the pattern.

5369

int32_t minML = (int32_t)pat[fp->fPatIdx++];

5370

int32_t maxML = (int32_t)pat[fp->fPatIdx++];

5371

U_ASSERT(minML <= maxML)(void)0;

5372

U_ASSERT(minML >= 0)(void)0;

5373

5374

// Fetch (from data) the last input index where a match was attempted.

5375

U_ASSERT(opValue>=0 && opValue+4<fPattern->fDataSize)(void)0;

5376

int64_t &lbStartIdx = fData[opValue+4];

5377

if (lbStartIdx < 0) {

5378

// First time through loop.

5379

lbStartIdx = fp->fInputIdx - minML;

5380

if (lbStartIdx > 0 && lbStartIdx < fInputLength) {

5381

U16_SET_CP_START(inputBuf, 0, lbStartIdx)do { if(((((inputBuf)[lbStartIdx])&0xfffffc00)==0xdc00) &&
(lbStartIdx)>(0) && ((((inputBuf)[(lbStartIdx)-1]
)&0xfffffc00)==0xd800)) { --(lbStartIdx); } } while (false
);

5382

}

5383

} else {

5384

// 2nd through nth time through the loop.

5385

// Back up start position for match by one.

5386

if (lbStartIdx == 0) {

5387

lbStartIdx--;

5388

} else {

5389

U16_BACK_1(inputBuf, 0, lbStartIdx)do { if(((((inputBuf)[--(lbStartIdx)])&0xfffffc00)==0xdc00
) && (lbStartIdx)>(0) && ((((inputBuf)[(lbStartIdx
)-1])&0xfffffc00)==0xd800)) { --(lbStartIdx); } } while (
false);

5390

}

5391

}

5392

5393

if (lbStartIdx < 0 || lbStartIdx < fp->fInputIdx - maxML) {

5394

// We have tried all potential match starting points without

5395

// getting a match. Backtrack out, and out of the

5396

// Look Behind altogether.

5397

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

5398

fActiveStart = fData[opValue+2];

5399

fActiveLimit = fData[opValue+3];

5400

U_ASSERT(fActiveStart >= 0)(void)0;

5401

U_ASSERT(fActiveLimit <= fInputLength)(void)0;

5402

break;

5403

}

5404

5405

// Save state to this URX_LB_CONT op, so failure to match will repeat the loop.

5406

// (successful match will fall off the end of the loop.)

5407

fp = StateSave(fp, fp->fPatIdx-3, status);

5408

fp->fInputIdx = lbStartIdx;

5409

}

5410

break;

5411

5412

case URX_LB_END:

5413

// End of a look-behind block, after a successful match.

5414

{

5415

U_ASSERT(opValue>=0 && opValue+4<fPattern->fDataSize)(void)0;

5416

if (fp->fInputIdx != fActiveLimit) {

5417

// The look-behind expression matched, but the match did not

5418

// extend all the way to the point that we are looking behind from.

5419

// FAIL out of here, which will take us back to the LB_CONT, which

5420

// will retry the match starting at another position or fail

5421

// the look-behind altogether, whichever is appropriate.

5422

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

5423

break;

5424

}

5425

5426

// Look-behind match is good. Restore the original input string region,

5427

// which had been truncated to pin the end of the lookbehind match to the

5428

// position being looked-behind.

5429

fActiveStart = fData[opValue+2];

5430

fActiveLimit = fData[opValue+3];

5431

U_ASSERT(fActiveStart >= 0)(void)0;

5432

U_ASSERT(fActiveLimit <= fInputLength)(void)0;

5433

}

5434

break;

5435

5436

5437

case URX_LBN_CONT:

5438

{

5439

// Negative Look-Behind, at top of loop checking for matches of LB expression

5440

// at all possible input starting positions.

5441

5442

// Fetch the extra parameters of this op.

5443

int32_t minML = (int32_t)pat[fp->fPatIdx++];

5444

int32_t maxML = (int32_t)pat[fp->fPatIdx++];

5445

int32_t continueLoc = (int32_t)pat[fp->fPatIdx++];

5446

continueLoc = URX_VAL(continueLoc)((continueLoc) & 0xffffff);

5447

U_ASSERT(minML <= maxML)(void)0;

5448

U_ASSERT(minML >= 0)(void)0;

5449

U_ASSERT(continueLoc > fp->fPatIdx)(void)0;

5450

5451

// Fetch (from data) the last input index where a match was attempted.

5452

U_ASSERT(opValue>=0 && opValue+4<fPattern->fDataSize)(void)0;

5453

int64_t &lbStartIdx = fData[opValue+4];

5454

if (lbStartIdx < 0) {

5455

// First time through loop.

5456

lbStartIdx = fp->fInputIdx - minML;

5457

if (lbStartIdx > 0 && lbStartIdx < fInputLength) {

5458

U16_SET_CP_START(inputBuf, 0, lbStartIdx)do { if(((((inputBuf)[lbStartIdx])&0xfffffc00)==0xdc00) &&
(lbStartIdx)>(0) && ((((inputBuf)[(lbStartIdx)-1]
)&0xfffffc00)==0xd800)) { --(lbStartIdx); } } while (false
);

5459

}

5460

} else {

5461

// 2nd through nth time through the loop.

5462

// Back up start position for match by one.

5463

if (lbStartIdx == 0) {

5464

lbStartIdx--; // Because U16_BACK is unsafe starting at 0.

5465

} else {

5466

U16_BACK_1(inputBuf, 0, lbStartIdx)do { if(((((inputBuf)[--(lbStartIdx)])&0xfffffc00)==0xdc00
) && (lbStartIdx)>(0) && ((((inputBuf)[(lbStartIdx
)-1])&0xfffffc00)==0xd800)) { --(lbStartIdx); } } while (
false);

5467

}

5468

}

5469

5470

if (lbStartIdx < 0 || lbStartIdx < fp->fInputIdx - maxML) {

5471

// We have tried all potential match starting points without

5472

// getting a match, which means that the negative lookbehind as

5473

// a whole has succeeded. Jump forward to the continue location

5474

fActiveStart = fData[opValue+2];

5475

fActiveLimit = fData[opValue+3];

5476

U_ASSERT(fActiveStart >= 0)(void)0;

5477

U_ASSERT(fActiveLimit <= fInputLength)(void)0;

5478

fp->fPatIdx = continueLoc;

5479

break;

5480

}

5481

5482

// Save state to this URX_LB_CONT op, so failure to match will repeat the loop.

5483

// (successful match will cause a FAIL out of the loop altogether.)

5484

fp = StateSave(fp, fp->fPatIdx-4, status);

5485

fp->fInputIdx = lbStartIdx;

5486

}

5487

break;

5488

5489

case URX_LBN_END:

5490

// End of a negative look-behind block, after a successful match.

5491

{

5492

U_ASSERT(opValue>=0 && opValue+4<fPattern->fDataSize)(void)0;

5493

if (fp->fInputIdx != fActiveLimit) {

5494

// The look-behind expression matched, but the match did not

5495

// extend all the way to the point that we are looking behind from.

5496

// FAIL out of here, which will take us back to the LB_CONT, which

5497

// will retry the match starting at another position or succeed

5498

// the look-behind altogether, whichever is appropriate.

5499

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

5500

break;

5501

}

5502

5503

// Look-behind expression matched, which means look-behind test as

5504

// a whole Fails

5505

5506

// Restore the original input string length, which had been truncated

5507

// inorder to pin the end of the lookbehind match

5508

// to the position being looked-behind.

5509

fActiveStart = fData[opValue+2];

5510

fActiveLimit = fData[opValue+3];

5511

U_ASSERT(fActiveStart >= 0)(void)0;

5512

U_ASSERT(fActiveLimit <= fInputLength)(void)0;

5513

5514

// Restore original stack position, discarding any state saved

5515

// by the successful pattern match.

5516

U_ASSERT(opValue>=0 && opValue+1<fPattern->fDataSize)(void)0;

5517

int32_t newStackSize = (int32_t)fData[opValue];

5518

U_ASSERT(fStack->size() > newStackSize)(void)0;

5519

fStack->setSize(newStackSize);

5520

5521

// FAIL, which will take control back to someplace

5522

// prior to entering the look-behind test.

5523

fp = (REStackFrame *)fStack->popFrame(fFrameSize);

5524

}

5525

break;

5526

5527

5528

case URX_LOOP_SR_I:

5529

// Loop Initialization for the optimized implementation of

5530

// [some character set]*

5531

// This op scans through all matching input.

5532

// The following LOOP_C op emulates stack unwinding if the following pattern fails.

5533

{

5534

U_ASSERT(opValue > 0 && opValue < fSets->size())(void)0;

5535

Regex8BitSet *s8 = &fPattern->fSets8[opValue];

5536

UnicodeSet *s = (UnicodeSet *)fSets->elementAt(opValue);

5537

5538

// Loop through input, until either the input is exhausted or

5539

// we reach a character that is not a member of the set.

5540

int32_t ix = (int32_t)fp->fInputIdx;

5541

for (;;) {

5542

if (ix >= fActiveLimit) {

5543

fHitEnd = TRUE1;

5544

break;

5545

}

5546

UChar32 c;

5547

U16_NEXT(inputBuf, ix, fActiveLimit, c)do { (c)=(inputBuf)[(ix)++]; if((((c)&0xfffffc00)==0xd800
)) { uint16_t __c2; if((ix)!=(fActiveLimit) && (((__c2
=(inputBuf)[(ix)])&0xfffffc00)==0xdc00)) { ++(ix); (c)=((
(UChar32)((c))<<10UL)+(UChar32)(__c2)-((0xd800<<10UL
)+0xdc00-0x10000)); } } } while (false);

5548

if (c<256) {

5549

if (s8->contains(c) == FALSE0) {

5550

U16_BACK_1(inputBuf, 0, ix)do { if(((((inputBuf)[--(ix)])&0xfffffc00)==0xdc00) &&
(ix)>(0) && ((((inputBuf)[(ix)-1])&0xfffffc00
)==0xd800)) { --(ix); } } while (false);

5551

break;

5552

}

5553

} else {

5554

if (s->contains(c) == FALSE0) {

5555

U16_BACK_1(inputBuf, 0, ix)do { if(((((inputBuf)[--(ix)])&0xfffffc00)==0xdc00) &&
(ix)>(0) && ((((inputBuf)[(ix)-1])&0xfffffc00
)==0xd800)) { --(ix); } } while (false);

5556

break;

5557

}

5558

}

5559

}

5560

5561

// If there were no matching characters, skip over the loop altogether.

5562

// The loop doesn't run at all, a * op always succeeds.

5563

if (ix == fp->fInputIdx) {

5564

fp->fPatIdx++; // skip the URX_LOOP_C op.

5565

break;

5566

}

5567

5568

// Peek ahead in the compiled pattern, to the URX_LOOP_C that

5569

// must follow. It's operand is the stack location

5570

// that holds the starting input index for the match of this [set]*

5571

int32_t loopcOp = (int32_t)pat[fp->fPatIdx];

5572

U_ASSERT(URX_TYPE(loopcOp) == URX_LOOP_C)(void)0;

5573

int32_t stackLoc = URX_VAL(loopcOp)((loopcOp) & 0xffffff);

5574

U_ASSERT(stackLoc >= 0 && stackLoc < fFrameSize)(void)0;

5575

fp->fExtra[stackLoc] = fp->fInputIdx;

5576

fp->fInputIdx = ix;

5577

5578

// Save State to the URX_LOOP_C op that follows this one,

5579

// so that match failures in the following code will return to there.

5580

// Then bump the pattern idx so the LOOP_C is skipped on the way out of here.

5581

fp = StateSave(fp, fp->fPatIdx, status);

5582

fp->fPatIdx++;

5583

}

5584

break;

5585

5586

5587

case URX_LOOP_DOT_I:

5588

// Loop Initialization for the optimized implementation of .*

5589

// This op scans through all remaining input.

5590

// The following LOOP_C op emulates stack unwinding if the following pattern fails.

5591

{

5592

// Loop through input until the input is exhausted (we reach an end-of-line)

5593

// In DOTALL mode, we can just go straight to the end of the input.

5594

int32_t ix;

5595

if ((opValue & 1) == 1) {

5596

// Dot-matches-All mode. Jump straight to the end of the string.

5597

ix = (int32_t)fActiveLimit;

5598

fHitEnd = TRUE1;

5599

} else {

5600

// NOT DOT ALL mode. Line endings do not match '.'

5601

// Scan forward until a line ending or end of input.

5602

ix = (int32_t)fp->fInputIdx;

5603

for (;;) {

5604

if (ix >= fActiveLimit) {

5605

fHitEnd = TRUE1;

5606

break;

5607

}

5608

UChar32 c;

5609

U16_NEXT(inputBuf, ix, fActiveLimit, c)do { (c)=(inputBuf)[(ix)++]; if((((c)&0xfffffc00)==0xd800
)) { uint16_t __c2; if((ix)!=(fActiveLimit) && (((__c2
=(inputBuf)[(ix)])&0xfffffc00)==0xdc00)) { ++(ix); (c)=((
(UChar32)((c))<<10UL)+(UChar32)(__c2)-((0xd800<<10UL
)+0xdc00-0x10000)); } } } while (false); // c = inputBuf[ix++]

5610

if ((c & 0x7f) <= 0x29) { // Fast filter of non-new-line-s

5611

if ((c == 0x0a) || // 0x0a is newline in both modes.

5612

(((opValue & 2) == 0) && // IF not UNIX_LINES mode

5613

isLineTerminator(c))) {

5614

// char is a line ending. Put the input pos back to the

5615

// line ending char, and exit the scanning loop.

5616

U16_BACK_1(inputBuf, 0, ix)do { if(((((inputBuf)[--(ix)])&0xfffffc00)==0xdc00) &&
(ix)>(0) && ((((inputBuf)[(ix)-1])&0xfffffc00
)==0xd800)) { --(ix); } } while (false);

5617

break;

5618

}

5619

}

5620

}

5621

}

5622

5623

// If there were no matching characters, skip over the loop altogether.

5624

// The loop doesn't run at all, a * op always succeeds.

5625

if (ix == fp->fInputIdx) {

5626

fp->fPatIdx++; // skip the URX_LOOP_C op.

5627

break;

5628

}

5629

5630

// Peek ahead in the compiled pattern, to the URX_LOOP_C that

5631

// must follow. It's operand is the stack location

5632

// that holds the starting input index for the match of this .*

5633

int32_t loopcOp = (int32_t)pat[fp->fPatIdx];

5634

U_ASSERT(URX_TYPE(loopcOp) == URX_LOOP_C)(void)0;

5635

int32_t stackLoc = URX_VAL(loopcOp)((loopcOp) & 0xffffff);

5636

U_ASSERT(stackLoc >= 0 && stackLoc < fFrameSize)(void)0;

5637

fp->fExtra[stackLoc] = fp->fInputIdx;

5638

fp->fInputIdx = ix;

5639

5640

// Save State to the URX_LOOP_C op that follows this one,

5641

// so that match failures in the following code will return to there.

5642

// Then bump the pattern idx so the LOOP_C is skipped on the way out of here.

5643

fp = StateSave(fp, fp->fPatIdx, status);

5644

fp->fPatIdx++;

5645

}

5646

break;

5647

5648

5649

case URX_LOOP_C:

5650

{

5651

U_ASSERT(opValue>=0 && opValue<fFrameSize)(void)0;

5652

backSearchIndex = (int32_t)fp->fExtra[opValue];

5653

U_ASSERT(backSearchIndex <= fp->fInputIdx)(void)0;

5654

if (backSearchIndex == fp->fInputIdx) {

5655

// We've backed up the input idx to the point that the loop started.

5656

// The loop is done. Leave here without saving state.

5657

// Subsequent failures won't come back here.

5658

break;

5659

}

5660

// Set up for the next iteration of the loop, with input index

5661

// backed up by one from the last time through,

5662

// and a state save to this instruction in case the following code fails again.

5663

// (We're going backwards because this loop emulates stack unwinding, not

5664

// the initial scan forward.)

5665

U_ASSERT(fp->fInputIdx > 0)(void)0;

5666

UChar32 prevC;

5667

U16_PREV(inputBuf, 0, fp->fInputIdx, prevC)do { (prevC)=(inputBuf)[--(fp->fInputIdx)]; if((((prevC)&
0xfffffc00)==0xdc00)) { uint16_t __c2; if((fp->fInputIdx)>
(0) && (((__c2=(inputBuf)[(fp->fInputIdx)-1])&
0xfffffc00)==0xd800)) { --(fp->fInputIdx); (prevC)=(((UChar32
)(__c2)<<10UL)+(UChar32)((prevC))-((0xd800<<10UL)
+0xdc00-0x10000)); } } } while (false); // !!!: should this 0 be one of f*Limit?

5668

5669

if (prevC == 0x0a &&

5670

fp->fInputIdx > backSearchIndex &&

5671

inputBuf[fp->fInputIdx-1] == 0x0d) {

5672

int32_t prevOp = (int32_t)pat[fp->fPatIdx-2];

5673

if (URX_TYPE(prevOp)((uint32_t)(prevOp) >> 24) == URX_LOOP_DOT_I) {

5674

// .*, stepping back over CRLF pair.

5675

U16_BACK_1(inputBuf, 0, fp->fInputIdx)do { if(((((inputBuf)[--(fp->fInputIdx)])&0xfffffc00)==
0xdc00) && (fp->fInputIdx)>(0) && ((((inputBuf
)[(fp->fInputIdx)-1])&0xfffffc00)==0xd800)) { --(fp->
fInputIdx); } } while (false);

5676

}

5677

}

5678

5679

5680

fp = StateSave(fp, fp->fPatIdx-1, status);

5681

}

5682

break;

5683

5684

5685

5686

default:

5687

// Trouble. The compiled pattern contains an entry with an

5688

// unrecognized type tag.

5689

UPRV_UNREACHABLE_ASSERT(void)0;

5690

// Unknown opcode type in opType = URX_TYPE(pat[fp->fPatIdx]). But we have

5691

// reports of this in production code, don't use UPRV_UNREACHABLE_EXIT.

5692

// See ICU-21669.

5693

status = U_INTERNAL_PROGRAM_ERROR;

5694

}

5695

5696

if (U_FAILURE(status)) {

5697

isMatch = FALSE0;

5698

break;

5699

}

5700

}

5701

5702

breakFromLoop:

5703

fMatch = isMatch;

5704

if (isMatch) {

5705

fLastMatchEnd = fMatchEnd;

5706

fMatchStart = startIdx;

5707

fMatchEnd = fp->fInputIdx;

5708

}

5709

5710

#ifdef REGEX_RUN_DEBUG

5711

if (fTraceDebug) {

5712

if (isMatch) {

5713

printf("Match. start=%ld end=%ld\n\n", fMatchStart, fMatchEnd);

5714

} else {

5715

printf("No match\n\n");

5716

}

5717

}

5718

#endif

5719

5720

fFrame = fp; // The active stack frame when the engine stopped.

5721

// Contains the capture group results that we need to

5722

// access later.

5723

5724

return;

5725

}

5726

5727

5728

UOBJECT_DEFINE_RTTI_IMPLEMENTATION(RegexMatcher)UClassID RegexMatcher::getStaticClassID() { static char classID
= 0; return (UClassID)&classID; } UClassID RegexMatcher::
getDynamicClassID() const { return RegexMatcher::getStaticClassID
(); }

5729

5730

U_NAMESPACE_END}

5731

5732

#endif // !UCONFIG_NO_REGULAR_EXPRESSIONS

5733

File:	out/../deps/icu-small/source/i18n/rematch.cpp
Warning:	line 4400, column 17 Value stored to 'opType' is never read

Bug Summary

Annotated Source Code