Make attributes preceed function declarations

This also adds soem additional ATTR_ONNULL and ATTR_RETNONNULL markers
that were absent previously.

The order for attributes is roughly:
noreturn, format, nonnull, returns_nonnull, malloc, alloc_size, access

XUtils.h

@@ -24,19 +24,26 @@ in the source distribution for its full text.
 #include "Macros.h"
 
 
-void fail(void) ATTR_NORETURN;
+ATTR_NORETURN
+void fail(void);
 
-void* xMalloc(size_t size) ATTR_ALLOC_SIZE1(1) ATTR_MALLOC;
+ATTR_RETNONNULL ATTR_MALLOC ATTR_ALLOC_SIZE1(1)
+void* xMalloc(size_t size);
 
-void* xMallocArray(size_t nmemb, size_t size) ATTR_ALLOC_SIZE2(1, 2) ATTR_MALLOC;
+ATTR_RETNONNULL ATTR_MALLOC ATTR_ALLOC_SIZE2(1, 2)
+void* xMallocArray(size_t nmemb, size_t size);
 
-void* xCalloc(size_t nmemb, size_t size) ATTR_ALLOC_SIZE2(1, 2) ATTR_MALLOC;
+ATTR_RETNONNULL ATTR_MALLOC ATTR_ALLOC_SIZE2(1, 2)
+void* xCalloc(size_t nmemb, size_t size);
 
-void* xRealloc(void* ptr, size_t size) ATTR_ALLOC_SIZE1(2);
+ATTR_RETNONNULL ATTR_ALLOC_SIZE1(2)
+void* xRealloc(void* ptr, size_t size);
 
-void* xReallocArray(void* ptr, size_t nmemb, size_t size) ATTR_ALLOC_SIZE2(2, 3);
+ATTR_RETNONNULL ATTR_ALLOC_SIZE2(2, 3)
+void* xReallocArray(void* ptr, size_t nmemb, size_t size);
 
-void* xReallocArrayZero(void* ptr, size_t prevmemb, size_t newmemb, size_t size) ATTR_ALLOC_SIZE2(3, 4);
+ATTR_RETNONNULL ATTR_ALLOC_SIZE2(3, 4)
+void* xReallocArrayZero(void* ptr, size_t prevmemb, size_t newmemb, size_t size);
 
 /*
  * String_startsWith gives better performance if strlen(match) can be computed
@@ -64,21 +71,21 @@ static inline bool String_eq_nullable(const char* s1, const char* s2) {
    return false;
 }
 
-ATTR_NONNULL
-char* String_cat(const char* s1, const char* s2) ATTR_MALLOC;
+ATTR_NONNULL ATTR_RETNONNULL ATTR_MALLOC
+char* String_cat(const char* s1, const char* s2);
 
-ATTR_NONNULL
-char* String_trim(const char* in) ATTR_MALLOC;
+ATTR_NONNULL ATTR_RETNONNULL ATTR_MALLOC
+char* String_trim(const char* in);
 
-ATTR_NONNULL_N(1)
+ATTR_NONNULL_N(1) ATTR_RETNONNULL
 char** String_split(const char* s, char sep, size_t* n);
 
 void String_freeArray(char** s);
 
-ATTR_NONNULL
-char* String_readLine(FILE* fp) ATTR_MALLOC;
+ATTR_RETNONNULL ATTR_MALLOC
+char* String_readLine(FILE* fp);
 
-ATTR_NONNULL
+ATTR_NONNULL ATTR_RETNONNULL
 static inline char* String_strchrnul(const char* s, int c) {
 #ifdef HAVE_STRCHRNUL
    return strchrnul(s, c);
@@ -91,32 +98,33 @@ static inline char* String_strchrnul(const char* s, int c) {
 }
 
 /* Always null-terminates dest. Caller must pass a strictly positive size. */
-ATTR_ACCESS3_W(1, 3)
-ATTR_ACCESS3_R(2, 3)
+ATTR_NONNULL ATTR_ACCESS3_W(1, 3) ATTR_ACCESS3_R(2, 3)
 size_t String_safeStrncpy(char* restrict dest, const char* restrict src, size_t size);
 
-ATTR_FORMAT(printf, 2, 3)
-ATTR_NONNULL_N(1, 2)
+ATTR_FORMAT(printf, 2, 3) ATTR_NONNULL_N(1, 2)
 int xAsprintf(char** strp, const char* fmt, ...);
 
-ATTR_FORMAT(printf, 3, 4)
-ATTR_ACCESS3_W(1, 2)
+ATTR_FORMAT(printf, 3, 4) ATTR_NONNULL_N(1, 3) ATTR_ACCESS3_W(1, 2)
 int xSnprintf(char* buf, size_t len, const char* fmt, ...);
 
-char* xStrdup(const char* str) ATTR_NONNULL ATTR_MALLOC;
+ATTR_NONNULL ATTR_RETNONNULL ATTR_MALLOC
+char* xStrdup(const char* str);
+
+ATTR_NONNULL
 void free_and_xStrdup(char** ptr, const char* str);
 
-ATTR_ACCESS3_R(1, 2)
-char* xStrndup(const char* str, size_t len) ATTR_NONNULL ATTR_MALLOC;
+ATTR_NONNULL ATTR_RETNONNULL ATTR_MALLOC ATTR_ACCESS3_R(1, 2)
+char* xStrndup(const char* str, size_t len);
 
-ATTR_ACCESS3_W(2, 3)
+ATTR_NONNULL ATTR_ACCESS3_W(2, 3)
 ssize_t xReadfile(const char* pathname, void* buffer, size_t count);
-ATTR_ACCESS3_W(3, 4)
+ATTR_NONNULL ATTR_ACCESS3_W(3, 4)
 ssize_t xReadfileat(openat_arg_t dirfd, const char* pathname, void* buffer, size_t count);
 
-ATTR_ACCESS3_R(2, 3)
+ATTR_NONNULL ATTR_ACCESS3_R(2, 3)
 ssize_t full_write(int fd, const void* buf, size_t count);
 
+ATTR_NONNULL
 static inline ssize_t full_write_str(int fd, const char* str) {
    return full_write(fd, str, strlen(str));
 }
@@ -129,6 +137,7 @@ int compareRealNumbers(double a, double b);
 /* Computes the sum of all positive floating point values in an array.
    NaN values in the array are skipped. The returned sum will always be
    nonnegative. */
+ATTR_NONNULL ATTR_ACCESS3_R(1, 2)
 double sumPositiveValues(const double* array, size_t count);
 
 /* Returns the number of trailing zero bits */