1*ccdc9c3eSSadaf EbrahimiThis is a dump from Google's source control system of the change 2*ccdc9c3eSSadaf Ebrahimithat removed UCS-2 support from RE2. As the explanation below 3*ccdc9c3eSSadaf Ebrahimisays, UCS-2 mode is fundamentally at odds with things like ^ and $, 4*ccdc9c3eSSadaf Ebrahimiso it never really worked very well. But if you are interested in using 5*ccdc9c3eSSadaf Ebrahimiit without those operators, it did work for that. It assumed that the 6*ccdc9c3eSSadaf EbrahimiUCS-2 data was in the native host byte order. 7*ccdc9c3eSSadaf Ebrahimi 8*ccdc9c3eSSadaf EbrahimiIf you are interested in adding UCS-2 mode back, this patch might 9*ccdc9c3eSSadaf Ebrahimibe a good starting point. 10*ccdc9c3eSSadaf Ebrahimi 11*ccdc9c3eSSadaf Ebrahimi 12*ccdc9c3eSSadaf EbrahimiChange 12780686 by rsc@rsc-re2 on 2009/09/16 15:30:15 13*ccdc9c3eSSadaf Ebrahimi 14*ccdc9c3eSSadaf Ebrahimi Retire UCS-2 mode. 15*ccdc9c3eSSadaf Ebrahimi 16*ccdc9c3eSSadaf Ebrahimi I added it as an experiment for V8, but it 17*ccdc9c3eSSadaf Ebrahimi requires 2-byte lookahead to do completely, 18*ccdc9c3eSSadaf Ebrahimi and RE2 has 1-byte lookahead (enough for UTF-8) 19*ccdc9c3eSSadaf Ebrahimi as a fairly deep fundamental assumption, 20*ccdc9c3eSSadaf Ebrahimi so it did not support ^ or $. 21*ccdc9c3eSSadaf Ebrahimi 22*ccdc9c3eSSadaf Ebrahimi==== re2/bitstate.cc#2 - re2/bitstate.cc#3 ==== 23*ccdc9c3eSSadaf Ebrahimire2/bitstate.cc#2:314,321 - re2/bitstate.cc#3:314,319 24*ccdc9c3eSSadaf Ebrahimi cap_[0] = p; 25*ccdc9c3eSSadaf Ebrahimi if (TrySearch(prog_->start(), p)) // Match must be leftmost; done. 26*ccdc9c3eSSadaf Ebrahimi return true; 27*ccdc9c3eSSadaf Ebrahimi- if (prog_->flags() & Regexp::UCS2) 28*ccdc9c3eSSadaf Ebrahimi- p++; 29*ccdc9c3eSSadaf Ebrahimi } 30*ccdc9c3eSSadaf Ebrahimi return false; 31*ccdc9c3eSSadaf Ebrahimi } 32*ccdc9c3eSSadaf Ebrahimi==== re2/compile.cc#17 - re2/compile.cc#18 ==== 33*ccdc9c3eSSadaf Ebrahimire2/compile.cc#17:95,101 - re2/compile.cc#18:95,100 34*ccdc9c3eSSadaf Ebrahimi // Input encodings. 35*ccdc9c3eSSadaf Ebrahimi enum Encoding { 36*ccdc9c3eSSadaf Ebrahimi kEncodingUTF8 = 1, // UTF-8 (0-10FFFF) 37*ccdc9c3eSSadaf Ebrahimi- kEncodingUCS2, // UCS-2 (0-FFFF), native byte order 38*ccdc9c3eSSadaf Ebrahimi kEncodingLatin1, // Latin1 (0-FF) 39*ccdc9c3eSSadaf Ebrahimi }; 40*ccdc9c3eSSadaf Ebrahimi 41*ccdc9c3eSSadaf Ebrahimire2/compile.cc#17:168,176 - re2/compile.cc#18:167,172 42*ccdc9c3eSSadaf Ebrahimi void AddRuneRangeLatin1(Rune lo, Rune hi, bool foldcase); 43*ccdc9c3eSSadaf Ebrahimi void AddRuneRangeUTF8(Rune lo, Rune hi, bool foldcase); 44*ccdc9c3eSSadaf Ebrahimi void Add_80_10ffff(); 45*ccdc9c3eSSadaf Ebrahimi- void AddRuneRangeUCS2(Rune lo, Rune hi, bool foldcase); 46*ccdc9c3eSSadaf Ebrahimi- void AddUCS2Pair(uint8 lo1, uint8 hi1, bool fold1, 47*ccdc9c3eSSadaf Ebrahimi- uint8 lo2, uint8 hi2, bool fold2); 48*ccdc9c3eSSadaf Ebrahimi 49*ccdc9c3eSSadaf Ebrahimi // New suffix that matches the byte range lo-hi, then goes to next. 50*ccdc9c3eSSadaf Ebrahimi Inst* RuneByteSuffix(uint8 lo, uint8 hi, bool foldcase, Inst* next); 51*ccdc9c3eSSadaf Ebrahimire2/compile.cc#17:475,481 - re2/compile.cc#18:471,477 52*ccdc9c3eSSadaf Ebrahimi 53*ccdc9c3eSSadaf Ebrahimi // Converts rune range lo-hi into a fragment that recognizes 54*ccdc9c3eSSadaf Ebrahimi // the bytes that would make up those runes in the current 55*ccdc9c3eSSadaf Ebrahimi- // encoding (Latin 1, UTF-8, or UCS-2). 56*ccdc9c3eSSadaf Ebrahimi+ // encoding (Latin 1 or UTF-8). 57*ccdc9c3eSSadaf Ebrahimi // This lets the machine work byte-by-byte even when 58*ccdc9c3eSSadaf Ebrahimi // using multibyte encodings. 59*ccdc9c3eSSadaf Ebrahimi 60*ccdc9c3eSSadaf Ebrahimire2/compile.cc#17:488,496 - re2/compile.cc#18:484,489 61*ccdc9c3eSSadaf Ebrahimi case kEncodingLatin1: 62*ccdc9c3eSSadaf Ebrahimi AddRuneRangeLatin1(lo, hi, foldcase); 63*ccdc9c3eSSadaf Ebrahimi break; 64*ccdc9c3eSSadaf Ebrahimi- case kEncodingUCS2: 65*ccdc9c3eSSadaf Ebrahimi- AddRuneRangeUCS2(lo, hi, foldcase); 66*ccdc9c3eSSadaf Ebrahimi- break; 67*ccdc9c3eSSadaf Ebrahimi } 68*ccdc9c3eSSadaf Ebrahimi } 69*ccdc9c3eSSadaf Ebrahimi 70*ccdc9c3eSSadaf Ebrahimire2/compile.cc#17:503,581 - re2/compile.cc#18:496,501 71*ccdc9c3eSSadaf Ebrahimi AddSuffix(RuneByteSuffix(lo, hi, foldcase, NULL)); 72*ccdc9c3eSSadaf Ebrahimi } 73*ccdc9c3eSSadaf Ebrahimi 74*ccdc9c3eSSadaf Ebrahimi- // Test whether 16-bit values are big or little endian. 75*ccdc9c3eSSadaf Ebrahimi- static bool BigEndian() { 76*ccdc9c3eSSadaf Ebrahimi- union { 77*ccdc9c3eSSadaf Ebrahimi- char byte[2]; 78*ccdc9c3eSSadaf Ebrahimi- int16 endian; 79*ccdc9c3eSSadaf Ebrahimi- } u; 80*ccdc9c3eSSadaf Ebrahimi- 81*ccdc9c3eSSadaf Ebrahimi- u.byte[0] = 1; 82*ccdc9c3eSSadaf Ebrahimi- u.byte[1] = 2; 83*ccdc9c3eSSadaf Ebrahimi- return u.endian == 0x0102; 84*ccdc9c3eSSadaf Ebrahimi- } 85*ccdc9c3eSSadaf Ebrahimi- 86*ccdc9c3eSSadaf Ebrahimi- void Compiler::AddUCS2Pair(uint8 lo1, uint8 hi1, bool fold1, 87*ccdc9c3eSSadaf Ebrahimi- uint8 lo2, uint8 hi2, bool fold2) { 88*ccdc9c3eSSadaf Ebrahimi- Inst* ip; 89*ccdc9c3eSSadaf Ebrahimi- if (reversed_) { 90*ccdc9c3eSSadaf Ebrahimi- ip = RuneByteSuffix(lo1, hi1, fold1, NULL); 91*ccdc9c3eSSadaf Ebrahimi- ip = RuneByteSuffix(lo2, hi2, fold2, ip); 92*ccdc9c3eSSadaf Ebrahimi- } else { 93*ccdc9c3eSSadaf Ebrahimi- ip = RuneByteSuffix(lo2, hi2, fold2, NULL); 94*ccdc9c3eSSadaf Ebrahimi- ip = RuneByteSuffix(lo1, hi1, fold1, ip); 95*ccdc9c3eSSadaf Ebrahimi- } 96*ccdc9c3eSSadaf Ebrahimi- AddSuffix(ip); 97*ccdc9c3eSSadaf Ebrahimi- } 98*ccdc9c3eSSadaf Ebrahimi- 99*ccdc9c3eSSadaf Ebrahimi- void Compiler::AddRuneRangeUCS2(Rune lo, Rune hi, bool foldcase) { 100*ccdc9c3eSSadaf Ebrahimi- if (lo > hi || lo > 0xFFFF) 101*ccdc9c3eSSadaf Ebrahimi- return; 102*ccdc9c3eSSadaf Ebrahimi- if (hi > 0xFFFF) 103*ccdc9c3eSSadaf Ebrahimi- hi = 0xFFFF; 104*ccdc9c3eSSadaf Ebrahimi- 105*ccdc9c3eSSadaf Ebrahimi- // We'll assemble a pattern assuming big endian. 106*ccdc9c3eSSadaf Ebrahimi- // If the machine isn't, tell Cat to reverse its arguments. 107*ccdc9c3eSSadaf Ebrahimi- bool oldreversed = reversed_; 108*ccdc9c3eSSadaf Ebrahimi- if (!BigEndian()) { 109*ccdc9c3eSSadaf Ebrahimi- reversed_ = !oldreversed; 110*ccdc9c3eSSadaf Ebrahimi- } 111*ccdc9c3eSSadaf Ebrahimi- 112*ccdc9c3eSSadaf Ebrahimi- // Split into bytes. 113*ccdc9c3eSSadaf Ebrahimi- int lo1 = lo >> 8; 114*ccdc9c3eSSadaf Ebrahimi- int lo2 = lo & 0xFF; 115*ccdc9c3eSSadaf Ebrahimi- int hi1 = hi >> 8; 116*ccdc9c3eSSadaf Ebrahimi- int hi2 = hi & 0xFF; 117*ccdc9c3eSSadaf Ebrahimi- 118*ccdc9c3eSSadaf Ebrahimi- if (lo1 == hi1) { 119*ccdc9c3eSSadaf Ebrahimi- // Easy case: high bits are same in both. 120*ccdc9c3eSSadaf Ebrahimi- // Only do ASCII case folding on the second byte if the top byte is 00. 121*ccdc9c3eSSadaf Ebrahimi- AddUCS2Pair(lo1, lo1, false, lo2, hi2, lo1==0 && foldcase); 122*ccdc9c3eSSadaf Ebrahimi- } else { 123*ccdc9c3eSSadaf Ebrahimi- // Harder case: different second byte ranges depending on first byte. 124*ccdc9c3eSSadaf Ebrahimi- 125*ccdc9c3eSSadaf Ebrahimi- // Initial fragment. 126*ccdc9c3eSSadaf Ebrahimi- if (lo2 > 0) { 127*ccdc9c3eSSadaf Ebrahimi- AddUCS2Pair(lo1, lo1, false, lo2, 0xFF, lo1==0 && foldcase); 128*ccdc9c3eSSadaf Ebrahimi- lo1++; 129*ccdc9c3eSSadaf Ebrahimi- } 130*ccdc9c3eSSadaf Ebrahimi- 131*ccdc9c3eSSadaf Ebrahimi- // Trailing fragment. 132*ccdc9c3eSSadaf Ebrahimi- if (hi2 < 0xFF) { 133*ccdc9c3eSSadaf Ebrahimi- AddUCS2Pair(hi1, hi1, false, 0, hi2, false); 134*ccdc9c3eSSadaf Ebrahimi- hi1--; 135*ccdc9c3eSSadaf Ebrahimi- } 136*ccdc9c3eSSadaf Ebrahimi- 137*ccdc9c3eSSadaf Ebrahimi- // Inner ranges. 138*ccdc9c3eSSadaf Ebrahimi- if (lo1 <= hi1) { 139*ccdc9c3eSSadaf Ebrahimi- AddUCS2Pair(lo1, hi1, false, 0, 0xFF, false); 140*ccdc9c3eSSadaf Ebrahimi- } 141*ccdc9c3eSSadaf Ebrahimi- } 142*ccdc9c3eSSadaf Ebrahimi- 143*ccdc9c3eSSadaf Ebrahimi- // Restore reverse setting. 144*ccdc9c3eSSadaf Ebrahimi- reversed_ = oldreversed; 145*ccdc9c3eSSadaf Ebrahimi- } 146*ccdc9c3eSSadaf Ebrahimi- 147*ccdc9c3eSSadaf Ebrahimi // Table describing how to make a UTF-8 matching machine 148*ccdc9c3eSSadaf Ebrahimi // for the rune range 80-10FFFF (Runeself-Runemax). 149*ccdc9c3eSSadaf Ebrahimi // This range happens frequently enough (for example /./ and /[^a-z]/) 150*ccdc9c3eSSadaf Ebrahimire2/compile.cc#17:707,716 - re2/compile.cc#18:627,634 151*ccdc9c3eSSadaf Ebrahimi 152*ccdc9c3eSSadaf Ebrahimi Frag Compiler::Literal(Rune r, bool foldcase) { 153*ccdc9c3eSSadaf Ebrahimi switch (encoding_) { 154*ccdc9c3eSSadaf Ebrahimi- default: // UCS-2 or something new 155*ccdc9c3eSSadaf Ebrahimi- BeginRange(); 156*ccdc9c3eSSadaf Ebrahimi- AddRuneRange(r, r, foldcase); 157*ccdc9c3eSSadaf Ebrahimi- return EndRange(); 158*ccdc9c3eSSadaf Ebrahimi+ default: 159*ccdc9c3eSSadaf Ebrahimi+ return kNullFrag; 160*ccdc9c3eSSadaf Ebrahimi 161*ccdc9c3eSSadaf Ebrahimi case kEncodingLatin1: 162*ccdc9c3eSSadaf Ebrahimi return ByteRange(r, r, foldcase); 163*ccdc9c3eSSadaf Ebrahimire2/compile.cc#17:927,934 - re2/compile.cc#18:845,850 164*ccdc9c3eSSadaf Ebrahimi 165*ccdc9c3eSSadaf Ebrahimi if (re->parse_flags() & Regexp::Latin1) 166*ccdc9c3eSSadaf Ebrahimi c.encoding_ = kEncodingLatin1; 167*ccdc9c3eSSadaf Ebrahimi- else if (re->parse_flags() & Regexp::UCS2) 168*ccdc9c3eSSadaf Ebrahimi- c.encoding_ = kEncodingUCS2; 169*ccdc9c3eSSadaf Ebrahimi c.reversed_ = reversed; 170*ccdc9c3eSSadaf Ebrahimi if (max_mem <= 0) { 171*ccdc9c3eSSadaf Ebrahimi c.max_inst_ = 100000; // more than enough 172*ccdc9c3eSSadaf Ebrahimire2/compile.cc#17:983,993 - re2/compile.cc#18:899,905 173*ccdc9c3eSSadaf Ebrahimi c.prog_->set_start_unanchored(c.prog_->start()); 174*ccdc9c3eSSadaf Ebrahimi } else { 175*ccdc9c3eSSadaf Ebrahimi Frag dot; 176*ccdc9c3eSSadaf Ebrahimi- if (c.encoding_ == kEncodingUCS2) { 177*ccdc9c3eSSadaf Ebrahimi- dot = c.Cat(c.ByteRange(0x00, 0xFF, false), c.ByteRange(0x00, 0xFF, false)); 178*ccdc9c3eSSadaf Ebrahimi- } else { 179*ccdc9c3eSSadaf Ebrahimi- dot = c.ByteRange(0x00, 0xFF, false); 180*ccdc9c3eSSadaf Ebrahimi- } 181*ccdc9c3eSSadaf Ebrahimi+ dot = c.ByteRange(0x00, 0xFF, false); 182*ccdc9c3eSSadaf Ebrahimi Frag dotloop = c.Star(dot, true); 183*ccdc9c3eSSadaf Ebrahimi Frag unanchored = c.Cat(dotloop, all); 184*ccdc9c3eSSadaf Ebrahimi c.prog_->set_start_unanchored(unanchored.begin); 185*ccdc9c3eSSadaf Ebrahimi==== re2/nfa.cc#8 - re2/nfa.cc#9 ==== 186*ccdc9c3eSSadaf Ebrahimire2/nfa.cc#8:426,432 - re2/nfa.cc#9:426,431 187*ccdc9c3eSSadaf Ebrahimi const char* bp = context.begin(); 188*ccdc9c3eSSadaf Ebrahimi int c = -1; 189*ccdc9c3eSSadaf Ebrahimi int wasword = 0; 190*ccdc9c3eSSadaf Ebrahimi- bool ucs2 = prog_->flags() & Regexp::UCS2; 191*ccdc9c3eSSadaf Ebrahimi 192*ccdc9c3eSSadaf Ebrahimi if (text.begin() > context.begin()) { 193*ccdc9c3eSSadaf Ebrahimi c = text.begin()[-1] & 0xFF; 194*ccdc9c3eSSadaf Ebrahimire2/nfa.cc#8:492,498 - re2/nfa.cc#9:491,497 195*ccdc9c3eSSadaf Ebrahimi // If there's a required first byte for an unanchored search 196*ccdc9c3eSSadaf Ebrahimi // and we're not in the middle of any possible matches, 197*ccdc9c3eSSadaf Ebrahimi // use memchr to search for the byte quickly. 198*ccdc9c3eSSadaf Ebrahimi- if (!ucs2 && !anchored && first_byte_ >= 0 && runq->size() == 0 && 199*ccdc9c3eSSadaf Ebrahimi+ if (!anchored && first_byte_ >= 0 && runq->size() == 0 && 200*ccdc9c3eSSadaf Ebrahimi p < text.end() && (p[0] & 0xFF) != first_byte_) { 201*ccdc9c3eSSadaf Ebrahimi p = reinterpret_cast<const char*>(memchr(p, first_byte_, 202*ccdc9c3eSSadaf Ebrahimi text.end() - p)); 203*ccdc9c3eSSadaf Ebrahimire2/nfa.cc#8:505,526 - re2/nfa.cc#9:504,514 204*ccdc9c3eSSadaf Ebrahimi flag = Prog::EmptyFlags(context, p); 205*ccdc9c3eSSadaf Ebrahimi } 206*ccdc9c3eSSadaf Ebrahimi 207*ccdc9c3eSSadaf Ebrahimi- // In UCS-2 mode, if we need to start a new thread, 208*ccdc9c3eSSadaf Ebrahimi- // make sure to do it on an even boundary. 209*ccdc9c3eSSadaf Ebrahimi- if(ucs2 && runq->size() == 0 && 210*ccdc9c3eSSadaf Ebrahimi- (p - context.begin()) % 2 && p < text.end()) { 211*ccdc9c3eSSadaf Ebrahimi- p++; 212*ccdc9c3eSSadaf Ebrahimi- flag = Prog::EmptyFlags(context, p); 213*ccdc9c3eSSadaf Ebrahimi- } 214*ccdc9c3eSSadaf Ebrahimi- 215*ccdc9c3eSSadaf Ebrahimi // Steal match storage (cleared but unused as of yet) 216*ccdc9c3eSSadaf Ebrahimi // temporarily to hold match boundaries for new thread. 217*ccdc9c3eSSadaf Ebrahimi- // In UCS-2 mode, only start the thread on a 2-byte boundary. 218*ccdc9c3eSSadaf Ebrahimi- if(!ucs2 || (p - context.begin()) % 2 == 0) { 219*ccdc9c3eSSadaf Ebrahimi- match_[0] = p; 220*ccdc9c3eSSadaf Ebrahimi- AddToThreadq(runq, start_, flag, p, match_); 221*ccdc9c3eSSadaf Ebrahimi- match_[0] = NULL; 222*ccdc9c3eSSadaf Ebrahimi- } 223*ccdc9c3eSSadaf Ebrahimi+ match_[0] = p; 224*ccdc9c3eSSadaf Ebrahimi+ AddToThreadq(runq, start_, flag, p, match_); 225*ccdc9c3eSSadaf Ebrahimi+ match_[0] = NULL; 226*ccdc9c3eSSadaf Ebrahimi } 227*ccdc9c3eSSadaf Ebrahimi 228*ccdc9c3eSSadaf Ebrahimi // If all the threads have died, stop early. 229*ccdc9c3eSSadaf Ebrahimi==== re2/parse.cc#22 - re2/parse.cc#23 ==== 230*ccdc9c3eSSadaf Ebrahimire2/parse.cc#22:160,167 - re2/parse.cc#23:160,165 231*ccdc9c3eSSadaf Ebrahimi status_(status), stacktop_(NULL), ncap_(0) { 232*ccdc9c3eSSadaf Ebrahimi if (flags_ & Latin1) 233*ccdc9c3eSSadaf Ebrahimi rune_max_ = 0xFF; 234*ccdc9c3eSSadaf Ebrahimi- else if (flags & UCS2) 235*ccdc9c3eSSadaf Ebrahimi- rune_max_ = 0xFFFF; 236*ccdc9c3eSSadaf Ebrahimi else 237*ccdc9c3eSSadaf Ebrahimi rune_max_ = Runemax; 238*ccdc9c3eSSadaf Ebrahimi } 239*ccdc9c3eSSadaf Ebrahimire2/parse.cc#22:365,387 - re2/parse.cc#23:363,374 240*ccdc9c3eSSadaf Ebrahimi bool Regexp::ParseState::PushCarat() { 241*ccdc9c3eSSadaf Ebrahimi if (flags_ & OneLine) { 242*ccdc9c3eSSadaf Ebrahimi return PushSimpleOp(kRegexpBeginText); 243*ccdc9c3eSSadaf Ebrahimi- } else { 244*ccdc9c3eSSadaf Ebrahimi- if (flags_ & UCS2) { 245*ccdc9c3eSSadaf Ebrahimi- status_->set_code(kRegexpUnsupported); 246*ccdc9c3eSSadaf Ebrahimi- status_->set_error_arg("multiline ^ in UCS-2 mode"); 247*ccdc9c3eSSadaf Ebrahimi- return false; 248*ccdc9c3eSSadaf Ebrahimi- } 249*ccdc9c3eSSadaf Ebrahimi- return PushSimpleOp(kRegexpBeginLine); 250*ccdc9c3eSSadaf Ebrahimi } 251*ccdc9c3eSSadaf Ebrahimi+ return PushSimpleOp(kRegexpBeginLine); 252*ccdc9c3eSSadaf Ebrahimi } 253*ccdc9c3eSSadaf Ebrahimi 254*ccdc9c3eSSadaf Ebrahimi // Pushes a \b or \B onto the stack. 255*ccdc9c3eSSadaf Ebrahimi bool Regexp::ParseState::PushWordBoundary(bool word) { 256*ccdc9c3eSSadaf Ebrahimi- if (flags_ & UCS2) { 257*ccdc9c3eSSadaf Ebrahimi- status_->set_code(kRegexpUnsupported); 258*ccdc9c3eSSadaf Ebrahimi- status_->set_error_arg("\\b or \\B in UCS-2 mode"); 259*ccdc9c3eSSadaf Ebrahimi- return false; 260*ccdc9c3eSSadaf Ebrahimi- } 261*ccdc9c3eSSadaf Ebrahimi if (word) 262*ccdc9c3eSSadaf Ebrahimi return PushSimpleOp(kRegexpWordBoundary); 263*ccdc9c3eSSadaf Ebrahimi return PushSimpleOp(kRegexpNoWordBoundary); 264*ccdc9c3eSSadaf Ebrahimire2/parse.cc#22:397,407 - re2/parse.cc#23:384,389 265*ccdc9c3eSSadaf Ebrahimi bool ret = PushSimpleOp(kRegexpEndText); 266*ccdc9c3eSSadaf Ebrahimi flags_ = oflags; 267*ccdc9c3eSSadaf Ebrahimi return ret; 268*ccdc9c3eSSadaf Ebrahimi- } 269*ccdc9c3eSSadaf Ebrahimi- if (flags_ & UCS2) { 270*ccdc9c3eSSadaf Ebrahimi- status_->set_code(kRegexpUnsupported); 271*ccdc9c3eSSadaf Ebrahimi- status_->set_error_arg("multiline $ in UCS-2 mode"); 272*ccdc9c3eSSadaf Ebrahimi- return false; 273*ccdc9c3eSSadaf Ebrahimi } 274*ccdc9c3eSSadaf Ebrahimi return PushSimpleOp(kRegexpEndLine); 275*ccdc9c3eSSadaf Ebrahimi } 276*ccdc9c3eSSadaf Ebrahimi==== re2/re2.cc#34 - re2/re2.cc#35 ==== 277*ccdc9c3eSSadaf Ebrahimire2/re2.cc#34:79,86 - re2/re2.cc#35:79,84 278*ccdc9c3eSSadaf Ebrahimi return RE2::ErrorBadUTF8; 279*ccdc9c3eSSadaf Ebrahimi case re2::kRegexpBadNamedCapture: 280*ccdc9c3eSSadaf Ebrahimi return RE2::ErrorBadNamedCapture; 281*ccdc9c3eSSadaf Ebrahimi- case re2::kRegexpUnsupported: 282*ccdc9c3eSSadaf Ebrahimi- return RE2::ErrorUnsupported; 283*ccdc9c3eSSadaf Ebrahimi } 284*ccdc9c3eSSadaf Ebrahimi return RE2::ErrorInternal; 285*ccdc9c3eSSadaf Ebrahimi } 286*ccdc9c3eSSadaf Ebrahimire2/re2.cc#34:122,130 - re2/re2.cc#35:120,125 287*ccdc9c3eSSadaf Ebrahimi break; 288*ccdc9c3eSSadaf Ebrahimi case RE2::Options::EncodingLatin1: 289*ccdc9c3eSSadaf Ebrahimi flags |= Regexp::Latin1; 290*ccdc9c3eSSadaf Ebrahimi- break; 291*ccdc9c3eSSadaf Ebrahimi- case RE2::Options::EncodingUCS2: 292*ccdc9c3eSSadaf Ebrahimi- flags |= Regexp::UCS2; 293*ccdc9c3eSSadaf Ebrahimi break; 294*ccdc9c3eSSadaf Ebrahimi } 295*ccdc9c3eSSadaf Ebrahimi 296*ccdc9c3eSSadaf Ebrahimi==== re2/re2.h#36 - re2/re2.h#37 ==== 297*ccdc9c3eSSadaf Ebrahimire2/re2.h#36:246,252 - re2/re2.h#37:246,251 298*ccdc9c3eSSadaf Ebrahimi ErrorBadUTF8, // invalid UTF-8 in regexp 299*ccdc9c3eSSadaf Ebrahimi ErrorBadNamedCapture, // bad named capture group 300*ccdc9c3eSSadaf Ebrahimi ErrorPatternTooLarge, // pattern too large (compile failed) 301*ccdc9c3eSSadaf Ebrahimi- ErrorUnsupported, // unsupported feature (in UCS-2 mode) 302*ccdc9c3eSSadaf Ebrahimi }; 303*ccdc9c3eSSadaf Ebrahimi 304*ccdc9c3eSSadaf Ebrahimi // Predefined common options. 305*ccdc9c3eSSadaf Ebrahimire2/re2.h#36:570,576 - re2/re2.h#37:569,574 306*ccdc9c3eSSadaf Ebrahimi 307*ccdc9c3eSSadaf Ebrahimi enum Encoding { 308*ccdc9c3eSSadaf Ebrahimi EncodingUTF8 = 1, 309*ccdc9c3eSSadaf Ebrahimi- EncodingUCS2, // 16-bit Unicode 0-FFFF only 310*ccdc9c3eSSadaf Ebrahimi EncodingLatin1 311*ccdc9c3eSSadaf Ebrahimi }; 312*ccdc9c3eSSadaf Ebrahimi 313*ccdc9c3eSSadaf Ebrahimi==== re2/regexp.cc#15 - re2/regexp.cc#16 ==== 314*ccdc9c3eSSadaf Ebrahimire2/regexp.cc#15:324,333 - re2/regexp.cc#16:324,329 315*ccdc9c3eSSadaf Ebrahimi // the regexp that remains after the prefix. The prefix might 316*ccdc9c3eSSadaf Ebrahimi // be ASCII case-insensitive. 317*ccdc9c3eSSadaf Ebrahimi bool Regexp::RequiredPrefix(string *prefix, bool *foldcase, Regexp** suffix) { 318*ccdc9c3eSSadaf Ebrahimi- // Don't even bother for UCS-2; it's time to throw that code away. 319*ccdc9c3eSSadaf Ebrahimi- if (parse_flags_ & UCS2) 320*ccdc9c3eSSadaf Ebrahimi- return false; 321*ccdc9c3eSSadaf Ebrahimi- 322*ccdc9c3eSSadaf Ebrahimi // No need for a walker: the regexp must be of the form 323*ccdc9c3eSSadaf Ebrahimi // 1. some number of ^ anchors 324*ccdc9c3eSSadaf Ebrahimi // 2. a literal char or string 325*ccdc9c3eSSadaf Ebrahimi==== re2/regexp.h#20 - re2/regexp.h#21 ==== 326*ccdc9c3eSSadaf Ebrahimire2/regexp.h#20:187,193 - re2/regexp.h#21:187,192 327*ccdc9c3eSSadaf Ebrahimi kRegexpBadPerlOp, // bad perl operator 328*ccdc9c3eSSadaf Ebrahimi kRegexpBadUTF8, // invalid UTF-8 in regexp 329*ccdc9c3eSSadaf Ebrahimi kRegexpBadNamedCapture, // bad named capture 330*ccdc9c3eSSadaf Ebrahimi- kRegexpUnsupported, // unsupported operator 331*ccdc9c3eSSadaf Ebrahimi }; 332*ccdc9c3eSSadaf Ebrahimi 333*ccdc9c3eSSadaf Ebrahimi // Error status for certain operations. 334*ccdc9c3eSSadaf Ebrahimire2/regexp.h#20:307,316 - re2/regexp.h#21:306,314 335*ccdc9c3eSSadaf Ebrahimi // \Q and \E to disable/enable metacharacters 336*ccdc9c3eSSadaf Ebrahimi // (?P<name>expr) for named captures 337*ccdc9c3eSSadaf Ebrahimi // \C to match any single byte 338*ccdc9c3eSSadaf Ebrahimi- UCS2 = 1<<10, // Text is in UCS-2, regexp is in UTF-8. 339*ccdc9c3eSSadaf Ebrahimi- UnicodeGroups = 1<<11, // Allow \p{Han} for Unicode Han group 340*ccdc9c3eSSadaf Ebrahimi+ UnicodeGroups = 1<<10, // Allow \p{Han} for Unicode Han group 341*ccdc9c3eSSadaf Ebrahimi // and \P{Han} for its negation. 342*ccdc9c3eSSadaf Ebrahimi- NeverNL = 1<<12, // Never match NL, even if the regexp mentions 343*ccdc9c3eSSadaf Ebrahimi+ NeverNL = 1<<11, // Never match NL, even if the regexp mentions 344*ccdc9c3eSSadaf Ebrahimi // it explicitly. 345*ccdc9c3eSSadaf Ebrahimi 346*ccdc9c3eSSadaf Ebrahimi // As close to Perl as we can get. 347*ccdc9c3eSSadaf Ebrahimi==== re2/testing/backtrack.cc#4 - re2/testing/backtrack.cc#5 ==== 348*ccdc9c3eSSadaf Ebrahimire2/testing/backtrack.cc#4:134,141 - re2/testing/backtrack.cc#5:134,139 349*ccdc9c3eSSadaf Ebrahimi cap_[0] = p; 350*ccdc9c3eSSadaf Ebrahimi if (Visit(prog_->start(), p)) // Match must be leftmost; done. 351*ccdc9c3eSSadaf Ebrahimi return true; 352*ccdc9c3eSSadaf Ebrahimi- if (prog_->flags() & Regexp::UCS2) 353*ccdc9c3eSSadaf Ebrahimi- p++; 354*ccdc9c3eSSadaf Ebrahimi } 355*ccdc9c3eSSadaf Ebrahimi return false; 356*ccdc9c3eSSadaf Ebrahimi } 357*ccdc9c3eSSadaf Ebrahimi==== re2/testing/tester.cc#12 - re2/testing/tester.cc#13 ==== 358*ccdc9c3eSSadaf Ebrahimire2/testing/tester.cc#12:144,154 - re2/testing/tester.cc#13:144,152 359*ccdc9c3eSSadaf Ebrahimi static ParseMode parse_modes[] = { 360*ccdc9c3eSSadaf Ebrahimi { single_line, "single-line" }, 361*ccdc9c3eSSadaf Ebrahimi { single_line|Regexp::Latin1, "single-line, latin1" }, 362*ccdc9c3eSSadaf Ebrahimi- { single_line|Regexp::UCS2, "single-line, ucs2" }, 363*ccdc9c3eSSadaf Ebrahimi { multi_line, "multiline" }, 364*ccdc9c3eSSadaf Ebrahimi { multi_line|Regexp::NonGreedy, "multiline, nongreedy" }, 365*ccdc9c3eSSadaf Ebrahimi { multi_line|Regexp::Latin1, "multiline, latin1" }, 366*ccdc9c3eSSadaf Ebrahimi- { multi_line|Regexp::UCS2, "multiline, ucs2" }, 367*ccdc9c3eSSadaf Ebrahimi }; 368*ccdc9c3eSSadaf Ebrahimi 369*ccdc9c3eSSadaf Ebrahimi static string FormatMode(Regexp::ParseFlags flags) { 370*ccdc9c3eSSadaf Ebrahimire2/testing/tester.cc#12:179,189 - re2/testing/tester.cc#13:177,185 371*ccdc9c3eSSadaf Ebrahimi RegexpStatus status; 372*ccdc9c3eSSadaf Ebrahimi regexp_ = Regexp::Parse(regexp_str, flags, &status); 373*ccdc9c3eSSadaf Ebrahimi if (regexp_ == NULL) { 374*ccdc9c3eSSadaf Ebrahimi- if (status.code() != kRegexpUnsupported) { 375*ccdc9c3eSSadaf Ebrahimi- LOG(INFO) << "Cannot parse: " << CEscape(regexp_str_) 376*ccdc9c3eSSadaf Ebrahimi- << " mode: " << FormatMode(flags); 377*ccdc9c3eSSadaf Ebrahimi- error_ = true; 378*ccdc9c3eSSadaf Ebrahimi- } 379*ccdc9c3eSSadaf Ebrahimi+ LOG(INFO) << "Cannot parse: " << CEscape(regexp_str_) 380*ccdc9c3eSSadaf Ebrahimi+ << " mode: " << FormatMode(flags); 381*ccdc9c3eSSadaf Ebrahimi+ error_ = true; 382*ccdc9c3eSSadaf Ebrahimi return; 383*ccdc9c3eSSadaf Ebrahimi } 384*ccdc9c3eSSadaf Ebrahimi prog_ = regexp_->CompileToProg(0); 385*ccdc9c3eSSadaf Ebrahimire2/testing/tester.cc#12:230,237 - re2/testing/tester.cc#13:226,231 386*ccdc9c3eSSadaf Ebrahimi RE2::Options options; 387*ccdc9c3eSSadaf Ebrahimi if (flags & Regexp::Latin1) 388*ccdc9c3eSSadaf Ebrahimi options.set_encoding(RE2::Options::EncodingLatin1); 389*ccdc9c3eSSadaf Ebrahimi- else if (flags & Regexp::UCS2) 390*ccdc9c3eSSadaf Ebrahimi- options.set_encoding(RE2::Options::EncodingUCS2); 391*ccdc9c3eSSadaf Ebrahimi if (kind_ == Prog::kLongestMatch) 392*ccdc9c3eSSadaf Ebrahimi options.set_longest_match(true); 393*ccdc9c3eSSadaf Ebrahimi re2_ = new RE2(re, options); 394*ccdc9c3eSSadaf Ebrahimire2/testing/tester.cc#12:281,379 - re2/testing/tester.cc#13:275,280 395*ccdc9c3eSSadaf Ebrahimi delete re2_; 396*ccdc9c3eSSadaf Ebrahimi } 397*ccdc9c3eSSadaf Ebrahimi 398*ccdc9c3eSSadaf Ebrahimi- // Converts UTF-8 string in text into UCS-2 string in new_text. 399*ccdc9c3eSSadaf Ebrahimi- static bool ConvertUTF8ToUCS2(const StringPiece& text, StringPiece* new_text) { 400*ccdc9c3eSSadaf Ebrahimi- const char* p = text.begin(); 401*ccdc9c3eSSadaf Ebrahimi- const char* ep = text.end(); 402*ccdc9c3eSSadaf Ebrahimi- uint16* q = new uint16[ep - p]; 403*ccdc9c3eSSadaf Ebrahimi- uint16* q0 = q; 404*ccdc9c3eSSadaf Ebrahimi- 405*ccdc9c3eSSadaf Ebrahimi- int n; 406*ccdc9c3eSSadaf Ebrahimi- Rune r; 407*ccdc9c3eSSadaf Ebrahimi- for (; p < ep; p += n) { 408*ccdc9c3eSSadaf Ebrahimi- if (!fullrune(p, ep - p)) { 409*ccdc9c3eSSadaf Ebrahimi- delete[] q0; 410*ccdc9c3eSSadaf Ebrahimi- return false; 411*ccdc9c3eSSadaf Ebrahimi- } 412*ccdc9c3eSSadaf Ebrahimi- n = chartorune(&r, p); 413*ccdc9c3eSSadaf Ebrahimi- if (r > 0xFFFF) { 414*ccdc9c3eSSadaf Ebrahimi- delete[] q0; 415*ccdc9c3eSSadaf Ebrahimi- return false; 416*ccdc9c3eSSadaf Ebrahimi- } 417*ccdc9c3eSSadaf Ebrahimi- *q++ = r; 418*ccdc9c3eSSadaf Ebrahimi- } 419*ccdc9c3eSSadaf Ebrahimi- *new_text = StringPiece(reinterpret_cast<char*>(q0), 2*(q - q0)); 420*ccdc9c3eSSadaf Ebrahimi- return true; 421*ccdc9c3eSSadaf Ebrahimi- } 422*ccdc9c3eSSadaf Ebrahimi- 423*ccdc9c3eSSadaf Ebrahimi- // Rewrites *sp from being a pointer into text8 (UTF-8) 424*ccdc9c3eSSadaf Ebrahimi- // to being a pointer into text16 (equivalent text but in UCS-2). 425*ccdc9c3eSSadaf Ebrahimi- static void AdjustUTF8ToUCS2(const StringPiece& text8, const StringPiece& text16, 426*ccdc9c3eSSadaf Ebrahimi- StringPiece *sp) { 427*ccdc9c3eSSadaf Ebrahimi- if (sp->begin() == NULL && text8.begin() != NULL) 428*ccdc9c3eSSadaf Ebrahimi- return; 429*ccdc9c3eSSadaf Ebrahimi- 430*ccdc9c3eSSadaf Ebrahimi- int nrune = 0; 431*ccdc9c3eSSadaf Ebrahimi- int n; 432*ccdc9c3eSSadaf Ebrahimi- Rune r; 433*ccdc9c3eSSadaf Ebrahimi- const char* p = text8.begin(); 434*ccdc9c3eSSadaf Ebrahimi- const char* ep = text8.end(); 435*ccdc9c3eSSadaf Ebrahimi- const char* spbegin = NULL; 436*ccdc9c3eSSadaf Ebrahimi- const char* spend = NULL; 437*ccdc9c3eSSadaf Ebrahimi- for (;;) { 438*ccdc9c3eSSadaf Ebrahimi- if (p == sp->begin()) 439*ccdc9c3eSSadaf Ebrahimi- spbegin = text16.begin() + sizeof(uint16)*nrune; 440*ccdc9c3eSSadaf Ebrahimi- if (p == sp->end()) 441*ccdc9c3eSSadaf Ebrahimi- spend = text16.begin() + sizeof(uint16)*nrune; 442*ccdc9c3eSSadaf Ebrahimi- if (p >= ep) 443*ccdc9c3eSSadaf Ebrahimi- break; 444*ccdc9c3eSSadaf Ebrahimi- n = chartorune(&r, p); 445*ccdc9c3eSSadaf Ebrahimi- p += n; 446*ccdc9c3eSSadaf Ebrahimi- nrune++; 447*ccdc9c3eSSadaf Ebrahimi- } 448*ccdc9c3eSSadaf Ebrahimi- if (spbegin == NULL || spend == NULL) { 449*ccdc9c3eSSadaf Ebrahimi- LOG(FATAL) << "Error in AdjustUTF8ToUCS2 " 450*ccdc9c3eSSadaf Ebrahimi- << CEscape(text8) << " " 451*ccdc9c3eSSadaf Ebrahimi- << (int)(sp->begin() - text8.begin()) << " " 452*ccdc9c3eSSadaf Ebrahimi- << (int)(sp->end() - text8.begin()); 453*ccdc9c3eSSadaf Ebrahimi- } 454*ccdc9c3eSSadaf Ebrahimi- *sp = StringPiece(spbegin, spend - spbegin); 455*ccdc9c3eSSadaf Ebrahimi- } 456*ccdc9c3eSSadaf Ebrahimi- 457*ccdc9c3eSSadaf Ebrahimi- // Rewrites *sp from begin a pointer into text16 (UCS-2) 458*ccdc9c3eSSadaf Ebrahimi- // to being a pointer into text8 (equivalent text but in UTF-8). 459*ccdc9c3eSSadaf Ebrahimi- static void AdjustUCS2ToUTF8(const StringPiece& text16, const StringPiece& text8, 460*ccdc9c3eSSadaf Ebrahimi- StringPiece* sp) { 461*ccdc9c3eSSadaf Ebrahimi- if (sp->begin() == NULL) 462*ccdc9c3eSSadaf Ebrahimi- return; 463*ccdc9c3eSSadaf Ebrahimi- 464*ccdc9c3eSSadaf Ebrahimi- int nrune = 0; 465*ccdc9c3eSSadaf Ebrahimi- int n; 466*ccdc9c3eSSadaf Ebrahimi- Rune r; 467*ccdc9c3eSSadaf Ebrahimi- const char* p = text8.begin(); 468*ccdc9c3eSSadaf Ebrahimi- const char* ep = text8.end(); 469*ccdc9c3eSSadaf Ebrahimi- const char* spbegin = NULL; 470*ccdc9c3eSSadaf Ebrahimi- const char* spend = NULL; 471*ccdc9c3eSSadaf Ebrahimi- for (;;) { 472*ccdc9c3eSSadaf Ebrahimi- if (nrune == (sp->begin() - text16.begin())/2) 473*ccdc9c3eSSadaf Ebrahimi- spbegin = p; 474*ccdc9c3eSSadaf Ebrahimi- if (nrune == (sp->end() - text16.begin())/2) 475*ccdc9c3eSSadaf Ebrahimi- spend = p; 476*ccdc9c3eSSadaf Ebrahimi- if (p >= ep) 477*ccdc9c3eSSadaf Ebrahimi- break; 478*ccdc9c3eSSadaf Ebrahimi- n = chartorune(&r, p); 479*ccdc9c3eSSadaf Ebrahimi- p += n; 480*ccdc9c3eSSadaf Ebrahimi- nrune++; 481*ccdc9c3eSSadaf Ebrahimi- } 482*ccdc9c3eSSadaf Ebrahimi- if (text8.begin() != NULL && (spbegin == NULL || spend == NULL)) { 483*ccdc9c3eSSadaf Ebrahimi- LOG(FATAL) << "Error in AdjustUCS2ToUTF8 " 484*ccdc9c3eSSadaf Ebrahimi- << CEscape(text16) << " " 485*ccdc9c3eSSadaf Ebrahimi- << (int)(sp->begin() - text16.begin()) << " " 486*ccdc9c3eSSadaf Ebrahimi- << (int)(sp->end() - text16.begin()); 487*ccdc9c3eSSadaf Ebrahimi- } 488*ccdc9c3eSSadaf Ebrahimi- *sp = StringPiece(spbegin, spend - spbegin); 489*ccdc9c3eSSadaf Ebrahimi- } 490*ccdc9c3eSSadaf Ebrahimi- 491*ccdc9c3eSSadaf Ebrahimi // Runs a single search using the named engine type. 492*ccdc9c3eSSadaf Ebrahimi // This interface hides all the irregularities of the various 493*ccdc9c3eSSadaf Ebrahimi // engine interfaces from the rest of this file. 494*ccdc9c3eSSadaf Ebrahimire2/testing/tester.cc#12:393,411 - re2/testing/tester.cc#13:294,300 495*ccdc9c3eSSadaf Ebrahimi 496*ccdc9c3eSSadaf Ebrahimi StringPiece text = orig_text; 497*ccdc9c3eSSadaf Ebrahimi StringPiece context = orig_context; 498*ccdc9c3eSSadaf Ebrahimi- bool ucs2 = false; 499*ccdc9c3eSSadaf Ebrahimi 500*ccdc9c3eSSadaf Ebrahimi- if ((flags() & Regexp::UCS2) && type != kEnginePCRE) { 501*ccdc9c3eSSadaf Ebrahimi- if (!ConvertUTF8ToUCS2(orig_context, &context)) { 502*ccdc9c3eSSadaf Ebrahimi- result->skipped = true; 503*ccdc9c3eSSadaf Ebrahimi- return; 504*ccdc9c3eSSadaf Ebrahimi- } 505*ccdc9c3eSSadaf Ebrahimi- 506*ccdc9c3eSSadaf Ebrahimi- // Rewrite context to refer to new text. 507*ccdc9c3eSSadaf Ebrahimi- AdjustUTF8ToUCS2(orig_context, context, &text); 508*ccdc9c3eSSadaf Ebrahimi- ucs2 = true; 509*ccdc9c3eSSadaf Ebrahimi- } 510*ccdc9c3eSSadaf Ebrahimi- 511*ccdc9c3eSSadaf Ebrahimi switch (type) { 512*ccdc9c3eSSadaf Ebrahimi default: 513*ccdc9c3eSSadaf Ebrahimi LOG(FATAL) << "Bad RunSearch type: " << (int)type; 514*ccdc9c3eSSadaf Ebrahimire2/testing/tester.cc#12:557,577 - re2/testing/tester.cc#13:446,451 515*ccdc9c3eSSadaf Ebrahimi } 516*ccdc9c3eSSadaf Ebrahimi } 517*ccdc9c3eSSadaf Ebrahimi 518*ccdc9c3eSSadaf Ebrahimi- // If we did UCS-2 matching, rewrite the matches to refer 519*ccdc9c3eSSadaf Ebrahimi- // to the original UTF-8 text. 520*ccdc9c3eSSadaf Ebrahimi- if (ucs2) { 521*ccdc9c3eSSadaf Ebrahimi- if (result->matched) { 522*ccdc9c3eSSadaf Ebrahimi- if (result->have_submatch0) { 523*ccdc9c3eSSadaf Ebrahimi- AdjustUCS2ToUTF8(context, orig_context, &result->submatch[0]); 524*ccdc9c3eSSadaf Ebrahimi- } else if (result->have_submatch) { 525*ccdc9c3eSSadaf Ebrahimi- for (int i = 0; i < nsubmatch; i++) { 526*ccdc9c3eSSadaf Ebrahimi- AdjustUCS2ToUTF8(context, orig_context, &result->submatch[i]); 527*ccdc9c3eSSadaf Ebrahimi- } 528*ccdc9c3eSSadaf Ebrahimi- } 529*ccdc9c3eSSadaf Ebrahimi- } 530*ccdc9c3eSSadaf Ebrahimi- delete[] context.begin(); 531*ccdc9c3eSSadaf Ebrahimi- } 532*ccdc9c3eSSadaf Ebrahimi- 533*ccdc9c3eSSadaf Ebrahimi if (!result->matched) 534*ccdc9c3eSSadaf Ebrahimi memset(result->submatch, 0, sizeof result->submatch); 535*ccdc9c3eSSadaf Ebrahimi } 536*ccdc9c3eSSadaf Ebrahimire2/testing/tester.cc#12:596,617 - re2/testing/tester.cc#13:470,475 537*ccdc9c3eSSadaf Ebrahimi return true; 538*ccdc9c3eSSadaf Ebrahimi } 539*ccdc9c3eSSadaf Ebrahimi 540*ccdc9c3eSSadaf Ebrahimi- // Check whether text uses only Unicode points <= 0xFFFF 541*ccdc9c3eSSadaf Ebrahimi- // (in the BMP). 542*ccdc9c3eSSadaf Ebrahimi- static bool IsBMP(const StringPiece& text) { 543*ccdc9c3eSSadaf Ebrahimi- const char* p = text.begin(); 544*ccdc9c3eSSadaf Ebrahimi- const char* ep = text.end(); 545*ccdc9c3eSSadaf Ebrahimi- while (p < ep) { 546*ccdc9c3eSSadaf Ebrahimi- if (!fullrune(p, ep - p)) 547*ccdc9c3eSSadaf Ebrahimi- return false; 548*ccdc9c3eSSadaf Ebrahimi- Rune r; 549*ccdc9c3eSSadaf Ebrahimi- p += chartorune(&r, p); 550*ccdc9c3eSSadaf Ebrahimi- if (r > 0xFFFF) 551*ccdc9c3eSSadaf Ebrahimi- return false; 552*ccdc9c3eSSadaf Ebrahimi- } 553*ccdc9c3eSSadaf Ebrahimi- return true; 554*ccdc9c3eSSadaf Ebrahimi- } 555*ccdc9c3eSSadaf Ebrahimi- 556*ccdc9c3eSSadaf Ebrahimi // Runs a single test. 557*ccdc9c3eSSadaf Ebrahimi bool TestInstance::RunCase(const StringPiece& text, const StringPiece& context, 558*ccdc9c3eSSadaf Ebrahimi Prog::Anchor anchor) { 559*ccdc9c3eSSadaf Ebrahimire2/testing/tester.cc#12:619,625 - re2/testing/tester.cc#13:477,483 560*ccdc9c3eSSadaf Ebrahimi Result correct; 561*ccdc9c3eSSadaf Ebrahimi RunSearch(kEngineBacktrack, text, context, anchor, &correct); 562*ccdc9c3eSSadaf Ebrahimi if (correct.skipped) { 563*ccdc9c3eSSadaf Ebrahimi- if (regexp_ == NULL || !IsBMP(context)) // okay to skip in UCS-2 mode 564*ccdc9c3eSSadaf Ebrahimi+ if (regexp_ == NULL) 565*ccdc9c3eSSadaf Ebrahimi return true; 566*ccdc9c3eSSadaf Ebrahimi LOG(ERROR) << "Skipped backtracking! " << CEscape(regexp_str_) 567*ccdc9c3eSSadaf Ebrahimi << " " << FormatMode(flags_); 568