[libFuzzer] Diff 14 - Detail. Same format for all header files.

[kcc]

LGTM

lib/Fuzzer/FuzzerDefs.h

 //===- FuzzerDefs.h - Internal header for the Fuzzer ------------*- C++ -* ===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // Basic definitions.
 //===----------------------------------------------------------------------===//
+
 #ifndef LLVM_FUZZER_DEFS_H
 #define LLVM_FUZZER_DEFS_H
 
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
 #include <string>

 };
 
 inline uint8_t  Bswap(uint8_t x)  { return x; }
 inline uint16_t Bswap(uint16_t x) { return __builtin_bswap16(x); }
 inline uint32_t Bswap(uint32_t x) { return __builtin_bswap32(x); }
 inline uint64_t Bswap(uint64_t x) { return __builtin_bswap64(x); }
 
 }  // namespace fuzzer
+
 #endif  // LLVM_FUZZER_DEFS_H

lib/Fuzzer/FuzzerDictionary.h

 bool ParseOneDictionaryEntry(const std::string &Str, Unit *U);
 // Parses the dictionary file, fills Units, returns true iff all lines
 // were parsed succesfully.
 bool ParseDictionaryFile(const std::string &Text, std::vector<Unit> *Units);
 
 }  // namespace fuzzer
 
 #endif  // LLVM_FUZZER_DICTIONARY_H
-

lib/Fuzzer/FuzzerExtFunctions.h

 //===- FuzzerExtFunctions.h - Interface to external functions ---*- C++ -* ===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // Defines an interface to (possibly optional) functions.
 //===----------------------------------------------------------------------===//
+
 #ifndef LLVM_FUZZER_EXT_FUNCTIONS_H
 #define LLVM_FUZZER_EXT_FUNCTIONS_H
 
 #include <stddef.h>
 #include <stdint.h>
 
 namespace fuzzer {
 
 struct ExternalFunctions {
   // Initialize function pointers. Functions that are not available will be set
   // to nullptr.  Do not call this constructor  before ``main()`` has been
   // entered.
   ExternalFunctions();
 
 #define EXT_FUNC(NAME, RETURN_TYPE, FUNC_SIG, WARN)                            \
   RETURN_TYPE(*NAME) FUNC_SIG = nullptr
 
 #include "FuzzerExtFunctions.def"
 
 #undef EXT_FUNC
 };
 } // namespace fuzzer
+
 #endif

lib/Fuzzer/FuzzerIO.h

 //===- FuzzerIO.h - Internal header for IO utils ----------------*- C++ -* ===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // IO interface.
 //===----------------------------------------------------------------------===//
+
 #ifndef LLVM_FUZZER_IO_H
 #define LLVM_FUZZER_IO_H
 
 #include "FuzzerDefs.h"
 
 namespace fuzzer {
 
 long GetEpoch(const std::string &Path);

 
 int CloseFile(int Fd);
 
 int DuplicateFile(int Fd);
 
 void DeleteFile(const std::string &Path);
 
 }  // namespace fuzzer
+
 #endif  // LLVM_FUZZER_IO_H

lib/Fuzzer/FuzzerSHA1.h

 //===- FuzzerSHA1.h - Internal header for the SHA1 utils --------*- C++ -* ===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // SHA1 utils.
 //===----------------------------------------------------------------------===//
+
 #ifndef LLVM_FUZZER_SHA1_H
 #define LLVM_FUZZER_SHA1_H
 
 #include "FuzzerDefs.h"
 #include <cstddef>
 #include <stdint.h>
 
 namespace fuzzer {
 
 // Private copy of SHA1 implementation.
 static const int kSHA1NumBytes = 20;
 
 // Computes SHA1 hash of 'Len' bytes in 'Data', writes kSHA1NumBytes to 'Out'.
 void ComputeSHA1(const uint8_t *Data, size_t Len, uint8_t *Out);
 
 std::string Sha1ToString(const uint8_t Sha1[kSHA1NumBytes]);
 
 std::string Hash(const Unit &U);
 
 }  // namespace fuzzer
+
 #endif  // LLVM_FUZZER_SHA1_H

lib/Fuzzer/FuzzerUtil.h

 //===- FuzzerUtil.h - Internal header for the Fuzzer Utils ------*- C++ -* ===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // Util functions.
 //===----------------------------------------------------------------------===//
+
 #ifndef LLVM_FUZZER_UTIL_H
 #define LLVM_FUZZER_UTIL_H
 
 #include "FuzzerDefs.h"
 
 namespace fuzzer {
 
 void PrintHexArray(const Unit &U, const char *PrintAfter = "");

 int ExecuteCommand(const std::string &Command);
 
 FILE* OpenProcessPipe(const char *Command, const char *Mode);
 
 const void *SearchMemory(const void *haystack, size_t haystacklen,
                          const void *needle, size_t needlelen);
 
 }  // namespace fuzzer
+
 #endif  // LLVM_FUZZER_UTIL_H