[Isolates] Pass current isolate address to the regexp native functions

src/v8.cc

 // Copyright 2006-2009 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 85 matching lines @@
 
 
 static uint32_t random_seed() {
   if (FLAG_random_seed == 0) {
     return random();
   }
   return FLAG_random_seed;
 }
 
 
-uint32_t V8::Random() {
+uint32_t V8::Random(Isolate* isolate) {
+  ASSERT(isolate == Isolate::Current());
+  // TODO(isolates): move lo and hi to isolate
   // Random number generator using George Marsaglia's MWC algorithm.
   static uint32_t hi = 0;
   static uint32_t lo = 0;
 
   // Initialize seed using the system random(). If one of the seeds
   // should ever become zero again, or if random() returns zero, we
   // avoid getting stuck with zero bits in hi or lo by re-initializing
   // them on demand.
   if (hi == 0) hi = random_seed();
   if (lo == 0) lo = random_seed();
@@ skipping 16 matching lines @@
 
 
 // Use a union type to avoid type-aliasing optimizations in GCC.
 typedef union {
   double double_value;
   uint64_t uint64_t_value;
 } double_int_union;
 
 
 Object* V8::FillHeapNumberWithRandom(Object* heap_number) {
-  uint64_t random_bits = Random();
+  uint64_t random_bits = Random(Isolate::Current());
   // Make a double* from address (heap_number + sizeof(double)).
   double_int_union* r = reinterpret_cast<double_int_union*>(
       reinterpret_cast<char*>(heap_number) +
       HeapNumber::kValueOffset - kHeapObjectTag);
   // Convert 32 random bits to 0.(32 random bits) in a double
   // by computing:
   // ( 1.(20 0s)(32 random bits) x 2^20 ) - (1.0 x 2^20)).
   const double binary_million = 1048576.0;
   r->double_value = binary_million;
   r->uint64_t_value |=  random_bits;
   r->double_value -= binary_million;
 
   return heap_number;
 }
 
 } }  // namespace v8::internal