Remove stl dependencies from d8.

src/d8.h

 // 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 10 matching lines @@
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef V8_D8_H_
 #define V8_D8_H_
 
-
-// Disable exceptions on windows to not generate warnings from <map>.
-#define _HAS_EXCEPTIONS 0
-#include <map>
-
 #include "v8.h"
+#include "hashmap.h"
 
 
 namespace v8 {
 
 
 namespace i = v8::internal;
 
 
 // A single counter in a counter collection.
 class Counter {
@@ skipping 18 matching lines @@
  private:
   static const unsigned kMaxCounters = 256;
   uint32_t magic_number_;
   uint32_t max_counters_;
   uint32_t max_name_size_;
   uint32_t counters_in_use_;
   Counter counters_[kMaxCounters];
 };
 
 
+class CounterMap {
+ public:
+  CounterMap(): hash_map_(Match) { }
+  Counter* Lookup(const char* name) {
+    i::HashMap::Entry* answer = hash_map_.Lookup(
+        const_cast<char*>(name),
+        Hash(name),
+        false);
+    if (!answer) return NULL;
+    return reinterpret_cast<Counter*>(answer->value);
+  }
+  void Set(const char* name, Counter* value) {
+    i::HashMap::Entry* answer = hash_map_.Lookup(
+        const_cast<char*>(name),
+        Hash(name),
+        true);
+    ASSERT(answer != NULL);
+    answer->value = value;
+  }
+  class Iterator {
+   public:
+    Iterator(CounterMap* map): map_(&map->hash_map_), entry_(map_->Start()) { }
+    void Next() { entry_ = map_->Next(entry_); }
+    bool More() { return entry_ != NULL; }
+    const char* CurrentKey() { return static_cast<const char*>(entry_->key); }
+    Counter* CurrentValue() { return static_cast<Counter*>(entry_->value); }
+   private:
+    i::HashMap* map_;
+    i::HashMap::Entry* entry_;
+  };
+ private:
+  static int Hash(const char* name);
+  static bool Match(void* key1, void* key2);
+  i::HashMap hash_map_;
+};
+
+
 class Shell: public i::AllStatic {
  public:
   static bool ExecuteString(Handle<String> source,
                             Handle<Value> name,
                             bool print_result,
                             bool report_exceptions);
   static void ReportException(TryCatch* try_catch);
   static void Initialize();
   static void OnExit();
   static int* LookupCounter(const char* name);
@@ skipping 12 matching lines @@
   static Handle<Value> Version(const Arguments& args);
   static Handle<Value> Load(const Arguments& args);
 
   static Handle<Context> utility_context() { return utility_context_; }
 
   static const char* kHistoryFileName;
   static const char* kPrompt;
  private:
   static Persistent<Context> utility_context_;
   static Persistent<Context> evaluation_context_;
-  typedef std::map<const char*, Counter*> CounterMap;
-  static CounterMap counter_map_;
+  static CounterMap* counter_map_;
   // We statically allocate a set of local counters to be used if we
   // don't want to store the stats in a memory-mapped file
   static CounterCollection local_counters_;
   static CounterCollection* counters_;
   static i::OS::MemoryMappedFile* counters_file_;
 };
 
 
 class LineEditor {
  public:
@@ skipping 13 matching lines @@
   const char* name_;
   LineEditor* next_;
   static LineEditor* first_;
 };
 
 
 }  // namespace v8
 
 
 #endif  // V8_D8_H_