Limit recursion depth for gathering BoyerMoore info.

src/jsregexp.h

 // Copyright 2012 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 167 matching lines @@
   static int IrregexpNumberOfRegisters(FixedArray* re);
   static ByteArray* IrregexpByteCode(FixedArray* re, bool is_ascii);
   static Code* IrregexpNativeCode(FixedArray* re, bool is_ascii);
 
   // Limit the space regexps take up on the heap.  In order to limit this we
   // would like to keep track of the amount of regexp code on the heap.  This
   // is not tracked, however.  As a conservative approximation we track the
   // total regexp code compiled including code that has subsequently been freed
   // and the total executable memory at any point.
   static const int kRegExpExecutableMemoryLimit = 16 * MB;
-  static const int kRegWxpCompiledLimit = 1 * MB;
+  static const int kRegExpCompiledLimit = 1 * MB;
 
  private:
   static String* last_ascii_string_;
   static String* two_byte_cached_string_;
 
   static bool CompileIrregexp(
       Handle<JSRegExp> re, Handle<String> sample_subject, bool is_ascii);
   static inline bool EnsureCompiledIrregexp(
       Handle<JSRegExp> re, Handle<String> sample_subject, bool is_ascii);
 
@@ skipping 1030 matching lines @@
 
   void SetAll(int map_number) {
     bitmaps_->at(map_number)->SetAll();
   }
 
   void SetRest(int from_map) {
     for (int i = from_map; i < length_; i++) SetAll(i);
   }
   bool EmitSkipInstructions(RegExpMacroAssembler* masm);
 
+  bool MaxDepthExceeded() {
+    return (++depth_ > kMaxFillInDepth);
+  }
+
+  static const int kMaxFillInDepth = 1024;
+
  private:
   // This is the value obtained by EatsAtLeast.  If we do not have at least this
   // many characters left in the sample string then the match is bound to fail.
   // Therefore it is OK to read a character this far ahead of the current match
   // point.
   int length_;
   RegExpCompiler* compiler_;
+  int depth_;
   // 0x7f for ASCII, 0xffff for UTF-16.
   int max_char_;
   ZoneList<BoyerMoorePositionInfo*>* bitmaps_;
 
   int GetSkipTable(int min_lookahead,
                    int max_lookahead,
                    Handle<ByteArray> boolean_skip_table);
   bool FindWorthwhileInterval(int* from, int* to);
   int FindBestInterval(
     int max_number_of_chars, int old_biggest_points, int* from, int* to);
@@ skipping 327 matching lines @@
   int* vector_;
   int offsets_vector_length_;
 
   friend class ExternalReference;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_JSREGEXP_H_