Remove JSCRE

src/jsregexp.h

 // Copyright 2006-2008 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 49 matching lines @@
   static Handle<Object> Exec(Handle<JSRegExp> regexp,
                              Handle<String> subject,
                              Handle<Object> index);
 
   // Call RegExp.prototyp.exec(string) in a loop.
   // Used by String.prototype.match and String.prototype.replace.
   // This function calls the garbage collector if necessary.
   static Handle<Object> ExecGlobal(Handle<JSRegExp> regexp,
                                    Handle<String> subject);
 
-  // Stores an uncompiled RegExp pattern in the JSRegExp object.
-  // It will be compiled by JSCRE when first executed.
-  static Handle<Object> JscrePrepare(Handle<JSRegExp> re,
-                                     Handle<String> pattern,
-                                     JSRegExp::Flags flags);
-
   // Prepares a JSRegExp object with Irregexp-specific data.
   static Handle<Object> IrregexpPrepare(Handle<JSRegExp> re,
                                         Handle<String> pattern,
                                         JSRegExp::Flags flags);
 
 
-  // Compile the pattern using JSCRE and store the result in the
-  // JSRegExp object.
-  static Handle<Object> JscreCompile(Handle<JSRegExp> re);
-
   static Handle<Object> AtomCompile(Handle<JSRegExp> re,
                                     Handle<String> pattern,
                                     JSRegExp::Flags flags,
                                     Handle<String> match_pattern);
   static Handle<Object> AtomExec(Handle<JSRegExp> regexp,
                                  Handle<String> subject,
                                  Handle<Object> index);
 
   static Handle<Object> AtomExecGlobal(Handle<JSRegExp> regexp,
                                        Handle<String> subject);
 
-  static Handle<Object> JscreCompile(Handle<JSRegExp> re,
-                                     Handle<String> pattern,
-                                     JSRegExp::Flags flags);
-
-  // Execute a compiled JSCRE pattern.
-  static Handle<Object> JscreExec(Handle<JSRegExp> regexp,
-                                  Handle<String> subject,
-                                  Handle<Object> index);
-
   // Execute an Irregexp bytecode pattern.
   static Handle<Object> IrregexpExec(Handle<JSRegExp> regexp,
                                      Handle<String> subject,
                                      Handle<Object> index);
 
-  static Handle<Object> JscreExecGlobal(Handle<JSRegExp> regexp,
-                                        Handle<String> subject);
-
   static Handle<Object> IrregexpExecGlobal(Handle<JSRegExp> regexp,
                                            Handle<String> subject);
 
   static void NewSpaceCollectionPrologue();
   static void OldSpaceCollectionPrologue();
 
   // Converts a source string to a 16 bit flat string.  The string
   // will be either sequential or it will be a SlicedString backed
   // by a flat string.
   static Handle<String> StringToTwoByte(Handle<String> pattern);
   static Handle<String> CachedStringToTwoByte(Handle<String> pattern);
 
   static const int kIrregexpImplementationIndex = 0;
   static const int kIrregexpNumberOfCapturesIndex = 1;
   static const int kIrregexpNumberOfRegistersIndex = 2;
   static const int kIrregexpCodeIndex = 3;
   static const int kIrregexpDataLength = 4;
 
-  static const int kJscreNumberOfCapturesIndex = 0;
-  static const int kJscreInternalIndex = 1;
-  static const int kJscreDataLength = 2;
-
  private:
   static String* last_ascii_string_;
   static String* two_byte_cached_string_;
 
-  static int JscreNumberOfCaptures(Handle<JSRegExp> re);
-  static ByteArray* JscreInternal(Handle<JSRegExp> re);
-
   static int IrregexpNumberOfCaptures(Handle<FixedArray> re);
   static int IrregexpNumberOfRegisters(Handle<FixedArray> re);
   static Handle<ByteArray> IrregexpByteCode(Handle<FixedArray> re);
   static Handle<Code> IrregexpNativeCode(Handle<FixedArray> re);
 
-  // Call jsRegExpExecute once
-  static Handle<Object> JscreExecOnce(Handle<JSRegExp> regexp,
-                                      int num_captures,
-                                      Handle<String> subject,
-                                      int previous_index,
-                                      const uc16* utf8_subject,
-                                      int* ovector,
-                                      int ovector_length);
-
   // On a successful match, the result is a JSArray containing
   // captured positions. On a failure, the result is the null value.
   // Returns an empty handle in case of an exception.
   static Handle<Object> IrregexpExecOnce(Handle<FixedArray> regexp,
                                          int num_captures,
                                          Handle<String> subject16,
                                          int previous_index,
                                          int* ovector,
                                          int ovector_length);
 
@@ skipping 1196 matching lines @@
                                     Handle<String> pattern,
                                     bool is_ascii);
 
   static void DotPrint(const char* label, RegExpNode* node, bool ignore_case);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_JSREGEXP_H_