Start migrating profiles processing to C++.

src/splay-tree-inl.h

 // Copyright 2010 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 40 matching lines @@
     // for the key to the root of the tree.
     Splay(key);
     // Ignore repeated insertions with the same key.
     int cmp = Config::Compare(key, root_->key_);
     if (cmp == 0) {
       locator->bind(root_);
       return false;
     }
     // Insert the new node.
     Node* node = new Node(key, Config::kNoValue);
-    if (cmp > 0) {
-      node->left_ = root_;
-      node->right_ = root_->right_;
-      root_->right_ = NULL;
-    } else {
-      node->right_ = root_;
-      node->left_ = root_->left_;
-      root_->left_ = NULL;
-    }
-    root_ = node;
+    InsertInternal(cmp, node);
   }
   locator->bind(root_);
   return true;
 }
 
 
 template<typename Config, class Allocator>
+void SplayTree<Config, Allocator>::InsertInternal(int cmp, Node* node) {
+  if (cmp > 0) {
+    node->left_ = root_;
+    node->right_ = root_->right_;
+    root_->right_ = NULL;
+  } else {
+    node->right_ = root_;
+    node->left_ = root_->left_;
+    root_->left_ = NULL;
+  }
+  root_ = node;
+}
+
+
+template<typename Config, class Allocator>
+bool SplayTree<Config, Allocator>::FindInternal(const Key& key) {
+  if (is_empty())
+    return false;
+  Splay(key);
+  return Config::Compare(key, root_->key_) == 0;
+}
+
+
+template<typename Config, class Allocator>
 bool SplayTree<Config, Allocator>::Find(const Key& key, Locator* locator) {
-  if (is_empty())
-    return false;
-  Splay(key);
-  if (Config::Compare(key, root_->key_) == 0) {
+  if (FindInternal(key)) {
     locator->bind(root_);
     return true;
   } else {
     return false;
   }
 }
 
 
 template<typename Config, class Allocator>
 bool SplayTree<Config, Allocator>::FindGreatestLessThan(const Key& key,
@@ skipping 61 matching lines @@
     return false;
   Node* current = root_;
   while (current->left_ != NULL)
     current = current->left_;
   locator->bind(current);
   return true;
 }
 
 
 template<typename Config, class Allocator>
+bool SplayTree<Config, Allocator>::Move(const Key& old_key,
+                                        const Key& new_key) {
+  if (!FindInternal(old_key))
+    return false;
+  Node* node_to_move = root_;
+  RemoveRootNode(old_key);
+  Splay(new_key);
+  int cmp = Config::Compare(new_key, root_->key_);
+  if (cmp == 0) {
+    // A node with the target key already exists.
+    delete node_to_move;
+    return false;
+  }
+  node_to_move->key_ = new_key;
+  InsertInternal(cmp, node_to_move);
+  return true;
+}
+
+
+template<typename Config, class Allocator>
 bool SplayTree<Config, Allocator>::Remove(const Key& key) {
-  // Bail if the tree is empty
-  if (is_empty())
+  if (!FindInternal(key))
     return false;
-  // Splay on the key to move the node with the given key to the top.
-  Splay(key);
-  // Bail if the key is not in the tree
-  if (Config::Compare(key, root_->key_) != 0)
-    return false;
+  Node* node_to_remove = root_;
+  RemoveRootNode(key);
+  delete node_to_remove;
+  return true;
+}
+
+
+template<typename Config, class Allocator>
+void SplayTree<Config, Allocator>::RemoveRootNode(const Key& key) {
   if (root_->left_ == NULL) {
     // No left child, so the new tree is just the right child.
     root_ = root_->right_;
   } else {
     // Left child exists.
     Node* right = root_->right_;
     // Make the original left child the new root.
     root_ = root_->left_;
     // Splay to make sure that the new root has an empty right child.
     Splay(key);
     // Insert the original right child as the right child of the new
     // root.
     root_->right_ = right;
   }
-  return true;
 }
 
 
 template<typename Config, class Allocator>
 void SplayTree<Config, Allocator>::Splay(const Key& key) {
   if (is_empty())
     return;
   Node dummy_node(Config::kNoKey, Config::kNoValue);
   // Create a dummy node.  The use of the dummy node is a bit
   // counter-intuitive: The right child of the dummy node will hold
@@ skipping 69 matching lines @@
     if (node->left() != NULL) nodes_to_visit.Add(node->left());
     if (node->right() != NULL) nodes_to_visit.Add(node->right());
     callback->Call(node);
   }
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPLAY_TREE_INL_H_