Fix some style issues.

src/serialize.cc

 // 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 860 matching lines @@
 #endif
 
 
 void Serializer::InitializeAllocators() {
   for (int i = 0; i <= LAST_SPACE; i++) {
     allocator_[i]->InitEmptyHeap(static_cast<AllocationSpace>(i));
   }
 }
 
 
-bool Serializer::IsVisited(HeapObject *obj) {
+bool Serializer::IsVisited(HeapObject* obj) {
   HashMap::Entry* entry =
     saved_addresses_.Lookup(obj, HeapObjectHash(obj), false);
   return entry != NULL;
 }
 
 
-Address Serializer::GetSavedAddress(HeapObject *obj) {
+Address Serializer::GetSavedAddress(HeapObject* obj) {
   HashMap::Entry* entry
   = saved_addresses_.Lookup(obj, HeapObjectHash(obj), false);
   ASSERT(entry != NULL);
   return reinterpret_cast<Address>(entry->value);
 }
 
 
 void Serializer::SaveAddress(HeapObject* obj, Address addr) {
   HashMap::Entry* entry =
     saved_addresses_.Lookup(obj, HeapObjectHash(obj), true);
@@ skipping 489 matching lines @@
 
 
 Object* Deserializer::GetObject() {
   // Read the prologue: type, size and encoded address.
   InstanceType type = static_cast<InstanceType>(reader_.GetInt());
   int size = reader_.GetInt() << kObjectAlignmentBits;
   Address a = GetEncodedAddress();
 
   // Get a raw object of the right size in the right space.
   AllocationSpace space = GetSpace(a);
-  Object *o;
+  Object* o;
   if (IsLargeExecutableObject(a)) {
     o = Heap::lo_space()->AllocateRawCode(size);
   } else if (IsLargeFixedArray(a)) {
     o = Heap::lo_space()->AllocateRawFixedArray(size);
   } else {
     o = Heap::AllocateRaw(size, space);
   }
   ASSERT(!o->IsFailure());
   // Check that the simulation of heap allocation was correct.
   ASSERT(o == Resolve(a));
@@ skipping 37 matching lines @@
                                    int page_offset,
                                    PagedSpace* space,
                                    List<Page*>* page_list) {
   ASSERT(page_index < page_list->length());
   Address address = (*page_list)[page_index]->OffsetToAddress(page_offset);
   return HeapObject::FromAddress(address);
 }
 
 
 template<typename T>
-void ConcatReversed(List<T> * target, const List<T> & source) {
+void ConcatReversed(List<T>* target, const List<T>& source) {
   for (int i = source.length() - 1; i >= 0; i--) {
     target->Add(source[i]);
   }
 }
 
 
 Object* Deserializer::Resolve(Address encoded) {
   Object* o = reinterpret_cast<Object*>(encoded);
   if (o->IsSmi()) return o;
 
@@ skipping 40 matching lines @@
         ASSERT(index < large_objects_.length());
       }
       return large_objects_[index];  // s.page_offset() is ignored.
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 } }  // namespace v8::internal