Revert r12990 and r12991 from trunk.

src/d8.cc

 // Copyright 2012 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 @@
 #if !defined(_WIN32) && !defined(_WIN64)
 #include <unistd.h>  // NOLINT
 #endif
 
 #ifndef ASSERT
 #define ASSERT(condition) assert(condition)
 #endif
 
 namespace v8 {
 
-
-static Handle<Value> Throw(const char* message) {
-  return ThrowException(String::New(message));
-}
-
-
-// TODO(rossberg): should replace these by proper uses of HasInstance,
-// once we figure out a good way to make the templates global.
-const char kArrayBufferMarkerPropName[] = "d8::_is_array_buffer_";
-const char kArrayMarkerPropName[] = "d8::_is_typed_array_";
-
-
-namespace Symbols {
-#define FOR_EACH_SYMBOL(V) \
-  V(ArrayBuffer, "ArrayBuffer") \
-  V(ArrayBufferMarkerPropName, kArrayBufferMarkerPropName) \
-  V(ArrayMarkerPropName, kArrayMarkerPropName) \
-  V(buffer, "buffer") \
-  V(byteLength, "byteLength") \
-  V(byteOffset, "byteOffset") \
-  V(BYTES_PER_ELEMENT, "BYTES_PER_ELEMENT")  \
-  V(length, "length")
-
-#define DEFINE_SYMBOL(name, value) Persistent<String> name;
-FOR_EACH_SYMBOL(DEFINE_SYMBOL)
-#undef DEFINE_SYMBOL
-
-void Initialize() {
-  HandleScope scope;
-#define INIT_SYMBOL(name, value) \
-  name = Persistent<String>::New(String::NewSymbol(value));
-FOR_EACH_SYMBOL(INIT_SYMBOL)
-#undef INIT_SYMBOL
-}
-
-void TearDown() {
-#define DISPOSE_SYMBOL(name, value) name.Dispose();
-  FOR_EACH_SYMBOL(DISPOSE_SYMBOL)
-#undef DISPOSE_SYMBOL
-}
-}
-
-
 LineEditor *LineEditor::first_ = NULL;
 
 
 LineEditor::LineEditor(Type type, const char* name)
     : type_(type),
       name_(name),
       next_(first_) {
   first_ = this;
 }
 
@@ skipping 145 matching lines @@
 
 Handle<Value> Shell::DisableProfiler(const Arguments& args) {
   V8::PauseProfiler();
   return Undefined();
 }
 
 
 Handle<Value> Shell::Read(const Arguments& args) {
   String::Utf8Value file(args[0]);
   if (*file == NULL) {
-    return Throw("Error loading file");
+    return ThrowException(String::New("Error loading file"));
   }
   Handle<String> source = ReadFile(*file);
   if (source.IsEmpty()) {
-    return Throw("Error loading file");
+    return ThrowException(String::New("Error loading file"));
   }
   return source;
 }
 
 
 Handle<String> Shell::ReadFromStdin() {
   static const int kBufferSize = 256;
   char buffer[kBufferSize];
   Handle<String> accumulator = String::New("");
   int length;
@@ skipping 20 matching lines @@
     }
   }
 }
 
 
 Handle<Value> Shell::Load(const Arguments& args) {
   for (int i = 0; i < args.Length(); i++) {
     HandleScope handle_scope;
     String::Utf8Value file(args[i]);
     if (*file == NULL) {
-      return Throw("Error loading file");
+      return ThrowException(String::New("Error loading file"));
     }
     Handle<String> source = ReadFile(*file);
     if (source.IsEmpty()) {
-      return Throw("Error loading file");
+      return ThrowException(String::New("Error loading file"));
     }
     if (!ExecuteString(source, String::New(*file), false, true)) {
-      return Throw("Error executing file");
+      return ThrowException(String::New("Error executing file"));
     }
   }
   return Undefined();
 }
 
 static int32_t convertToInt(Local<Value> value_in, TryCatch* try_catch) {
   if (value_in->IsInt32()) {
     return value_in->Int32Value();
   }
 
   Local<Value> number = value_in->ToNumber();
   if (try_catch->HasCaught()) return 0;
 
   ASSERT(number->IsNumber());
   Local<Int32> int32 = number->ToInt32();
   if (try_catch->HasCaught() || int32.IsEmpty()) return 0;
 
   int32_t value = int32->Int32Value();
   if (try_catch->HasCaught()) return 0;
 
   return value;
 }
 
 
 static int32_t convertToUint(Local<Value> value_in, TryCatch* try_catch) {
   int32_t raw_value = convertToInt(value_in, try_catch);
   if (try_catch->HasCaught()) return 0;
 
   if (raw_value < 0) {
-    Throw("Array length must not be negative.");
+    ThrowException(String::New("Array length must not be negative."));
     return 0;
   }
 
   static const int kMaxLength = 0x3fffffff;
 #ifndef V8_SHARED
   ASSERT(kMaxLength == i::ExternalArray::kMaxLength);
 #endif  // V8_SHARED
   if (raw_value > static_cast<int32_t>(kMaxLength)) {
-    Throw("Array length exceeds maximum length.");
+    ThrowException(
+        String::New("Array length exceeds maximum length."));
   }
   return raw_value;
 }
 
 
+// TODO(rossberg): should replace these by proper uses of HasInstance,
+// once we figure out a good way to make the templates global.
+const char kArrayBufferMarkerPropName[] = "d8::_is_array_buffer_";
+const char kArrayMarkerPropName[] = "d8::_is_typed_array_";
+
+
 Handle<Value> Shell::CreateExternalArrayBuffer(Handle<Object> buffer,
                                                int32_t length) {
   static const int32_t kMaxSize = 0x7fffffff;
   // Make sure the total size fits into a (signed) int.
   if (length < 0 || length > kMaxSize) {
-    return Throw("ArrayBuffer exceeds maximum size (2G)");
+    return ThrowException(String::New("ArrayBuffer exceeds maximum size (2G)"));
   }
   uint8_t* data = new uint8_t[length];
   if (data == NULL) {
-    return Throw("Memory allocation failed");
+    return ThrowException(String::New("Memory allocation failed"));
   }
   memset(data, 0, length);
 
-  buffer->SetHiddenValue(Symbols::ArrayBufferMarkerPropName, True());
+  buffer->SetHiddenValue(String::New(kArrayBufferMarkerPropName), True());
   Persistent<Object> persistent_array = Persistent<Object>::New(buffer);
   persistent_array.MakeWeak(data, ExternalArrayWeakCallback);
   persistent_array.MarkIndependent();
   V8::AdjustAmountOfExternalAllocatedMemory(length);
 
   buffer->SetIndexedPropertiesToExternalArrayData(
       data, v8::kExternalByteArray, length);
-  buffer->Set(Symbols::byteLength, Int32::New(length), ReadOnly);
+  buffer->Set(String::New("byteLength"), Int32::New(length), ReadOnly);
 
   return buffer;
 }
 
 
 Handle<Value> Shell::ArrayBuffer(const Arguments& args) {
   if (!args.IsConstructCall()) {
     Handle<Value>* rec_args = new Handle<Value>[args.Length()];
     for (int i = 0; i < args.Length(); ++i) rec_args[i] = args[i];
     Handle<Value> result = args.Callee()->NewInstance(args.Length(), rec_args);
     delete[] rec_args;
     return result;
   }
 
   if (args.Length() == 0) {
-    return Throw("ArrayBuffer constructor must have one argument");
+    return ThrowException(
+        String::New("ArrayBuffer constructor must have one argument"));
   }
   TryCatch try_catch;
   int32_t length = convertToUint(args[0], &try_catch);
   if (try_catch.HasCaught()) return try_catch.ReThrow();
 
   return CreateExternalArrayBuffer(args.This(), length);
 }
 
 
 Handle<Object> Shell::CreateExternalArray(Handle<Object> array,
                                           Handle<Object> buffer,
                                           ExternalArrayType type,
                                           int32_t length,
                                           int32_t byteLength,
                                           int32_t byteOffset,
                                           int32_t element_size) {
   ASSERT(element_size == 1 || element_size == 2 ||
          element_size == 4 || element_size == 8);
   ASSERT(byteLength == length * element_size);
 
   void* data = buffer->GetIndexedPropertiesExternalArrayData();
   ASSERT(data != NULL);
 
   array->SetIndexedPropertiesToExternalArrayData(
       static_cast<uint8_t*>(data) + byteOffset, type, length);
-  array->SetHiddenValue(Symbols::ArrayMarkerPropName, Int32::New(type));
-  array->Set(Symbols::byteLength, Int32::New(byteLength), ReadOnly);
-  array->Set(Symbols::byteOffset, Int32::New(byteOffset), ReadOnly);
-  array->Set(Symbols::length, Int32::New(length), ReadOnly);
-  array->Set(Symbols::BYTES_PER_ELEMENT, Int32::New(element_size));
-  array->Set(Symbols::buffer, buffer, ReadOnly);
+  array->SetHiddenValue(String::New(kArrayMarkerPropName), Int32::New(type));
+  array->Set(String::New("byteLength"), Int32::New(byteLength), ReadOnly);
+  array->Set(String::New("byteOffset"), Int32::New(byteOffset), ReadOnly);
+  array->Set(String::New("length"), Int32::New(length), ReadOnly);
+  array->Set(String::New("BYTES_PER_ELEMENT"), Int32::New(element_size));
+  array->Set(String::New("buffer"), buffer, ReadOnly);
 
   return array;
 }
 
 
 Handle<Value> Shell::CreateExternalArray(const Arguments& args,
                                          ExternalArrayType type,
                                          int32_t element_size) {
   if (!args.IsConstructCall()) {
     Handle<Value>* rec_args = new Handle<Value>[args.Length()];
@@ skipping 13 matching lines @@
   //   TypedArray(TypedArray array)
   //   TypedArray(ArrayBuffer buffer,
   //              optional unsigned long byteOffset,
   //              optional unsigned long length)
   Handle<Object> buffer;
   int32_t length;
   int32_t byteLength;
   int32_t byteOffset;
   bool init_from_array = false;
   if (args.Length() == 0) {
-    return Throw("Array constructor must have at least one argument");
+    return ThrowException(
+        String::New("Array constructor must have at least one argument"));
   }
   if (args[0]->IsObject() &&
       !args[0]->ToObject()->GetHiddenValue(
-          Symbols::ArrayBufferMarkerPropName).IsEmpty()) {
+          String::New(kArrayBufferMarkerPropName)).IsEmpty()) {
     // Construct from ArrayBuffer.
     buffer = args[0]->ToObject();
     int32_t bufferLength =
-        convertToUint(buffer->Get(Symbols::byteLength), &try_catch);
+        convertToUint(buffer->Get(String::New("byteLength")), &try_catch);
     if (try_catch.HasCaught()) return try_catch.ReThrow();
 
     if (args.Length() < 2 || args[1]->IsUndefined()) {
       byteOffset = 0;
     } else {
       byteOffset = convertToUint(args[1], &try_catch);
       if (try_catch.HasCaught()) return try_catch.ReThrow();
       if (byteOffset > bufferLength) {
-        return Throw("byteOffset out of bounds");
+        return ThrowException(String::New("byteOffset out of bounds"));
       }
       if (byteOffset % element_size != 0) {
-        return Throw("byteOffset must be multiple of element size");
+        return ThrowException(
+            String::New("byteOffset must be multiple of element size"));
       }
     }
 
     if (args.Length() < 3 || args[2]->IsUndefined()) {
       byteLength = bufferLength - byteOffset;
       length = byteLength / element_size;
       if (byteLength % element_size != 0) {
-        return Throw("buffer size must be multiple of element size");
+        return ThrowException(
+            String::New("buffer size must be multiple of element size"));
       }
     } else {
       length = convertToUint(args[2], &try_catch);
       if (try_catch.HasCaught()) return try_catch.ReThrow();
       byteLength = length * element_size;
       if (byteOffset + byteLength > bufferLength) {
-        return Throw("length out of bounds");
+        return ThrowException(String::New("length out of bounds"));
       }
     }
   } else {
     if (args[0]->IsObject() &&
-        args[0]->ToObject()->Has(Symbols::length)) {
+        args[0]->ToObject()->Has(String::New("length"))) {
       // Construct from array.
       length = convertToUint(
-          args[0]->ToObject()->Get(Symbols::length), &try_catch);
+          args[0]->ToObject()->Get(String::New("length")), &try_catch);
       if (try_catch.HasCaught()) return try_catch.ReThrow();
       init_from_array = true;
     } else {
       // Construct from size.
       length = convertToUint(args[0], &try_catch);
       if (try_catch.HasCaught()) return try_catch.ReThrow();
     }
     byteLength = length * element_size;
     byteOffset = 0;
 
     Handle<Object> global = Context::GetCurrent()->Global();
-    Handle<Value> array_buffer = global->Get(Symbols::ArrayBuffer);
+    Handle<Value> array_buffer = global->Get(String::New("ArrayBuffer"));
     ASSERT(!try_catch.HasCaught() && array_buffer->IsFunction());
     Handle<Value> buffer_args[] = { Uint32::New(byteLength) };
     Handle<Value> result = Handle<Function>::Cast(array_buffer)->NewInstance(
         1, buffer_args);
     if (try_catch.HasCaught()) return result;
     buffer = result->ToObject();
   }
 
   Handle<Object> array = CreateExternalArray(
       args.This(), buffer, type, length, byteLength, byteOffset, element_size);
 
   if (init_from_array) {
     Handle<Object> init = args[0]->ToObject();
     for (int i = 0; i < length; ++i) array->Set(i, init->Get(i));
   }
 
   return array;
 }
 
 
 Handle<Value> Shell::ArrayBufferSlice(const Arguments& args) {
   TryCatch try_catch;
 
   if (!args.This()->IsObject()) {
-    return Throw("'slice' invoked on non-object receiver");
+    return ThrowException(
+        String::New("'slice' invoked on non-object receiver"));
   }
 
   Local<Object> self = args.This();
   Local<Value> marker =
-      self->GetHiddenValue(Symbols::ArrayBufferMarkerPropName);
+      self->GetHiddenValue(String::New(kArrayBufferMarkerPropName));
   if (marker.IsEmpty()) {
-    return Throw("'slice' invoked on wrong receiver type");
+    return ThrowException(
+        String::New("'slice' invoked on wrong receiver type"));
   }
 
   int32_t length =
-      convertToUint(self->Get(Symbols::byteLength), &try_catch);
+      convertToUint(self->Get(String::New("byteLength")), &try_catch);
   if (try_catch.HasCaught()) return try_catch.ReThrow();
 
   if (args.Length() == 0) {
-    return Throw("'slice' must have at least one argument");
+    return ThrowException(
+        String::New("'slice' must have at least one argument"));
   }
   int32_t begin = convertToInt(args[0], &try_catch);
   if (try_catch.HasCaught()) return try_catch.ReThrow();
   if (begin < 0) begin += length;
   if (begin < 0) begin = 0;
   if (begin > length) begin = length;
 
   int32_t end;
   if (args.Length() < 2 || args[1]->IsUndefined()) {
     end = length;
@@ skipping 18 matching lines @@
   memcpy(dest, src, end - begin);
 
   return buffer;
 }
 
 
 Handle<Value> Shell::ArraySubArray(const Arguments& args) {
   TryCatch try_catch;
 
   if (!args.This()->IsObject()) {
-    return Throw("'subarray' invoked on non-object receiver");
+    return ThrowException(
+        String::New("'subarray' invoked on non-object receiver"));
   }
 
   Local<Object> self = args.This();
-  Local<Value> marker = self->GetHiddenValue(Symbols::ArrayMarkerPropName);
+  Local<Value> marker = self->GetHiddenValue(String::New(kArrayMarkerPropName));
   if (marker.IsEmpty()) {
-    return Throw("'subarray' invoked on wrong receiver type");
+    return ThrowException(
+        String::New("'subarray' invoked on wrong receiver type"));
   }
 
-  Handle<Object> buffer = self->Get(Symbols::buffer)->ToObject();
+  Handle<Object> buffer = self->Get(String::New("buffer"))->ToObject();
   if (try_catch.HasCaught()) return try_catch.ReThrow();
   int32_t length =
-      convertToUint(self->Get(Symbols::length), &try_catch);
+      convertToUint(self->Get(String::New("length")), &try_catch);
   if (try_catch.HasCaught()) return try_catch.ReThrow();
   int32_t byteOffset =
-      convertToUint(self->Get(Symbols::byteOffset), &try_catch);
+      convertToUint(self->Get(String::New("byteOffset")), &try_catch);
   if (try_catch.HasCaught()) return try_catch.ReThrow();
   int32_t element_size =
-      convertToUint(self->Get(Symbols::BYTES_PER_ELEMENT), &try_catch);
+      convertToUint(self->Get(String::New("BYTES_PER_ELEMENT")), &try_catch);
   if (try_catch.HasCaught()) return try_catch.ReThrow();
 
   if (args.Length() == 0) {
-    return Throw("'subarray' must have at least one argument");
+    return ThrowException(
+        String::New("'subarray' must have at least one argument"));
   }
   int32_t begin = convertToInt(args[0], &try_catch);
   if (try_catch.HasCaught()) return try_catch.ReThrow();
   if (begin < 0) begin += length;
   if (begin < 0) begin = 0;
   if (begin > length) begin = length;
 
   int32_t end;
   if (args.Length() < 2 || args[1]->IsUndefined()) {
     end = length;
@@ skipping 14 matching lines @@
     buffer, Uint32::New(byteOffset), Uint32::New(length)
   };
   return constructor->NewInstance(3, construct_args);
 }
 
 
 Handle<Value> Shell::ArraySet(const Arguments& args) {
   TryCatch try_catch;
 
   if (!args.This()->IsObject()) {
-    return Throw("'set' invoked on non-object receiver");
+    return ThrowException(
+        String::New("'set' invoked on non-object receiver"));
   }
 
   Local<Object> self = args.This();
-  Local<Value> marker = self->GetHiddenValue(Symbols::ArrayMarkerPropName);
+  Local<Value> marker = self->GetHiddenValue(String::New(kArrayMarkerPropName));
   if (marker.IsEmpty()) {
-    return Throw("'set' invoked on wrong receiver type");
+    return ThrowException(
+        String::New("'set' invoked on wrong receiver type"));
   }
   int32_t length =
-      convertToUint(self->Get(Symbols::length), &try_catch);
+      convertToUint(self->Get(String::New("length")), &try_catch);
   if (try_catch.HasCaught()) return try_catch.ReThrow();
   int32_t element_size =
-      convertToUint(self->Get(Symbols::BYTES_PER_ELEMENT), &try_catch);
+      convertToUint(self->Get(String::New("BYTES_PER_ELEMENT")), &try_catch);
   if (try_catch.HasCaught()) return try_catch.ReThrow();
 
   if (args.Length() == 0) {
-    return Throw("'set' must have at least one argument");
+    return ThrowException(
+        String::New("'set' must have at least one argument"));
   }
   if (!args[0]->IsObject() ||
-      !args[0]->ToObject()->Has(Symbols::length)) {
-    return Throw("'set' invoked with non-array argument");
+      !args[0]->ToObject()->Has(String::New("length"))) {
+    return ThrowException(
+        String::New("'set' invoked with non-array argument"));
   }
   Handle<Object> source = args[0]->ToObject();
   int32_t source_length =
-      convertToUint(source->Get(Symbols::length), &try_catch);
+      convertToUint(source->Get(String::New("length")), &try_catch);
   if (try_catch.HasCaught()) return try_catch.ReThrow();
 
   int32_t offset;
   if (args.Length() < 2 || args[1]->IsUndefined()) {
     offset = 0;
   } else {
     offset = convertToUint(args[1], &try_catch);
     if (try_catch.HasCaught()) return try_catch.ReThrow();
   }
   if (offset + source_length > length) {
-    return Throw("offset or source length out of bounds");
+    return ThrowException(String::New("offset or source length out of bounds"));
   }
 
   int32_t source_element_size;
-  if (source->GetHiddenValue(Symbols::ArrayMarkerPropName).IsEmpty()) {
+  if (source->GetHiddenValue(String::New(kArrayMarkerPropName)).IsEmpty()) {
     source_element_size = 0;
   } else {
     source_element_size =
-       convertToUint(source->Get(Symbols::BYTES_PER_ELEMENT), &try_catch);
+       convertToUint(source->Get(String::New("BYTES_PER_ELEMENT")), &try_catch);
     if (try_catch.HasCaught()) return try_catch.ReThrow();
   }
 
   if (element_size == source_element_size &&
       self->GetConstructor()->StrictEquals(source->GetConstructor())) {
     // Use memmove on the array buffers.
-    Handle<Object> buffer = self->Get(Symbols::buffer)->ToObject();
+    Handle<Object> buffer = self->Get(String::New("buffer"))->ToObject();
     if (try_catch.HasCaught()) return try_catch.ReThrow();
     Handle<Object> source_buffer =
-        source->Get(Symbols::buffer)->ToObject();
+        source->Get(String::New("buffer"))->ToObject();
     if (try_catch.HasCaught()) return try_catch.ReThrow();
     int32_t byteOffset =
-        convertToUint(self->Get(Symbols::byteOffset), &try_catch);
+        convertToUint(self->Get(String::New("byteOffset")), &try_catch);
     if (try_catch.HasCaught()) return try_catch.ReThrow();
     int32_t source_byteOffset =
-        convertToUint(source->Get(Symbols::byteOffset), &try_catch);
+        convertToUint(source->Get(String::New("byteOffset")), &try_catch);
     if (try_catch.HasCaught()) return try_catch.ReThrow();
 
     uint8_t* dest = byteOffset + offset * element_size + static_cast<uint8_t*>(
         buffer->GetIndexedPropertiesExternalArrayData());
     uint8_t* src = source_byteOffset + static_cast<uint8_t*>(
         source_buffer->GetIndexedPropertiesExternalArrayData());
     memmove(dest, src, source_length * element_size);
   } else if (source_element_size == 0) {
     // Source is not a typed array, copy element-wise sequentially.
     for (int i = 0; i < source_length; ++i) {
       self->Set(offset + i, source->Get(i));
       if (try_catch.HasCaught()) return try_catch.ReThrow();
     }
   } else {
     // Need to copy element-wise to make the right conversions.
-    Handle<Object> buffer = self->Get(Symbols::buffer)->ToObject();
+    Handle<Object> buffer = self->Get(String::New("buffer"))->ToObject();
     if (try_catch.HasCaught()) return try_catch.ReThrow();
     Handle<Object> source_buffer =
-        source->Get(Symbols::buffer)->ToObject();
+        source->Get(String::New("buffer"))->ToObject();
     if (try_catch.HasCaught()) return try_catch.ReThrow();
 
     if (buffer->StrictEquals(source_buffer)) {
       // Same backing store, need to handle overlap correctly.
       // This gets a bit tricky in the case of different element sizes
       // (which, of course, is extremely unlikely to ever occur in practice).
       int32_t byteOffset =
-          convertToUint(self->Get(Symbols::byteOffset), &try_catch);
+          convertToUint(self->Get(String::New("byteOffset")), &try_catch);
       if (try_catch.HasCaught()) return try_catch.ReThrow();
       int32_t source_byteOffset =
-          convertToUint(source->Get(Symbols::byteOffset), &try_catch);
+          convertToUint(source->Get(String::New("byteOffset")), &try_catch);
       if (try_catch.HasCaught()) return try_catch.ReThrow();
 
       // Copy as much as we can from left to right.
       int i = 0;
       int32_t next_dest_offset = byteOffset + (offset + 1) * element_size;
       int32_t next_src_offset = source_byteOffset + source_element_size;
       while (i < length && next_dest_offset <= next_src_offset) {
         self->Set(offset + i, source->Get(i));
         ++i;
         next_dest_offset += element_size;
@@ skipping 26 matching lines @@
     }
   }
 
   return Undefined();
 }
 
 
 void Shell::ExternalArrayWeakCallback(Persistent<Value> object, void* data) {
   HandleScope scope;
   int32_t length =
-      object->ToObject()->Get(Symbols::byteLength)->Uint32Value();
+      object->ToObject()->Get(String::New("byteLength"))->Uint32Value();
   V8::AdjustAmountOfExternalAllocatedMemory(-length);
   delete[] static_cast<uint8_t*>(data);
   object.Dispose();
 }
 
 
 Handle<Value> Shell::Int8Array(const Arguments& args) {
   return CreateExternalArray(args, v8::kExternalByteArray, sizeof(int8_t));
 }
 
@@ skipping 365 matching lines @@
   global_template->Set(String::New("quit"), FunctionTemplate::New(Quit));
   global_template->Set(String::New("version"), FunctionTemplate::New(Version));
   global_template->Set(String::New("enableProfiler"),
                        FunctionTemplate::New(EnableProfiler));
   global_template->Set(String::New("disableProfiler"),
                        FunctionTemplate::New(DisableProfiler));
 
   // Bind the handlers for external arrays.
   PropertyAttribute attr =
       static_cast<PropertyAttribute>(ReadOnly | DontDelete);
-  global_template->Set(Symbols::ArrayBuffer,
+  global_template->Set(String::New("ArrayBuffer"),
                        CreateArrayBufferTemplate(ArrayBuffer), attr);
   global_template->Set(String::New("Int8Array"),
                        CreateArrayTemplate(Int8Array), attr);
   global_template->Set(String::New("Uint8Array"),
                        CreateArrayTemplate(Uint8Array), attr);
   global_template->Set(String::New("Int16Array"),
                        CreateArrayTemplate(Int16Array), attr);
   global_template->Set(String::New("Uint16Array"),
                        CreateArrayTemplate(Uint16Array), attr);
   global_template->Set(String::New("Int32Array"),
@@ skipping 37 matching lines @@
   Shell::counter_map_ = new CounterMap();
   // Set up counters
   if (i::StrLength(i::FLAG_map_counters) != 0)
     MapCounters(i::FLAG_map_counters);
   if (i::FLAG_dump_counters || i::FLAG_track_gc_object_stats) {
     V8::SetCounterFunction(LookupCounter);
     V8::SetCreateHistogramFunction(CreateHistogram);
     V8::SetAddHistogramSampleFunction(AddHistogramSample);
   }
 #endif  // V8_SHARED
-
-  Symbols::Initialize();
   if (options.test_shell) return;
 
 #ifndef V8_SHARED
   Locker lock;
   HandleScope scope;
   Handle<ObjectTemplate> global_template = CreateGlobalTemplate();
   utility_context_ = Context::New(NULL, global_template);
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
   // Start the debugger agent if requested.
@@ skipping 138 matching lines @@
   *size_out = size;
   return chars;
 }
 
 
 Handle<Value> Shell::ReadBuffer(const Arguments& args) {
   ASSERT(sizeof(char) == sizeof(uint8_t));  // NOLINT
   String::Utf8Value filename(args[0]);
   int length;
   if (*filename == NULL) {
-    return Throw("Error loading file");
+    return ThrowException(String::New("Error loading file"));
   }
 
   uint8_t* data = reinterpret_cast<uint8_t*>(ReadChars(*filename, &length));
   if (data == NULL) {
-    return Throw("Error reading file");
+    return ThrowException(String::New("Error reading file"));
   }
   Handle<Object> buffer = Object::New();
-  buffer->SetHiddenValue(Symbols::ArrayBufferMarkerPropName, True());
+  buffer->SetHiddenValue(String::New(kArrayBufferMarkerPropName), True());
   Persistent<Object> persistent_buffer = Persistent<Object>::New(buffer);
   persistent_buffer.MakeWeak(data, ExternalArrayWeakCallback);
   persistent_buffer.MarkIndependent();
   V8::AdjustAmountOfExternalAllocatedMemory(length);
 
   buffer->SetIndexedPropertiesToExternalArrayData(
       data, kExternalUnsignedByteArray, length);
-  buffer->Set(Symbols::byteLength,
+  buffer->Set(String::New("byteLength"),
       Int32::New(static_cast<int32_t>(length)), ReadOnly);
   return buffer;
 }
 
 
 #ifndef V8_SHARED
 static char* ReadToken(char* data, char token) {
   char* next = i::OS::StrChr(data, token);
   if (next != NULL) {
     *next = '\0';
@@ skipping 477 matching lines @@
       || !options.script_executed )
       && !options.test_shell ) {
 #if !defined(V8_SHARED) && defined(ENABLE_DEBUGGER_SUPPORT)
     if (!i::FLAG_debugger) {
       InstallUtilityScript();
     }
 #endif  // !V8_SHARED && ENABLE_DEBUGGER_SUPPORT
     RunShell();
   }
 
-  Symbols::TearDown();
   V8::Dispose();
 
 #ifndef V8_SHARED
   OnExit();
 #endif  // V8_SHARED
 
   return result;
 }
 
 }  // namespace v8
 
 
 #ifndef GOOGLE3
 int main(int argc, char* argv[]) {
   return v8::Shell::Main(argc, argv);
 }
 #endif