Switch to standard integer types in courgette/.

courgette/disassembler_elf_32.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "courgette/disassembler_elf_32.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 
 #include "courgette/assembly_program.h"
 #include "courgette/courgette.h"
 #include "courgette/encoded_program.h"
 
 namespace courgette {
 
 DisassemblerElf32::DisassemblerElf32(const void* start, size_t length)
@@ skipping 153 matching lines @@
       }
     }
   }
 
   return false;
 }
 
 RVA DisassemblerElf32::FileOffsetToRVA(size_t offset) const {
   // File offsets can be 64 bit values, but we are dealing with 32
   // bit executables and so only need to support 32bit file sizes.
-  uint32 offset32 = (uint32)offset;
+  uint32_t offset32 = (uint32_t)offset;
 
   for (int i = 0; i < SectionHeaderCount(); i++) {
 
     const Elf32_Shdr *section_header = SectionHeader(i);
 
     // These can appear to have a size in the file, but don't.
     if (section_header->sh_type == SHT_NOBITS)
       continue;
 
     Elf32_Off section_begin = section_header->sh_offset;
@@ skipping 37 matching lines @@
       return false;
 
     (*rva)->set_offset(offset);
   }
 
   return true;
 }
 
 CheckBool DisassemblerElf32::ParseFile(AssemblyProgram* program) {
   // Walk all the bytes in the file, whether or not in a section.
-  uint32 file_offset = 0;
+  uint32_t file_offset = 0;
 
   std::vector<size_t> abs_offsets;
 
   if (!RVAsToOffsets(&abs32_locations_, &abs_offsets))
     return false;
 
   if (!RVAsToOffsets(&rel32_locations_))
     return false;
 
   std::vector<size_t>::iterator current_abs_offset = abs_offsets.begin();
@@ skipping 109 matching lines @@
     if (next_relocation > file_offset) {
       if (!ParseSimpleRegion(file_offset, next_relocation, program))
         return false;
 
       file_offset = next_relocation;
       continue;
     }
 
     if (*current_abs_offset != end_abs_offset &&
         file_offset == **current_abs_offset) {
-
-      const uint8* p = OffsetToPointer(file_offset);
+      const uint8_t* p = OffsetToPointer(file_offset);
       RVA target_rva = Read32LittleEndian(p);
 
       if (!program->EmitAbs32(program->FindOrMakeAbs32Label(target_rva)))
         return false;
       file_offset += sizeof(RVA);
       (*current_abs_offset)++;
       continue;
     }
 
     if (*current_rel != end_rel &&
         file_offset == (**current_rel)->get_offset()) {
-
-      uint32 relative_target = (**current_rel)->relative_target();
+      uint32_t relative_target = (**current_rel)->relative_target();
       // This cast is for 64 bit systems, and is only safe because we
       // are working on 32 bit executables.
       RVA target_rva = (RVA)(origin + (file_offset - origin_offset) +
                              relative_target);
 
       if (! (**current_rel)->EmitInstruction(program, target_rva))
         return false;
       file_offset += (**current_rel)->op_size();
       (*current_rel)++;
       continue;
@@ skipping 96 matching lines @@
       return false;
   }
 
   std::sort(rel32_locations_.begin(),
             rel32_locations_.end(),
             TypedRVA::IsLessThan);
   return true;
 }
 
 }  // namespace courgette