Reland regexp global optimizations.

src/unicode.h

 // Copyright 2011 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 183 matching lines @@
       unsigned& offset);
   static inline bool EncodeAsciiCharacter(uchar c, byte* buffer,
       unsigned capacity, unsigned& offset);
   static inline bool EncodeNonAsciiCharacter(uchar c, byte* buffer,
       unsigned capacity, unsigned& offset);
   static inline uchar DecodeCharacter(const byte* buffer, unsigned* offset);
   virtual void Rewind() = 0;
 
  protected:
   virtual void FillBuffer() = 0;
+  virtual bool BoundsCheck(unsigned offset) = 0;
   // The number of characters left in the current buffer
   unsigned remaining_;
   // The current offset within the buffer
   unsigned cursor_;
   // The buffer containing the decoded characters.
   const byte* buffer_;
 };
 
 // --- I n p u t   B u f f e r ---
 
 /**
  * Provides efficient access to encoded characters in strings.  It
  * does so by reading characters one block at a time, rather than one
  * character at a time, which gives string implementations an
  * opportunity to optimize the decoding.
  */
 template <class Reader, class Input = Reader*, unsigned kSize = 256>
 class InputBuffer : public CharacterStream {
  public:
   virtual void Rewind();
   inline void Reset(Input input);
   void Seek(unsigned position);
   inline void Reset(unsigned position, Input input);
  protected:
   InputBuffer() { }
   explicit InputBuffer(Input input) { Reset(input); }
   virtual void FillBuffer();
+  virtual bool BoundsCheck(unsigned offset) {
+    return (buffer_ != util_buffer_) || (offset < kSize);
+  }
 
   // A custom offset that can be used by the string implementation to
   // mark progress within the encoded string.
   unsigned offset_;
   // The input string
   Input input_;
   // To avoid heap allocation, we keep an internal buffer to which
   // the encoded string can write its characters.  The string
   // implementation is free to decide whether it wants to use this
   // buffer or not.
@@ skipping 73 matching lines @@
   static const int kMaxWidth = 1;
   static int Convert(uchar c,
                      uchar n,
                      uchar* result,
                      bool* allow_caching_ptr);
 };
 
 }  // namespace unibrow
 
 #endif  // V8_UNICODE_H_