Add v8::jscre namespace around jscre functions to avoid link errors with jsc ...

src/jsregexp.cc

 // 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 360 matching lines @@
                                           Handle<FixedArray> irregexp_data) {
   Factory::SetRegExpData(re, JSRegExp::IRREGEXP, pattern, flags, irregexp_data);
   return re;
 }
 
 
 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;
   } else {
     // It doesn't matter which object we return here, we just need to return
     // a non-failure to indicate to the GC-retry code that there was no
     // allocation failure.
     return pattern;
   }
 }
 
 
 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,
                                     error_message,
                                     code));
 }
 
 
 Handle<Object> RegExpImpl::JscreCompile(Handle<JSRegExp> re) {
   ASSERT_EQ(re->TypeTag(), JSRegExp::JSCRE);
   ASSERT(re->DataAt(JSRegExp::kJscreDataIndex)->IsUndefined());
 
   Handle<String> pattern(re->Pattern());
   JSRegExp::Flags flags = re->GetFlags();
 
   Handle<String> two_byte_pattern = StringToTwoByte(pattern);
 
   unsigned number_of_captures;
   const char* error_message = NULL;
 
-  JscreRegExp* code = NULL;
+  v8::jscre::JscreRegExp* code = NULL;
   FlattenString(pattern);
 
   CompileWithRetryAfterGC(two_byte_pattern,
                           flags,
                           &number_of_captures,
                           &error_message,
                           &code);
 
   if (code == NULL) {
     // Throw an exception.
@@ skipping 107 matching lines @@
                                          int num_captures,
                                          Handle<String> subject,
                                          int previous_index,
                                          const uc16* two_byte_subject,
                                          int* offsets_vector,
                                          int offsets_vector_length) {
   int rc;
   {
     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();
   }
 
   // Other JSRE errors:
   if (rc < 0) {
     // Throw an exception.
     Handle<Object> code(Smi::FromInt(rc));
     Handle<Object> args[2] = { Factory::LookupAsciiSymbol("jsre_exec"), code };
     Handle<Object> regexp_err(
         Factory::NewTypeError("jsre_error", HandleVector(args, 2)));
@@ skipping 2006 matching lines @@
   byte codes[1024];
   IrregexpAssembler assembler(Vector<byte>(codes, 1024));
   RegExpMacroAssemblerIrregexp macro_assembler(&assembler);
   return compiler.Assemble(&macro_assembler,
                            node,
                            input->capture_count);
 }
 
 
 }}  // namespace v8::internal