Include full clangformat config.

Hopefully stabilizes behaviour between versions.

.clang-format

@@ -1,7 +1,115 @@
 ---
 Language:        Cpp
-BasedOnStyle:  LLVM
+AccessModifierOffset: -2
-AllowShortFunctionsOnASingleLine: false
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlines: Right
+AlignOperands:   true
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: None
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: MultiLine
+BinPackArguments: true
+BinPackParameters: true
+BraceWrapping:
+  AfterClass:      false
+  AfterControlStatement: false
+  AfterEnum:       false
+  AfterFunction:   false
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     false
+  AfterUnion:      false
+  AfterExternBlock: false
+  BeforeCatch:     false
+  BeforeElse:      false
+  IndentBraces:    false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Attach
+BreakBeforeInheritanceComma: false
+BreakInheritanceList: BeforeColon
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: BeforeColon
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: true
+ColumnLimit:     80
+CommentPragmas:  '^ IWYU pragma:'
+CompactNamespaces: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DerivePointerAlignment: false
+DisableFormat:   false
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: true
+ForEachMacros:
+  - foreach
+IncludeBlocks:   Preserve
+IncludeCategories:
+  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
+    Priority:        2
+  - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
+    Priority:        3
+  - Regex:           '.*'
+    Priority:        1
+IncludeIsMainRegex: '(Test)?$'
+IndentCaseLabels: false
+IndentPPDirectives: None
 IndentWidth:     4
+IndentWrappedFunctionNames: false
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: true
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBinPackProtocolList: Auto
+ObjCBlockIndentWidth: 2
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyBreakTemplateDeclaration: 10
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 60
+PointerAlignment: Right
+ReflowComments:  true
+SortIncludes:    true
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles:  false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard:        Cpp11
+TabWidth:        8
+UseTab:          Never
 ...
 

common/randombytes.c

@@ -33,11 +33,10 @@ THE SOFTWARE.
 
 #if defined(_WIN32)
 /* Windows */
-# include <windows.h>
 #include <wincrypt.h> /* CryptAcquireContext, CryptGenRandom */
+#include <windows.h>
 #endif /* defined(_WIN32) */
 
-
 #if defined(__linux__)
 /* Linux */
 // We would need to include <linux/random.h>, but not every target has access
@@ -65,7 +64,6 @@ THE SOFTWARE.
 
 #endif /* defined(__linux__) */
 
-
 #if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
 /* Dragonfly, FreeBSD, NetBSD, OpenBSD (has arc4random) */
 #include <sys/param.h>
@@ -81,31 +79,30 @@ THE SOFTWARE.
 #include <stdbool.h>
 #endif /* defined(__EMSCRIPTEN__) */
 
-
 #if defined(_WIN32)
-static int randombytes_win32_randombytes(void* buf, const size_t n)
+static int randombytes_win32_randombytes(void *buf, const size_t n) {
-{
     HCRYPTPROV ctx;
     BOOL tmp;
 
     tmp = CryptAcquireContext(&ctx, NULL, NULL, PROV_RSA_FULL,
                               CRYPT_VERIFYCONTEXT);
-	if (tmp == FALSE) return -1;
+    if (tmp == FALSE)
+        return -1;
 
     tmp = CryptGenRandom(ctx, n, (BYTE *)buf);
-	if (tmp == FALSE) return -1;
+    if (tmp == FALSE)
+        return -1;
 
     tmp = CryptReleaseContext(ctx, 0);
-	if (tmp == FALSE) return -1;
+    if (tmp == FALSE)
+        return -1;
 
     return 0;
 }
 #endif /* defined(_WIN32) */
 
-
 #if defined(__linux__) && defined(SYS_getrandom)
-static int randombytes_linux_randombytes_getrandom(void *buf, size_t n)
+static int randombytes_linux_randombytes_getrandom(void *buf, size_t n) {
-{
     /* I have thought about using a separate PRF, seeded by getrandom, but
      * it turns out that the performance of getrandom is good enough
      * (250 MB/s on my laptop).
@@ -129,15 +126,12 @@ static int randombytes_linux_randombytes_getrandom(void *buf, size_t n)
 }
 #endif /* defined(__linux__) && defined(SYS_getrandom) */
 
-
 #if defined(__linux__) && !defined(SYS_getrandom)
-static int randombytes_linux_read_entropy_ioctl(int device, int *entropy)
+static int randombytes_linux_read_entropy_ioctl(int device, int *entropy) {
-{
     return ioctl(device, RNDGETENTCNT, entropy);
 }
 
-static int randombytes_linux_read_entropy_proc(FILE *stream, int *entropy)
+static int randombytes_linux_read_entropy_proc(FILE *stream, int *entropy) {
-{
     int retcode;
     do {
         rewind(stream);
@@ -149,8 +143,7 @@ static int randombytes_linux_read_entropy_proc(FILE *stream, int *entropy)
     return 0;
 }
 
-static int randombytes_linux_wait_for_entropy(int device)
+static int randombytes_linux_wait_for_entropy(int device) {
-{
     /* We will block on /dev/random, because any increase in the OS' entropy
      * level will unblock the request. I use poll here (as does libsodium),
      * because we don't *actually* want to read from the device. */
@@ -159,7 +152,8 @@ static int randombytes_linux_wait_for_entropy(int device)
     struct pollfd pfd;
     int fd;
     FILE *proc_file;
-	int retcode, retcode_error = 0; // Used as return codes throughout this function
+    int retcode,
+        retcode_error = 0; // Used as return codes throughout this function
     int entropy = 0;
 
     /* If the device has enough entropy already, we will want to return early */
@@ -196,9 +190,11 @@ static int randombytes_linux_wait_for_entropy(int device)
             continue;
         } else if (retcode == 1) {
             if (strategy == IOCTL) {
-				retcode = randombytes_linux_read_entropy_ioctl(device, &entropy);
+                retcode =
+                    randombytes_linux_read_entropy_ioctl(device, &entropy);
             } else if (strategy == PROC) {
-				retcode = randombytes_linux_read_entropy_proc(proc_file, &entropy);
+                retcode =
+                    randombytes_linux_read_entropy_proc(proc_file, &entropy);
             } else {
                 return -1; // Unreachable
             }
@@ -231,17 +227,17 @@ static int randombytes_linux_wait_for_entropy(int device)
     return retcode;
 }
 
-
+static int randombytes_linux_randombytes_urandom(void *buf, size_t n) {
-static int randombytes_linux_randombytes_urandom(void *buf, size_t n)
-{
     int fd;
     size_t offset = 0, count;
     ssize_t tmp;
     do {
         fd = open("/dev/urandom", O_RDONLY);
     } while (fd == -1 && errno == EINTR);
-	if (fd == -1) return -1;
+    if (fd == -1)
-	if (randombytes_linux_wait_for_entropy(fd) == -1) return -1;
+        return -1;
+    if (randombytes_linux_wait_for_entropy(fd) == -1)
+        return -1;
 
     while (n > 0) {
         count = n <= SSIZE_MAX ? n : SSIZE_MAX;
@@ -249,7 +245,8 @@ static int randombytes_linux_randombytes_urandom(void *buf, size_t n)
         if (tmp == -1 && (errno == EAGAIN || errno == EINTR)) {
             continue;
         }
-		if (tmp == -1) return -1; /* Unrecoverable IO error */
+        if (tmp == -1)
+            return -1; /* Unrecoverable IO error */
         offset += tmp;
         n -= tmp;
     }
@@ -258,19 +255,17 @@ static int randombytes_linux_randombytes_urandom(void *buf, size_t n)
 }
 #endif /* defined(__linux__) && !defined(SYS_getrandom) */
 
-
 #if defined(BSD)
-static int randombytes_bsd_randombytes(void *buf, size_t n)
+static int randombytes_bsd_randombytes(void *buf, size_t n) {
-{
     arc4random_buf(buf, n);
     return 0;
 }
 #endif /* defined(BSD) */
 
-
 #if defined(__EMSCRIPTEN__)
 static int randombytes_js_randombytes_nodejs(void *buf, size_t n) {
-	const int ret = EM_ASM_INT({
+    const int ret = EM_ASM_INT(
+        {
             var crypto;
             try {
                 crypto = require('crypto');
@@ -283,7 +278,8 @@ static int randombytes_js_randombytes_nodejs(void *buf, size_t n) {
             } catch (error) {
                 return -1;
             }
-	}, buf, n);
+        },
+        buf, n);
     switch (ret) {
     case 0:
         return 0;
@@ -298,9 +294,7 @@ static int randombytes_js_randombytes_nodejs(void *buf, size_t n) {
 }
 #endif /* defined(__EMSCRIPTEN__) */
 
-
+int randombytes(uint8_t *buf, size_t n) {
-int randombytes(uint8_t *buf, size_t n)
-{
 #if defined(__EMSCRIPTEN__)
     return randombytes_js_randombytes_nodejs(buf, n);
 #elif defined(__linux__)

test/crypto_kem/functest.c

@@ -107,7 +107,9 @@ static int test_invalid_sk_a(void) {
 
         // Alice uses Bobs response to get her secret key
         if ((returncode = crypto_kem_dec(key_a, sendb, sk_a)) > 0) {
-            printf("ERROR failing crypto_kem_dec returned %d instead of negative or zero code\n", returncode);
+            printf("ERROR failing crypto_kem_dec returned %d instead of "
+                   "negative or zero code\n",
+                   returncode);
             return -1;
         }
 
@@ -143,7 +145,9 @@ static int test_invalid_ciphertext(void) {
 
         // Alice uses Bobs response to get her secret key
         if ((returncode = crypto_kem_dec(key_a, sendb, sk_a)) > 0) {
-            printf("ERROR crypto_kem_dec should either fail (negative returncode) or succeed (return 0) but returned %d\n", returncode);
+            printf("ERROR crypto_kem_dec should either fail (negative "
+                   "returncode) or succeed (return 0) but returned %d\n",
+                   returncode);
             return -1;
         }
 

test/crypto_sign/functest.c

@@ -41,7 +41,6 @@ static int check_canary(const unsigned char *d) {
         return -1;                                                             \
     }
 
-
 static int test_sign(void) {
     unsigned char pk[CRYPTO_PUBLICKEYBYTES + 16];
     unsigned char sk[CRYPTO_SECRETKEYBYTES + 16];
@@ -70,7 +69,8 @@ static int test_sign(void) {
 
         // By relying on m == sm we prevent having to allocate CRYPTO_BYTES
         // twice
-        if ((returncode = crypto_sign_open(sm + 8, &mlen, sm + 8, smlen, pk + 8)) != 0) {
+        if ((returncode =
+                 crypto_sign_open(sm + 8, &mlen, sm + 8, smlen, pk + 8)) != 0) {
             printf("ERROR Signature did not verify correctly!\n");
             if (returncode > 0) {
                 puts("ERROR return code should be < 0 on failure");