xref: /aosp_15_r20/external/regex-re2/ucs2.diff (revision ccdc9c3e24c519bfa4832a66aa2e83a52c19f295)
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