Remove stl dependencies from d8.

src/d8.cc

 // Copyright 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 68 matching lines @@
 
 i::SmartPointer<char> DumbLineEditor::Prompt(const char* prompt) {
   static const int kBufferSize = 256;
   char buffer[kBufferSize];
   printf("%s", prompt);
   char* str = fgets(buffer, kBufferSize, stdin);
   return i::SmartPointer<char>(str ? i::StrDup(str) : str);
 }
 
 
-Shell::CounterMap Shell::counter_map_;
+CounterMap* Shell::counter_map_;
 i::OS::MemoryMappedFile* Shell::counters_file_ = NULL;
 CounterCollection Shell::local_counters_;
 CounterCollection* Shell::counters_ = &local_counters_;
 Persistent<Context> Shell::utility_context_;
 Persistent<Context> Shell::evaluation_context_;
 
 
+bool CounterMap::Match(void* key1, void* key2) {
+  const char* name1 = reinterpret_cast<const char*>(key1);
+  const char* name2 = reinterpret_cast<const char*>(key2);
+  return !strcmp(name1, name2);

[Kevin Millikin (Chromium), 2009/03/24 13:29:30]

return strcmp(name1, name2) == 0; maybe?

+}
+
+
 // Converts a V8 value to a C string.
 const char* ToCString(const v8::String::Utf8Value& value) {
   return *value ? *value : "<string conversion failed>";
 }
 
 
 // Executes a string within the current v8 context.
 bool Shell::ExecuteString(Handle<String> source,
                           Handle<Value> name,
                           bool print_result,
@@ skipping 184 matching lines @@
       NULL : counters_file_->memory();
   if (memory == NULL) {
     printf("Could not map counters file %s\n", name);
     exit(1);
   }
   counters_ = static_cast<CounterCollection*>(memory);
   V8::SetCounterFunction(LookupCounter);
 }
 
 
+int CounterMap::Hash(const char* name) {
+  int h = 0;
+  int c;
+  while ((c = *name++) != 0) {
+    h += h << 5;
+    h += c;
+  }
+  return h;
+}
+
+
 int* Shell::LookupCounter(const char* name) {
-  CounterMap::iterator item = counter_map_.find(name);
-  if (item != counter_map_.end()) {
-    Counter* result = (*item).second;
-    return result->ptr();
+  Counter* counter = counter_map_->Lookup(name);
+  if (counter != NULL) {
+    return counter->ptr();
   }
   Counter* result = counters_->GetNextCounter();
   if (result == NULL) return NULL;
-  counter_map_[name] = result;
+  counter_map_->Set(name, result);
   return result->Bind(name);
 }
 
 
 void Shell::Initialize() {
+  Shell::counter_map_ = new CounterMap();
   // Set up counters
   if (i::FLAG_map_counters != NULL)
     MapCounters(i::FLAG_map_counters);
   if (i::FLAG_dump_counters)
     V8::SetCounterFunction(LookupCounter);
   // Initialize the global objects
   HandleScope scope;
   Handle<ObjectTemplate> global_template = ObjectTemplate::New();
   global_template->Set(String::New("print"), FunctionTemplate::New(Print));
   global_template->Set(String::New("load"), FunctionTemplate::New(Load));
@@ skipping 50 matching lines @@
   // Set the security token of the debug context to allow access.
   i::Debug::debug_context()->set_security_token(i::Heap::undefined_value());
 }
 
 
 void Shell::OnExit() {
   if (i::FLAG_dump_counters) {
     ::printf("+----------------------------------------+-------------+\n");
     ::printf("| Name                                   | Value       |\n");
     ::printf("+----------------------------------------+-------------+\n");
-    for (CounterMap::iterator i = counter_map_.begin();
-         i != counter_map_.end();
-         i++) {
-      Counter* counter = (*i).second;
-      ::printf("| %-38s | %11i |\n", (*i).first, counter->value());
+    for (CounterMap::Iterator i(counter_map_); i.More(); i.Next()) {
+      Counter* counter = i.CurrentValue();
+      ::printf("| %-38s | %11i |\n", i.CurrentKey(), counter->value());
     }
     ::printf("+----------------------------------------+-------------+\n");
   }
   if (counters_file_ != NULL)
     delete counters_file_;
 }
 
 
 static char* ReadChars(const char *name, int* size_out) {
   v8::Unlocker unlocker;  // Release the V8 lock while reading files.
@@ skipping 248 matching lines @@
   return 0;
 }
 
 
 }  // namespace v8
 
 
 int main(int argc, char* argv[]) {
   return v8::Shell::Main(argc, argv);
 }