Fix a bunch of spelling mistakes :\

src/spaces.h

 // Copyright 2006-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 782 matching lines @@
   // Sets allocation pointer to a page bottom.
   static void SetAllocationInfo(AllocationInfo* alloc_info, Page* p);
 
   // Returns the top page specified by an allocation info structure.
   static Page* TopPageOf(AllocationInfo alloc_info) {
     return Page::FromAllocationTop(alloc_info.limit);
   }
 
   // Expands the space by allocating a fixed number of pages. Returns false if
   // it cannot allocate requested number of pages from OS. Newly allocated
-  // pages are appened to the last_page;
+  // pages are append to the last_page;
   bool Expand(Page* last_page);
 
   // Generic fast case allocation function that tries linear allocation in
   // the top page of 'alloc_info'.  Returns NULL on failure.
   inline HeapObject* AllocateLinearly(AllocationInfo* alloc_info,
                                       int size_in_bytes);
 
   // During normal allocation or deserialization, roll to the next page in
   // the space (there is assumed to be one) and allocate there.  This
   // function is space-dependent.
@@ skipping 75 matching lines @@
 
   // Tear down the space.  Heap memory was not allocated by the space, so it
   // is not deallocated here.
   void TearDown();
 
   // True if the space has been set up but not torn down.
   bool HasBeenSetup() { return start_ != NULL; }
 
   // Double the size of the semispace by committing extra virtual memory.
   // Assumes that the caller has checked that the semispace has not reached
-  // its maxmimum capacity (and thus there is space available in the reserved
+  // its maximum capacity (and thus there is space available in the reserved
   // address range to grow).
   bool Double();
 
   // Returns the start address of the space.
   Address low() { return start_; }
   // Returns one past the end address of the space.
   Address high() { return low() + capacity_; }
 
   // Age mark accessors.
   Address age_mark() { return age_mark_; }
   void set_age_mark(Address mark) { age_mark_ = mark; }
 
   // True if the address is in the address range of this semispace (not
   // necessarily below the allocation pointer).
   bool Contains(Address a) {
     return (reinterpret_cast<uint32_t>(a) & address_mask_)
            == reinterpret_cast<uint32_t>(start_);
   }
 
   // True if the object is a heap object in the address range of this
   // semispace (not necessarily below the allocation pointer).
   bool Contains(Object* o) {
     return (reinterpret_cast<uint32_t>(o) & object_mask_) == object_expected_;
   }
 
-  // The offset of an address from the begining of the space.
+  // The offset of an address from the beginning of the space.
   int SpaceOffsetForAddress(Address addr) { return addr - low(); }
 
   // If we don't have this here then SemiSpace will be abstract.  However
   // it should never be called.
   virtual int Size() {
     UNREACHABLE();
     return 0;
   }
 
 #ifdef DEBUG
@@ skipping 583 matching lines @@
   // Accessors for the fields of the chunk.
   LargeObjectChunk* next() { return next_; }
   void set_next(LargeObjectChunk* chunk) { next_ = chunk; }
 
   size_t size() { return size_; }
   void set_size(size_t size_in_bytes) { size_ = size_in_bytes; }
 
   // Returns the object in this chunk.
   inline HeapObject* GetObject();
 
-  // Given a requested size (including any extra remembereed set words),
+  // Given a requested size (including any extra remembered set words),
   // returns the physical size of a chunk to be allocated.
   static int ChunkSizeFor(int size_in_bytes);
 
-  // Given a chunk size, returns the object size it can accomodate (not
+  // Given a chunk size, returns the object size it can accommodate (not
   // including any extra remembered set words).  Used by
   // LargeObjectSpace::Available.  Note that this can overestimate the size
   // of object that will fit in a chunk---if the object requires extra
   // remembered set words (eg, for large fixed arrays), the actual object
   // size for the chunk will be smaller than reported by this function.
   static int ObjectSizeFor(int chunk_size) {
     if (chunk_size <= (Page::kPageSize + Page::kObjectStartOffset)) return 0;
     return chunk_size - Page::kPageSize - Page::kObjectStartOffset;
   }
 
@@ skipping 110 matching lines @@
 
  private:
   LargeObjectChunk* current_;
   HeapObjectCallback size_func_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_H_