Patch for allowing several V8 instances in process:...

src/conversions.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 82 matching lines @@
 
 static inline void ReleaseCString(const char* original, const char* str) {
 }
 
 
 static inline void ReleaseCString(String* original, const char* str) {
   DeleteArray(const_cast<char *>(str));
 }
 
 
-static inline bool IsSpace(const char* str, int index) {
+static inline bool IsSpace(const char* str, int index, V8Context* v8context) {
   ASSERT(index >= 0 && index < StrLength(str));
-  return Scanner::kIsWhiteSpace.get(str[index]);
+  return v8context->scanner_data_.kIsWhiteSpace_.get(str[index]);
 }
 
 
-static inline bool IsSpace(String* str, int index) {
-  return Scanner::kIsWhiteSpace.get(str->Get(index));
+static inline bool IsSpace(String* str, int index, V8Context* v8context) {
+  return v8context->scanner_data_.kIsWhiteSpace_.get(str->Get(index));
 }
 
 
 static inline bool SubStringEquals(const char* str,
                                    int index,
                                    const char* other) {
   return strncmp(str + index, other, strlen(other)) != 0;
 }
 
 
@@ skipping 144 matching lines @@
 // char* or a String*.
 template<class S>
 static double InternalStringToDouble(S* str,
                                      int flags,
                                      double empty_string_val) {
   double result = 0.0;
   int index = 0;
 
   int len = GetLength(str);
 
+  V8Context* const v8context = v8_context();
   // Skip leading spaces.
-  while ((index < len) && IsSpace(str, index)) index++;
+  while ((index < len) && IsSpace(str, index, v8context)) index++;
 
   // Is the string empty?
   if (index >= len) return empty_string_val;
 
   // Get the first character.
   uint16_t first = GetChar(str, index);
 
   // Numbers can only start with '-', '+', '.', 'I' (Infinity), or a digit.
   if (first != '-' && first != '+' && first != '.' && first != 'I' &&
       (first > '9' || first < '0')) {
@@ skipping 40 matching lines @@
         index++;
       if (!SubStringEquals(str, index, "Infinity"))
         return JUNK_STRING_VALUE;
       result = is_negative ? -V8_INFINITY : V8_INFINITY;
       index += 8;
     }
   }
 
   if ((flags & ALLOW_TRAILING_JUNK) == 0) {
     // skip trailing spaces
-    while ((index < len) && IsSpace(str, index)) index++;
+    while ((index < len) && IsSpace(str, index, v8context)) index++;
     // string ending with junk?
     if (index < len) return JUNK_STRING_VALUE;
   }
 
   return sign * result;
 }
 
 
 double StringToDouble(String* str, int flags, double empty_string_val) {
   return InternalStringToDouble(str, flags, empty_string_val);
 }
 
 
 double StringToDouble(const char* str, int flags, double empty_string_val) {
   return InternalStringToDouble(str, flags, empty_string_val);
 }
 
+static MutexLockAdapter mutex_lock(OS::CreateMutex());
 
 extern "C" char* dtoa(double d, int mode, int ndigits,
                       int* decpt, int* sign, char** rve);
 
 extern "C" void freedtoa(char* s);
 
 const char* DoubleToCString(double v, Vector<char> buffer) {
   StringBuilder builder(buffer.start(), buffer.length());
 
   switch (fpclassify(v)) {
     case FP_NAN:
       builder.AddString("NaN");
       break;
 
     case FP_INFINITE:
       if (v < 0.0) {
         builder.AddString("-Infinity");
       } else {
         builder.AddString("Infinity");
       }
       break;
 
     case FP_ZERO:
       builder.AddCharacter('0');
       break;
 
     default: {
       int decimal_point;
       int sign;
-
+      V8SharedStateLocker dtoa_locker(&mutex_lock);
       char* decimal_rep = dtoa(v, 0, 0, &decimal_point, &sign, NULL);
       int length = StrLength(decimal_rep);
 
       if (sign) builder.AddCharacter('-');
 
       if (length <= decimal_point && decimal_point <= 21) {
         // ECMA-262 section 9.8.1 step 6.
         builder.AddString(decimal_rep);
         builder.AddPadding('0', decimal_point - length);
 
@@ skipping 62 matching lines @@
 
   if (abs_value >= 1e21) {
     char arr[100];
     Vector<char> buffer(arr, ARRAY_SIZE(arr));
     return StrDup(DoubleToCString(value, buffer));
   }
 
   // Find a sufficiently precise decimal representation of n.
   int decimal_point;
   int sign;
+  V8SharedStateLocker dtoa_locker(&mutex_lock);
   char* decimal_rep = dtoa(abs_value, 3, f, &decimal_point, &sign, NULL);
   int decimal_rep_length = StrLength(decimal_rep);
 
   // Create a representation that is padded with zeros if needed.
   int zero_prefix_length = 0;
   int zero_postfix_length = 0;
 
   if (decimal_point <= 0) {
     zero_prefix_length = -decimal_point + 1;
     decimal_point = 1;
@@ skipping 68 matching lines @@
   bool negative = false;
   if (value < 0) {
     value = -value;
     negative = true;
   }
 
   // Find a sufficiently precise decimal representation of n.
   int decimal_point;
   int sign;
   char* decimal_rep = NULL;
+  V8SharedStateLocker dtoa_locker(&mutex_lock);
   if (f == -1) {
     decimal_rep = dtoa(value, 0, 0, &decimal_point, &sign, NULL);
     f = StrLength(decimal_rep) - 1;
   } else {
     decimal_rep = dtoa(value, 2, f + 1, &decimal_point, &sign, NULL);
   }
   int decimal_rep_length = StrLength(decimal_rep);
   ASSERT(decimal_rep_length > 0);
   ASSERT(decimal_rep_length <= f + 1);
   USE(decimal_rep_length);
@@ skipping 13 matching lines @@
 
   bool negative = false;
   if (value < 0) {
     value = -value;
     negative = true;
   }
 
   // Find a sufficiently precise decimal representation of n.
   int decimal_point;
   int sign;
+  V8SharedStateLocker dtoa_locker(&mutex_lock);
   char* decimal_rep = dtoa(value, 2, p, &decimal_point, &sign, NULL);
   int decimal_rep_length = StrLength(decimal_rep);
   ASSERT(decimal_rep_length <= p);
 
   int exponent = decimal_point - 1;
 
   char* result = NULL;
 
   if (exponent < -6 || exponent >= p) {
     result =
@@ skipping 102 matching lines @@
   // Allocate result and fill in the parts.
   StringBuilder builder(result_size + 1);
   builder.AddSubstring(integer_buffer + integer_pos + 1, integer_part_size);
   if (decimal_pos > 0) builder.AddCharacter('.');
   builder.AddSubstring(decimal_buffer, decimal_pos);
   return builder.Finalize();
 }
 
 
 } }  // namespace v8::internal