Patch for allowing several V8 instances in process:...

src/jsregexp.cc

 // Copyright 2006-2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 101 matching lines @@
 // Generic RegExp methods. Dispatches to implementation specific methods.
 
 
 class OffsetsVector {
  public:
   inline OffsetsVector(int num_registers)
       : offsets_vector_length_(num_registers) {
     if (offsets_vector_length_ > kStaticOffsetsVectorSize) {
       vector_ = NewArray<int>(offsets_vector_length_);
     } else {
-      vector_ = static_offsets_vector_;
+      int* & static_offsets_vector =
+        v8_context()->reg_exp_stack_data_.static_offsets_vector_;
+      if (!static_offsets_vector)
+        static_offsets_vector = new int[kStaticOffsetsVectorSize];
+      vector_ = static_offsets_vector;
     }
   }
   inline ~OffsetsVector() {
     if (offsets_vector_length_ > kStaticOffsetsVectorSize) {
       DeleteArray(vector_);
       vector_ = NULL;
     }
   }
   inline int* vector() { return vector_; }
   inline int length() { return offsets_vector_length_; }
 
  private:
   int* vector_;
   int offsets_vector_length_;
   static const int kStaticOffsetsVectorSize = 50;
-  static int static_offsets_vector_[kStaticOffsetsVectorSize];
 };
 
-
-int OffsetsVector::static_offsets_vector_[
-    OffsetsVector::kStaticOffsetsVectorSize];
-
-
 Handle<Object> RegExpImpl::Compile(Handle<JSRegExp> re,
                                    Handle<String> pattern,
                                    Handle<String> flag_str) {
   JSRegExp::Flags flags = RegExpFlagsFromString(flag_str);
   Handle<FixedArray> cached = CompilationCache::LookupRegExp(pattern, flags);
   bool in_cache = !cached.is_null();
   LOG(RegExpCompileEvent(re, in_cache));
 
   Handle<Object> result;
   if (in_cache) {
@@ skipping 1084 matching lines @@
       break;
     case Guard::GEQ:
       ASSERT(!trace->mentions_reg(guard->reg()));
       macro_assembler->IfRegisterLT(guard->reg(),
                                     guard->value(),
                                     trace->backtrack());
       break;
   }
 }
 
-
-static unibrow::Mapping<unibrow::Ecma262UnCanonicalize> uncanonicalize;
-static unibrow::Mapping<unibrow::CanonicalizationRange> canonrange;
-
-
 // Returns the number of characters in the equivalence class, omitting those
 // that cannot occur in the source string because it is ASCII.
 static int GetCaseIndependentLetters(uc16 character,
                                      bool ascii_subject,
                                      unibrow::uchar* letters) {
-  int length = uncanonicalize.get(character, '\0', letters);
+  int length = v8_context()->reg_exp_stack_data_.uncanonicalize_.get(
+    character, '\0', letters);
   // Unibrow returns 0 or 1 for characters where case independependence is
   // trivial.
   if (length == 0) {
     letters[0] = character;
     length = 1;
   }
   if (!ascii_subject || character <= String::kMaxAsciiCharCode) {
     return length;
   }
   // The standard requires that non-ASCII characters cannot have ASCII
@@ skipping 2644 matching lines @@
 }
 
 
 static void AddUncanonicals(ZoneList<CharacterRange>* ranges,
                             int bottom,
                             int top);
 
 
 void CharacterRange::AddCaseEquivalents(ZoneList<CharacterRange>* ranges,
                                         bool is_ascii) {
+  unibrow::Mapping<unibrow::Ecma262UnCanonicalize>& uncanonicalize =
+    v8_context()->reg_exp_stack_data_.uncanonicalize_;
   uc16 bottom = from();
   uc16 top = to();
   if (is_ascii) {
     if (bottom > String::kMaxAsciiCharCode) return;
     if (top > String::kMaxAsciiCharCode) top = String::kMaxAsciiCharCode;
   }
   unibrow::uchar chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
   if (top == bottom) {
     // If this is a singleton we just expand the one character.
     int length = uncanonicalize.get(bottom, '\0', chars);
@@ skipping 16 matching lines @@
     // because 'a' uncanonicalizes to ['a', 'A'] and the k'th letter
     // uncanonicalizes to ['a' + k, 'A' + k].
     // Once we've found the start point we look up its uncanonicalization
     // and produce a range for each element.  For instance for [c-f]
     // we look up ['a', 'A'] and produce [c-f] and [C-F].  We then only
     // add a range if it is not already contained in the input, so [c-f]
     // will be skipped but [C-F] will be added.  If this range is not
     // completely contained in a block we do this for all the blocks
     // covered by the range.
     unibrow::uchar range[unibrow::Ecma262UnCanonicalize::kMaxWidth];
+    unibrow::Mapping<unibrow::CanonicalizationRange>& canonrange =
+      v8_context()->reg_exp_stack_data_.canonrange_;
     // First, look up the block that contains the 'bottom' character.
     int length = canonrange.get(bottom, '\0', range);
     if (length == 0) {
       range[0] = bottom;
     } else {
       ASSERT_EQ(1, length);
     }
     int pos = bottom;
     // The start of the current block.  Note that except for the first
     // iteration 'start' is always equal to 'pos'.
@@ skipping 76 matching lines @@
   // Split up very large ranges.  This helps remove ranges where there are no
   // case mappings.
   for (int i = 0; i < boundary_count; i++) {
     if (bottom < boundaries[i] && top >= boundaries[i]) {
       AddUncanonicals(ranges, bottom, boundaries[i] - 1);
       AddUncanonicals(ranges, boundaries[i], top);
       return;
     }
   }
 
+  unibrow::Mapping<unibrow::Ecma262UnCanonicalize>& uncanonicalize  =
+    v8_context()->reg_exp_stack_data_.uncanonicalize_;
+
   // If we are completely in a zone with no case mappings then we are done.
   // We start at 2 so as not to except the ASCII range from mappings.
   for (int i = kFirstRealCaselessZoneIndex; i < boundary_count; i += 2) {
     if (bottom >= boundaries[i] && top < boundaries[i + 1]) {
 #ifdef DEBUG
       for (int j = bottom; j <= top; j++) {
         unsigned current_char = j;
         int length = uncanonicalize.get(current_char, '\0', chars);
         for (int k = 0; k < length; k++) {
           ASSERT(chars[k] == current_char);
@@ skipping 533 matching lines @@
   RegExpMacroAssemblerIrregexp macro_assembler(codes);
 #endif
 
   return compiler.Assemble(&macro_assembler,
                            node,
                            data->capture_count,
                            pattern);
 }
 
 }}  // namespace v8::internal