Add v8::jscre namespace around jscre functions to avoid link errors with jsc pcre files in Chrome.

Review URL: http://codereview.chromium.org/12496

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@849 ce2b1a6d-e550-0410-aec6-3dcde31c8c00

src/jsregexp.cc

@@ -378,23 +378,23 @@ static inline Object* DoCompile(String* pattern,
                                 JSRegExp::Flags flags,
                                 unsigned* number_of_captures,
                                 const char** error_message,
-                                JscreRegExp** code) {
-  JSRegExpIgnoreCaseOption case_option = flags.is_ignore_case()
-    ? JSRegExpIgnoreCase
-    : JSRegExpDoNotIgnoreCase;
-  JSRegExpMultilineOption multiline_option = flags.is_multiline()
-    ? JSRegExpMultiline
-    : JSRegExpSingleLine;
+                                v8::jscre::JscreRegExp** code) {
+  v8::jscre::JSRegExpIgnoreCaseOption case_option = flags.is_ignore_case()
+    ? v8::jscre::JSRegExpIgnoreCase
+    : v8::jscre::JSRegExpDoNotIgnoreCase;
+  v8::jscre::JSRegExpMultilineOption multiline_option = flags.is_multiline()
+    ? v8::jscre::JSRegExpMultiline
+    : v8::jscre::JSRegExpSingleLine;
   *error_message = NULL;
   malloc_failure = Failure::Exception();
-  *code = jsRegExpCompile(pattern->GetTwoByteData(),
-                          pattern->length(),
-                          case_option,
-                          multiline_option,
-                          number_of_captures,
-                          error_message,
-                          &JSREMalloc,
-                          &JSREFree);
+  *code = v8::jscre::jsRegExpCompile(pattern->GetTwoByteData(),
+                                     pattern->length(),
+                                     case_option,
+                                     multiline_option,
+                                     number_of_captures,
+                                     error_message,
+                                     &JSREMalloc,
+                                     &JSREFree);
   if (*code == NULL && (malloc_failure->IsRetryAfterGC() ||
                        malloc_failure->IsOutOfMemoryFailure())) {
     return malloc_failure;
@@ -411,7 +411,7 @@ void CompileWithRetryAfterGC(Handle<String> pattern,
                              JSRegExp::Flags flags,
                              unsigned* number_of_captures,
                              const char** error_message,
-                             JscreRegExp** code) {
+                             v8::jscre::JscreRegExp** code) {
   CALL_HEAP_FUNCTION_VOID(DoCompile(*pattern,
                                     flags,
                                     number_of_captures,
@@ -432,7 +432,7 @@ Handle<Object> RegExpImpl::JscreCompile(Handle<JSRegExp> re) {
   unsigned number_of_captures;
   const char* error_message = NULL;
 
-  JscreRegExp* code = NULL;
+  v8::jscre::JscreRegExp* code = NULL;
   FlattenString(pattern);
 
   CompileWithRetryAfterGC(two_byte_pattern,
@@ -560,23 +560,24 @@ Handle<Object> RegExpImpl::JscreExecOnce(Handle<JSRegExp> regexp,
   {
     AssertNoAllocation a;
     ByteArray* internal = JscreInternal(regexp);
-    const JscreRegExp* js_regexp =
-        reinterpret_cast<JscreRegExp*>(internal->GetDataStartAddress());
+    const v8::jscre::JscreRegExp* js_regexp =
+        reinterpret_cast<v8::jscre::JscreRegExp*>(
+            internal->GetDataStartAddress());
 
     LOG(RegExpExecEvent(regexp, previous_index, subject));
 
-    rc = jsRegExpExecute(js_regexp,
-                         two_byte_subject,
-                         subject->length(),
-                         previous_index,
-                         offsets_vector,
-                         offsets_vector_length);
+    rc = v8::jscre::jsRegExpExecute(js_regexp,
+                                    two_byte_subject,
+                                    subject->length(),
+                                    previous_index,
+                                    offsets_vector,
+                                    offsets_vector_length);
   }
 
   // The KJS JavaScript engine returns null (ie, a failed match) when
   // JSRE's internal match limit is exceeded.  We duplicate that behavior here.
-  if (rc == JSRegExpErrorNoMatch
-      || rc == JSRegExpErrorHitLimit) {
+  if (rc == v8::jscre::JSRegExpErrorNoMatch
+      || rc == v8::jscre::JSRegExpErrorHitLimit) {
     return Factory::null_value();
   }
 

src/third_party/jscre/pcre.h

@@ -49,6 +49,8 @@ POSSIBILITY OF SUCH DAMAGE.
 // we allow DEBUG to be set and undef it manually.
 #undef DEBUG
 
+namespace v8 { namespace jscre {
+
 typedef uint16_t UChar;
 
 struct JSRegExp;
@@ -77,4 +79,6 @@ int jsRegExpExecute(const JSRegExp*,
 
 void jsRegExpFree(JSRegExp*);
 
+} }  // namespace v8::jscre
+
 #endif

src/third_party/jscre/pcre_compile.cpp

@@ -65,6 +65,8 @@ compile time. */
 
 #define BRASTACK_SIZE 200
 
+namespace v8 { namespace jscre {
+
 /* Table for handling escaped characters in the range '0'-'z'. Positive returns
 are simple data values; negative values are for special things like \d and so
 on. Zero means further processing is needed (for things like \x), or the escape
@@ -2671,3 +2673,5 @@ void jsRegExpFree(JSRegExp* re, free_t* free_function)
 {
     (*free_function)(reinterpret_cast<void*>(re));
 }
+
+} }  // namespace v8::jscre

src/third_party/jscre/pcre_exec.cpp

@@ -61,6 +61,8 @@ the JavaScript specification. There are also some supporting functions. */
 #undef min
 #undef max
 
+namespace v8 { namespace jscre {
+
 #ifndef USE_COMPUTED_GOTO_FOR_MATCH_RECURSION
 typedef int ReturnLocation;
 #else
@@ -2079,3 +2081,5 @@ int jsRegExpExecute(const JSRegExp* re,
     DPRINTF((">>>> returning PCRE_ERROR_NOMATCH\n"));
     return JSRegExpErrorNoMatch;
 }
+
+} }  // namespace v8::jscre

src/third_party/jscre/pcre_internal.h

@@ -103,6 +103,8 @@ all, it had only been about 10 years then... */
 #define DPRINTF(p) /*nothing*/
 #endif
 
+namespace v8 { namespace jscre {
+
 /* PCRE keeps offsets in its compiled code as 2-byte quantities (always stored
 in big-endian order) by default. These are used, for example, to link from the
 start of a subpattern to its alternatives and its end. The use of 2 bytes per
@@ -416,6 +418,7 @@ but are not part of the public API and so not exported from the library. */
 extern int kjs_pcre_ucp_othercase(unsigned);
 extern bool kjs_pcre_xclass(int, const unsigned char*);
 
+} }  // namespace v8::jscre
 #endif
 
 #endif

src/third_party/jscre/pcre_tables.cpp

@@ -42,6 +42,8 @@ PCRE code modules. */
 
 #include "pcre_internal.h"
 
+namespace v8 { namespace jscre {
+
 /*************************************************
 *           Tables for UTF-8 support             *
 *************************************************/
@@ -69,3 +71,5 @@ const unsigned char kjs_pcre_utf8_table4[0x40] = {
   3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5 };
 
 #include "pcre_chartables.c"
+
+} }  // namespace v8::jscre

src/third_party/jscre/pcre_ucp_searchfuncs.cpp

@@ -46,6 +46,8 @@ properties. */
 #include "ucpinternal.h"       /* Internal table details */
 #include "ucptable.cpp"        /* The table itself */
 
+namespace v8 { namespace jscre {
+
 /*************************************************
 *       Search table and return other case       *
 *************************************************/
@@ -96,3 +98,5 @@ int kjs_pcre_ucp_othercase(unsigned c)
         offset |= f1_caseneg;
     return !offset ? -1 : c + offset;
 }
+
+} }  // namespace v8::jscre

src/third_party/jscre/pcre_xclass.cpp

@@ -42,6 +42,8 @@ class (one that contains characters whose values are > 255). */
 
 #include "pcre_internal.h"
 
+namespace v8 { namespace jscre {
+
 /*************************************************
 *       Match character against an XCLASS        *
 *************************************************/
@@ -112,3 +114,5 @@ bool kjs_pcre_xclass(int c, const unsigned char* data)
     
     return negated;   /* char did not match */
 }
+
+} }  // namespace v8::jscre