code review 1174041: re2: memory diet

re2/parse.cc

 // Copyright 2006 The RE2 Authors.  All Rights Reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // Regular expression parser.
 
 // The parser is a simple precedence-based parser with a
 // manual stack.  The parsing work is done by the methods
 // of the ParseState class.  The Regexp::Parse function is
 // essentially just a lexer that calls the ParseState method
@@ skipping 84 matching lines @@
   bool DoLeftParenNoCapture();
 
   // Processes a vertical bar in the input.
   bool DoVerticalBar();
 
   // Processes a right parenthesis in the input.
   bool DoRightParen();
 
   // Processes the end of input, returning the final regexp.
   Regexp* DoFinish();
+··
+  // Finishes the regexp if necessary, preparing it for use
+  // in a more complicated expression.
+  // If it is a CharClassBuilder, converts into a CharClass.
+  Regexp* FinishRegexp(Regexp*);
 
   // These routines don't manipulate the parse stack
   // directly, but they do need to look at flags_.
   // ParseCharClass also manipulates the internals of Regexp
   // while creating *out_re.
 
   // Parse a character class into *out_re.
   // Removes parsed text from s.
   bool ParseCharClass(StringPiece* s, Regexp** out_re,
                       RegexpStatus* status);
@@ skipping 52 matching lines @@
 // Cleans up by freeing all the regexps on the stack.
 Regexp::ParseState::~ParseState() {
   Regexp* next;
   for (Regexp* re = stacktop_; re != NULL; re = next) {
     next = re->down_;
     re->down_ = NULL;
     re->Decref();
   }
 }
 
+// Finishes the regexp if necessary, preparing it for use in
+// a more complex expression.
+// If it is a CharClassBuilder, converts into a CharClass.
+Regexp* Regexp::ParseState::FinishRegexp(Regexp* re) {
+  if (re == NULL)
+    return NULL;
+  re->down_ = NULL;
+
+  if (re->op_ == kRegexpCharClass && re->ccb_ != NULL) {
+    CharClassBuilder* ccb = re->ccb_;
+    re->ccb_ = NULL;
+    re->cc_ = ccb->GetCharClass();
+    delete ccb;
+  }
+
+  return re;
+}
+
 // Pushes the given regular expression onto the stack.
 // Could check for too much memory used here.
 bool Regexp::ParseState::PushRegexp(Regexp* re) {
   MaybeConcatString(-1, NoParseFlags);
 
   // Special case: a character class of one character is just
   // a literal.  This is a common idiom for escaping
   // single characters (e.g., [.] instead of \.), and some
   // analysis does better with fewer character classes.
   // Similarly, [Aa] can be rewritten as a literal A with ASCII case folding.
   if (re->op_ == kRegexpCharClass) {
-    if (re->cc_->size() == 1) {
-      Rune r = re->cc_->begin()->lo;
+    if (re->ccb_->size() == 1) {
+      Rune r = re->ccb_->begin()->lo;
       re->Decref();
       re = new Regexp(kRegexpLiteral, flags_);
       re->rune_ = r;
-    } else if (re->cc_->size() == 2) {
-      Rune r = re->cc_->begin()->lo;
-      if ('A' <= r && r <= 'Z' && re->cc_->Contains(r + 'a' - 'A')) {
+    } else if (re->ccb_->size() == 2) {
+      Rune r = re->ccb_->begin()->lo;
+      if ('A' <= r && r <= 'Z' && re->ccb_->Contains(r + 'a' - 'A')) {
         re->Decref();
         re = new Regexp(kRegexpLiteral, flags_ | FoldCase);
         re->rune_ = r + 'a' - 'A';
       }
     }
   }
 
   if (!IsMarker(re->op()))
     re->simple_ = re->ComputeSimple();
   re->down_ = stacktop_;
@@ skipping 66 matching lines @@
 Rune CycleFoldRune(Rune r) {
   CaseFold* f = LookupCaseFold(r);
   if (f == NULL || r < f->lo)
     return r;
   return ApplyFold(f, r);
 }
 
 // Add lo-hi to the class, along with their fold-equivalent characters.
 // If lo-hi is already in the class, assume that the fold-equivalent
 // chars are there too, so there's no work to do.
-static void AddFoldedRange(CharClass* cc, Rune lo, Rune hi, int depth) {
+static void AddFoldedRange(CharClassBuilder* cc, Rune lo, Rune hi, int depth) {
   // AddFoldedRange calls itself recursively for each rune in the fold cycle.
   // Most folding cycles are small: there aren't any bigger than four in the
   // current Unicode tables.  make_unicode_casefold.py checks that
   // the cycles are not too long, and we double-check here using depth.
   if (depth > 10) {
     LOG(DFATAL) << "AddFoldedRange recurses too much.";
     return;
   }
 
   if (!cc->AddRange(lo, hi))  // lo-hi was already there? we're done
@@ skipping 35 matching lines @@
     // Pick up where this fold left off.
     lo = f->hi + 1;
   }
 }
 
 // Pushes the literal rune r onto the stack.
 bool Regexp::ParseState::PushLiteral(Rune r) {
   // Do case folding if needed.
   if ((flags_ & FoldCase) && CycleFoldRune(r) != r) {
     Regexp* re = new Regexp(kRegexpCharClass, flags_ & ~FoldCase);
+    re->ccb_ = new CharClassBuilder;
     Rune r1 = r;
     do {
       if (!(flags_ & NeverNL) || r != '\n') {
-        re->cc()->AddRange(r, r);
+        re->ccb_->AddRange(r, r);
       }
       r = CycleFoldRune(r);
     } while (r != r1);
-    re->cc()->RemoveAbove(rune_max_);
+    re->ccb_->RemoveAbove(rune_max_);
     return PushRegexp(re);
   }
 
   // Exclude newline if applicable.
   if ((flags_ & NeverNL) && r == '\n')
     return PushRegexp(new Regexp(kRegexpNoMatch, flags_));
 
   // No fancy stuff worked.  Ordinary literal.
   if (MaybeConcatString(r, flags_))
     return true;
@@ skipping 31 matching lines @@
   }
   return PushSimpleOp(kRegexpEndLine);
 }
 
 // Pushes a . onto the stack.
 bool Regexp::ParseState::PushDot() {
   if ((flags_ & DotNL) && !(flags_ & NeverNL))
     return PushSimpleOp(kRegexpAnyChar);
   // Rewrite . into [^\n]
   Regexp* re = new Regexp(kRegexpCharClass, flags_ & ~FoldCase);
-  re->cc_->AddRange(0, '\n' - 1);
-  re->cc_->AddRange('\n' + 1, rune_max_);
+  re->ccb_ = new CharClassBuilder;
+  re->ccb_->AddRange(0, '\n' - 1);
+  re->ccb_->AddRange('\n' + 1, rune_max_);
   return PushRegexp(re);
 }
 
 // Pushes a regexp with the given op (and no args) onto the stack.
 bool Regexp::ParseState::PushSimpleOp(RegexpOp op) {
   Regexp* re = new Regexp(op, flags_);
   return PushRegexp(re);
 }
 
 // Pushes a repeat operator regexp onto the stack.
 // A valid argument for the operator must already be on the stack.
 // The char c is the name of the operator, for use in error messages.
 bool Regexp::ParseState::PushRepeatOp(RegexpOp op, const StringPiece& s,
                                       bool nongreedy) {
   if (stacktop_ == NULL || IsMarker(stacktop_->op())) {
     status_->set_code(kRegexpRepeatArgument);
     status_->set_error_arg(s);
     return false;
   }
   Regexp::ParseFlags fl = flags_;
   if (nongreedy)
     fl = fl ^ NonGreedy;
   Regexp* re = new Regexp(op, fl);
   re->AllocSub(1);
-  re->sub_[0] = stacktop_;
+  re->down_ = stacktop_->down_;
+  re->sub()[0] = FinishRegexp(stacktop_);
   re->simple_ = re->ComputeSimple();
-  re->down_ = stacktop_->down_;
   stacktop_ = re;
   return true;
 }
 
 // Pushes a repetition regexp onto the stack.
 // A valid argument for the operator must already be on the stack.
 bool Regexp::ParseState::PushRepetition(int min, int max,
                                         const StringPiece& s,
                                         bool nongreedy) {
   if ((max != -1 && max < min) || max > 1000) {
     status_->set_code(kRegexpRepeatSize);
     status_->set_error_arg(s);
     return false;
   }
   if (stacktop_ == NULL || IsMarker(stacktop_->op())) {
     status_->set_code(kRegexpRepeatArgument);
     status_->set_error_arg(s);
     return false;
   }
   Regexp::ParseFlags fl = flags_;
   if (nongreedy)
     fl = fl ^ NonGreedy;
   Regexp* re = new Regexp(kRegexpRepeat, fl);
   re->min_ = min;
   re->max_ = max;
   re->AllocSub(1);
-  re->sub_[0] = stacktop_;
+  re->down_ = stacktop_->down_;
+  re->sub()[0] = FinishRegexp(stacktop_);
   re->simple_ = re->ComputeSimple();
 
-  re->down_ = stacktop_->down_;
   stacktop_ = re;
   return true;
 }
 
-// Pseudo-operators marking left paren and pipe operators
-// in the regexp stack.
+// Pseudo-operators - only on parse stack.
+
+// Markers for left paren and pipe operators in the regexp stack.
 const RegexpOp kLeftParen = static_cast<RegexpOp>(kMaxRegexpOp+1);
 const RegexpOp kVerticalBar = static_cast<RegexpOp>(kMaxRegexpOp+2);
 
 // Checks whether a particular regexp op is a marker.
 bool Regexp::ParseState::IsMarker(RegexpOp op) {
   return op >= kLeftParen;
 }
 
 // Processes a left parenthesis in the input.
 // Pushes a marker onto the stack.
 bool Regexp::ParseState::DoLeftParen(const StringPiece& name) {
   Regexp* re = new Regexp(kLeftParen, flags_);
   re->cap_ = ++ncap_;
   if (name.data() != NULL)
     re->name_ = new string(name.as_string());
   return PushRegexp(re);
 }
 
 // Pushes a non-capturing marker onto the stack.
 bool Regexp::ParseState::DoLeftParenNoCapture() {
   Regexp* re = new Regexp(kLeftParen, flags_);
   re->cap_ = -1;
   return PushRegexp(re);
 }
 
 // Adds r to cc, along with r's upper case if foldascii is set.
-static void AddLiteral(CharClass* cc, Rune r, bool foldascii) {
+static void AddLiteral(CharClassBuilder* cc, Rune r, bool foldascii) {
   cc->AddRange(r, r);
   if (foldascii && 'a' <= r && r <= 'z')
     cc->AddRange(r + 'A' - 'a', r + 'A' - 'a');
 }
 
 // Processes a vertical bar in the input.
 bool Regexp::ParseState::DoVerticalBar() {
   MaybeConcatString(-1, NoParseFlags);
   DoConcatenation();
 
   // Below the vertical bar is a list to alternate.
   // Above the vertical bar is a list to concatenate.
   // We just did the concatenation, so either swap
   // the result below the vertical bar or push a new
   // vertical bar on the stack.
   Regexp* r1;
   Regexp* r2;
   if ((r1 = stacktop_) != NULL &&
       (r2 = stacktop_->down_) != NULL &&
       r2->op() == kVerticalBar) {
     // If above and below vertical bar are literal or char class,
     // can merge into a single char class.
     Regexp* r3;
     if ((r1->op() == kRegexpLiteral ||
          r1->op() == kRegexpCharClass ||
          r1->op() == kRegexpAnyChar) &&
         (r3 = r2->down_) != NULL) {
+      Rune rune;
       switch (r3->op()) {
         case kRegexpLiteral:  // convert to char class
+          rune = r3->rune_;
           r3->op_ = kRegexpCharClass;
-          r3->cc_ = new CharClass;
-          AddLiteral(r3->cc_, r3->rune_, r3->parse_flags_ & Regexp::FoldCase);
+          r3->cc_ = NULL;
+          r3->ccb_ = new CharClassBuilder;
+          AddLiteral(r3->ccb_, rune, r3->parse_flags_ & Regexp::FoldCase);
           // fall through
         case kRegexpCharClass:
           if (r1->op() == kRegexpLiteral)
-            AddLiteral(r3->cc_, r1->rune_, r1->parse_flags_ & Regexp::FoldCase);
+            AddLiteral(r3->ccb_, r1->rune_, r1->parse_flags_ & Regexp::FoldCase);
           else if (r1->op() == kRegexpCharClass)
-            r3->cc_->AddCharClass(r1->cc());
-          if (r1->op() == kRegexpAnyChar || r3->cc_->full()) {
+            r3->ccb_->AddCharClass(r1->ccb_);
+          if (r1->op() == kRegexpAnyChar || r3->ccb_->full()) {
+            delete r3->ccb_;
+            r3->ccb_ = NULL;
             r3->op_ = kRegexpAnyChar;
-            delete r3->cc_;
-            r3->cc_ = NULL;
           }
           // fall through
         case kRegexpAnyChar:
           // pop r1
           stacktop_ = r2;
           r1->Decref();
           return true;
         default:
           break;
       }
@@ skipping 31 matching lines @@
 
   // Restore flags from when paren opened.
   Regexp* re = r2;
   flags_ = re->parse_flags();
 
   // Rewrite LeftParen as capture if needed.
   if (re->cap_ > 0) {
     re->op_ = kRegexpCapture;
     // re->cap_ is already set
     re->AllocSub(1);
-    re->sub_[0] = r1;
+    re->sub()[0] = FinishRegexp(r1);
     re->simple_ = re->ComputeSimple();
   } else {
     re->Decref();
     re = r1;
   }
   return PushRegexp(re);
 }
 
 // Processes the end of input, returning the final regexp.
 Regexp* Regexp::ParseState::DoFinish() {
   DoAlternation();
   Regexp* re = stacktop_;
   if (re != NULL && re->down_ != NULL) {
     status_->set_code(kRegexpMissingParen);
     status_->set_error_arg(whole_regexp_);
     return NULL;
   }
   stacktop_ = NULL;
-  return re;
+  return FinishRegexp(re);
 }
 
 // Collapse the regexps on top of the stack, down to the
 // first marker, into a new op node (op == kRegexpAlternate
 // or op == kRegexpConcat).
 void Regexp::ParseState::DoCollapse(RegexpOp op) {
   // Scan backward to marker, counting children of composite.
   int n = 0;
   Regexp* next = NULL;
   Regexp* sub;
   for (sub = stacktop_; sub != NULL && !IsMarker(sub->op()); sub = next) {
     next = sub->down_;
     if (sub->op_ == op)
       n += sub->nsub_;
     else
       n++;
   }
 
   // If there's just one child, leave it alone.
   // (Concat of one thing is that one thing; alternate of one thing is same.)
   if (stacktop_ != NULL && stacktop_->down_ == next)
     return;
 
   // Construct op (alternation or concatenation), flattening op of op.
-  Regexp* re = new Regexp(op, flags_);
-  re->AllocSub(n);
+  Regexp** subs = new Regexp*[n];
   next = NULL;
+  int i = n;
   for (sub = stacktop_; sub != NULL && !IsMarker(sub->op()); sub = next) {
-    next = sub->down_;  // in case we sub->Decref().
+    next = sub->down_;
     if (sub->op_ == op) {
+      Regexp** sub_subs = sub->sub();
       for (int k = sub->nsub_ - 1; k >= 0; k--)
-        re->sub_[--n] = sub->sub_[k]->Incref();
+        subs[--i] = sub_subs[k]->Incref();
       sub->Decref();
     } else {
-      re->sub_[--n] = sub;
+      subs[--i] = FinishRegexp(sub);
     }
   }
+··
+  Regexp* re = ConcatOrAlternate(op, subs, n, flags_);
+  delete[] subs;
   re->simple_ = re->ComputeSimple();
   re->down_ = next;
   stacktop_ = re;
 }
 
 // Finishes the current concatenation,
 // collapsing it into a single regexp on the stack.
 void Regexp::ParseState::DoConcatenation() {
   Regexp* r1 = stacktop_;
   if (r1 == NULL || IsMarker(r1->op())) {
     // empty concatenation is special case
     Regexp* re = new Regexp(kRegexpEmptyMatch, flags_);
     PushRegexp(re);
   }
   DoCollapse(kRegexpConcat);
 }
 
 // Finishes the current alternation,
 // collapsing it to a single regexp on the stack.
 void Regexp::ParseState::DoAlternation() {
   DoVerticalBar();
   // Now stack top is kVerticalBar.
   Regexp* r1 = stacktop_;
   stacktop_ = r1->down_;
   r1->Decref();
   DoCollapse(kRegexpAlternate);
 }
 
 // Incremental conversion of concatenated literals into strings.
-// If top of stack is literal, literal or literal, string or string, literal
-// or string, string, collapse into single string.
+// If top of stack is (literal, literal) or (literal, string) or (string, literal)
+// or (string, string), collapse into single string.
 // Don't walk down the stack -- the parser calls this frequently
 // enough that below the bottom two is known to be collapsed.
 // Only called when another regexp is about to be pushed
 // on the stack, so that the topmost literal is not being considered.
 // (Otherwise ab* would turn into (ab)*.)
 // If r >= 0, consider pushing a literal r on the stack.
 // Return whether that happened.
 bool Regexp::ParseState::MaybeConcatString(int r, ParseFlags flags) {
   Regexp* re1;
   Regexp* re2;
   if ((re1 = stacktop_) == NULL || (re2 = re1->down_) == NULL)
     return false;
 
   if (re1->op_ != kRegexpLiteral && re1->op_ != kRegexpLiteralString)
     return false;
   if (re2->op_ != kRegexpLiteral && re2->op_ != kRegexpLiteralString)
     return false;
   if ((re1->parse_flags_ & FoldCase) != (re2->parse_flags_ & FoldCase))
     return false;
 
   if (re2->op_ == kRegexpLiteral) {
     // convert into string
+    Rune rune = re2->rune_;
     re2->op_ = kRegexpLiteralString;
-    re2->AddRuneToString(re2->rune_);
+    re2->nrunes_ = 0;
+    re2->runes_ = NULL;
+    re2->AddRuneToString(rune);
   }
 
   // push re1 into re2.
   if (re1->op_ == kRegexpLiteral) {
     re2->AddRuneToString(re1->rune_);
   } else {
     for (int i = 0; i < re1->nrunes_; i++)
       re2->AddRuneToString(re1->runes_[i]);
     re1->nrunes_ = 0;
     delete[] re1->runes_;
@@ skipping 272 matching lines @@
 
 BadEscape:
   // Unrecognized escape sequence.
   status->set_code(kRegexpBadEscape);
   status->set_error_arg(StringPiece(begin, s->data() - begin));
   return false;
 }
 
 // Add a range to the character class, but exclude newline if asked.
 // Also handle case folding.
-static void AddRange(CharClass* cc, Rune lo, Rune hi,
+static void AddRange(CharClassBuilder* cc, Rune lo, Rune hi,
                      Regexp::ParseFlags parse_flags) {
 
   // Take out \n if the flags say so.
   bool cutnl = !(parse_flags & Regexp::ClassNL) ||
                (parse_flags & Regexp::NeverNL);
   if (cutnl && lo <= '\n' && '\n' <= hi) {
     if (lo < '\n')
       AddRange(cc, lo, '\n' - 1, parse_flags);
     if (hi > '\n')
       AddRange(cc, '\n' + 1, hi, parse_flags);
@@ skipping 33 matching lines @@
 
 // Look for a Unicode group with the given name (e.g., "Han")
 static UGroup* LookupUnicodeGroup(const StringPiece& name) {
   // Special case: "Any" means any.
   if (name == "Any")
     return &anygroup;
   return LookupGroup(name, unicode_groups, num_unicode_groups);
 }
 
 // Add a UGroup to the character class.
-static void AddUGroup(CharClass *cc, UGroup *g,
+static void AddUGroup(CharClassBuilder *cc, UGroup *g,
                       Regexp::ParseFlags parse_flags) {
   for (int i = 0; i < g->nr16; i++) {
     AddRange(cc, g->r16[i].lo, g->r16[i].hi, parse_flags);
   }
   for (int i = 0; i < g->nr32; i++) {
     AddRange(cc, g->r32[i].lo, g->r32[i].hi, parse_flags);
   }
 }
 
 // Add the negation of a UGroup to the character class.
-static void AddNegatedUGroup(CharClass* cc, UGroup *g,
+static void AddNegatedUGroup(CharClassBuilder* cc, UGroup *g,
                              Regexp::ParseFlags parse_flags) {
   int next = 0;
   for (int i = 0; i < g->nr16; i++) {
     if (next < g->r16[i].lo)
       AddRange(cc, next, g->r16[i].lo - 1, parse_flags);
     next = g->r16[i].hi + 1;
   }
   for (int i = 0; i < g->nr32; i++) {
     if (next < g->r32[i].lo)
       AddRange(cc, next, g->r32[i].lo - 1, parse_flags);
@@ skipping 26 matching lines @@
 
 enum ParseStatus {
   kParseOk,  // Did some parsing.
   kParseError,  // Found an error.
   kParseNothing,  // Decided not to parse.
 };
 
 // Maybe parses a Unicode character group like \p{Han} or \P{Han}
 // (the latter is a negated group).
 ParseStatus ParseUnicodeGroup(StringPiece* s, Regexp::ParseFlags parse_flags,
-                              CharClass *cc,
+                              CharClassBuilder *cc,
                               RegexpStatus* status) {
   // Decide whether to parse.
   if (!(parse_flags & Regexp::UnicodeGroups))
     return kParseNothing;
   if (s->size() < 2 || (*s)[0] != '\\')
     return kParseNothing;
   Rune c = (*s)[1];
   if (c != 'p' && c != 'P')
     return kParseNothing;
 
@@ skipping 44 matching lines @@
     AddUGroup(cc, g, parse_flags);
   else
     AddNegatedUGroup(cc, g, parse_flags);
   return kParseOk;
 }
 
 // Parses a character class name like [:alnum:].
 // Sets *s to span the remainder of the string.
 // Adds the ranges corresponding to the class to ranges.
 static ParseStatus ParseCCName(StringPiece* s, Regexp::ParseFlags parse_flags,
-                               CharClass *cc,
+                               CharClassBuilder *cc,
                                RegexpStatus* status) {
   // Check begins with [:
   const char* p = s->data();
   const char* ep = s->data() + s->size();
   if (ep - p < 2 || p[0] != '[' || p[1] != ':')
     return kParseNothing;
 
   // Look for closing :].
   const char* q;
   for (q = p+2; q <= ep-2 && (*q != ':' || *(q+1) != ']'); q++)
@@ skipping 76 matching lines @@
                                         RegexpStatus* status) {
   StringPiece whole_class = *s;
   if (s->size() == 0 || (*s)[0] != '[') {
     // Caller checked this.
     status->set_code(kRegexpInternalError);
     status->set_error_arg(NULL);
     return false;
   }
   bool negated = false;
   Regexp* re = new Regexp(kRegexpCharClass, flags_ & ~FoldCase);
+  re->ccb_ = new CharClassBuilder;
   s->remove_prefix(1);  // '['
   if (s->size() > 0 && (*s)[0] == '^') {
     s->remove_prefix(1);  // '^'
     negated = true;
     if (!(flags_ & ClassNL) || (flags_ & NeverNL)) {
       // If NL can't match implicitly, then pretend
       // negated classes include a leading \n.
-      re->cc_->AddRange('\n', '\n');
+      re->ccb_->AddRange('\n', '\n');
     }
   }
   bool first = true;  // ] is okay as first char in class
   while (s->size() > 0 && ((*s)[0] != ']' || first)) {
     // - is only okay unescaped as first or last in class.
     // Except that Perl allows - anywhere.
     if ((*s)[0] == '-' && !first && !(flags_&PerlX) &&
         (s->size() == 1 || (*s)[1] != ']')) {
       StringPiece t = *s;
       t.remove_prefix(1);  // '-'
       Rune r;
       int n = StringPieceToRune(&r, &t, status);
       if (n < 0) {
         re->Decref();
         return false;
       }
       status->set_code(kRegexpBadCharRange);
       status->set_error_arg(StringPiece(s->data(), 1+n));
       re->Decref();
       return false;
     }
     first = false;
 
     // Look for [:alnum:] etc.
     if (s->size() > 2 && (*s)[0] == '[' && (*s)[1] == ':') {
-      switch (ParseCCName(s, flags_, re->cc_, status)) {
+      switch (ParseCCName(s, flags_, re->ccb_, status)) {
         case kParseOk:
           continue;
         case kParseError:
           re->Decref();
           return false;
         case kParseNothing:
           break;
       }
     }
 
     // Look for Unicode character group like \p{Han}
     if (s->size() > 2 &&
         (*s)[0] == '\\' &&
         ((*s)[1] == 'p' || (*s)[1] == 'P')) {
-      switch (ParseUnicodeGroup(s, flags_, re->cc_, status)) {
+      switch (ParseUnicodeGroup(s, flags_, re->ccb_, status)) {
         case kParseOk:
           continue;
         case kParseError:
           re->Decref();
           return false;
         case kParseNothing:
           break;
       }
     }
 
     // Look for Perl character class symbols (extension).
     UGroup *g = MaybeParsePerlCCEscape(s, flags_);
     if (g != NULL) {
-      AddUGroup(re->cc_, g, flags_);
+      AddUGroup(re->ccb_, g, flags_);
       continue;
     }
 
     // Otherwise assume single character or simple range.
     RuneRange rr;
     if (!ParseCCRange(s, &rr, whole_class, status)) {
       re->Decref();
       return false;
     }
     // AddRange is usually called in response to a class like
     // \p{Foo} or [[:foo:]]; for those, it filters \n out unless
     // Regexp::ClassNL is set.  In an explicit range or singleton
     // like we just parsed, we do not filter \n out, so set ClassNL
     // in the flags.
-    AddRange(re->cc_, rr.lo, rr.hi, flags_ | Regexp::ClassNL);
+    AddRange(re->ccb_, rr.lo, rr.hi, flags_ | Regexp::ClassNL);
   }
   if (s->size() == 0) {
     status->set_code(kRegexpMissingBracket);
     status->set_error_arg(whole_class);
     re->Decref();
     return false;
   }
   s->remove_prefix(1);  // ']'
 
   if (negated)
-    re->cc_->Negate();
-  re->cc_->RemoveAbove(rune_max_);
+    re->ccb_->Negate();
+  re->ccb_->RemoveAbove(rune_max_);
 
   *out_re = re;
   return true;
 }
 
 // Is this a valid capture name?  [A-Za-z0-9_]+
 // PCRE limits names to 32 bytes.
 // Python rejects names starting with digits.
 // We don't enforce either of those.
 static bool IsValidCaptureName(const StringPiece& name) {
@@ skipping 385 matching lines @@
                 return NULL;
               if (!ps.PushLiteral(r))
                 return NULL;
             }
             break;
           }
         }
 
         if (t[1] == 'p' || t[1] == 'P') {
           Regexp* re = new Regexp(kRegexpCharClass, ps.flags() & ~FoldCase);
-          switch (ParseUnicodeGroup(&t, ps.flags(), re->cc_, status)) {
+          re->ccb_ = new CharClassBuilder;
+          switch (ParseUnicodeGroup(&t, ps.flags(), re->ccb_, status)) {
             case kParseOk:
               if (!ps.PushRegexp(re))
                 return NULL;
               goto Break2;
             case kParseError:
               re->Decref();
               return NULL;
             case kParseNothing:
               re->Decref();
               break;
           }
         }
 
         UGroup *g = MaybeParsePerlCCEscape(&t, ps.flags());
         if (g != NULL) {
           Regexp* re = new Regexp(kRegexpCharClass, ps.flags() & ~FoldCase);
-          AddUGroup(re->cc_, g, ps.flags());
+          re->ccb_ = new CharClassBuilder;
+          AddUGroup(re->ccb_, g, ps.flags());
           if (!ps.PushRegexp(re))
             return NULL;
           break;
         }
 
         Rune r;
         if (!ParseEscape(&t, &r, status, ps.rune_max()))
           return NULL;
         if (!ps.PushLiteral(r))
           return NULL;
         break;
       }
     }
   Break2:
     lastunary = isunary;
   }
   return ps.DoFinish();
 }
 
 }  // namespace re2