Api inlining. Made some core functionality available in the api and...

src/api.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 320 matching lines @@
   // Threading support for handle data.
   static int ArchiveSpacePerThread();
   static char* RestoreThread(char* from);
   static char* ArchiveThread(char* to);
 
   // Garbage collection support.
   static void Iterate(v8::internal::ObjectVisitor* v);
   static char* Iterate(v8::internal::ObjectVisitor* v, char* data);
 
 
-  inline void** GetSpareOrNewBlock();
+  inline internal::Object** GetSpareOrNewBlock();
   inline void DeleteExtensions(int extensions);
 
   inline void IncrementCallDepth() {call_depth++;}
   inline void DecrementCallDepth() {call_depth--;}
   inline bool CallDepthIsZero() { return call_depth == 0; }
 
   inline void EnterContext(Handle<Object> context);
   inline bool LeaveLastContext();
 
   // Returns the last entered context or an empty handle if no
   // contexts have been entered.
   inline Handle<Object> LastEnteredContext();
 
   inline void SaveContext(Handle<Object> context);
   inline Handle<Object> RestoreContext();
   inline bool HasSavedContexts();
 
-  inline List<void**>* Blocks() { return &blocks; }
+  inline List<internal::Object**>* Blocks() { return &blocks; }
 
   inline bool IgnoreOutOfMemory() { return ignore_out_of_memory; }
   inline void SetIgnoreOutOfMemory(bool value) { ignore_out_of_memory = value; }
 
  private:
-  List<void**> blocks;
+  List<internal::Object**> blocks;
   Object** spare;
   int call_depth;
   // Used as a stack to keep track of entered contexts.
   List<Handle<Object> > entered_contexts_;
   // Used as a stack to keep track of saved contexts.
   List<Handle<Object> > saved_contexts_;
   bool ignore_out_of_memory;
   // This is only used for threading support.
   v8::ImplementationUtilities::HandleScopeData handle_scope_data_;
 
   static void Iterate(ObjectVisitor* v,
-      List<void**>* blocks,
+      List<internal::Object**>* blocks,
       v8::ImplementationUtilities::HandleScopeData* handle_data);
   char* RestoreThreadHelper(char* from);
   char* ArchiveThreadHelper(char* to);
 
   DISALLOW_COPY_AND_ASSIGN(HandleScopeImplementer);
 };
 
 
 static const int kHandleBlockSize = v8::internal::KB - 2;  // fit in one page
 
@@ skipping 25 matching lines @@
 }
 
 
 Handle<Object> HandleScopeImplementer::LastEnteredContext() {
   if (entered_contexts_.is_empty()) return Handle<Object>::null();
   return entered_contexts_.last();
 }
 
 
 // If there's a spare block, use it for growing the current scope.
-void** HandleScopeImplementer::GetSpareOrNewBlock() {
-  void** block = (spare != NULL) ?
-      reinterpret_cast<void**>(spare) :
-      NewArray<void*>(kHandleBlockSize);
+internal::Object** HandleScopeImplementer::GetSpareOrNewBlock() {
+  internal::Object** block = (spare != NULL) ?
+      spare :
+      NewArray<internal::Object*>(kHandleBlockSize);
   spare = NULL;
   return block;
 }
 
 
 void HandleScopeImplementer::DeleteExtensions(int extensions) {
   if (spare != NULL) {
     DeleteArray(spare);
     spare = NULL;
   }
   for (int i = extensions; i > 1; --i) {
-    void** block = blocks.RemoveLast();
+    internal::Object** block = blocks.RemoveLast();
 #ifdef DEBUG
     v8::ImplementationUtilities::ZapHandleRange(block,
                                                 &block[kHandleBlockSize]);
 #endif
     DeleteArray(block);
   }
-  spare = reinterpret_cast<Object**>(blocks.RemoveLast());
+  spare = blocks.RemoveLast();
 #ifdef DEBUG
   v8::ImplementationUtilities::ZapHandleRange(
-      reinterpret_cast<void**>(spare),
-      reinterpret_cast<void**>(&spare[kHandleBlockSize]));
+      spare,
+      &spare[kHandleBlockSize]);
 #endif
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_API_H_