Convert column widths to 120 and reformat (awslabs#102)

It's just styling, merging it over.

Author: ColdenCullen

.clang-format

@@ -21,7 +21,7 @@ BreakBeforeBinaryOperators: None
 BreakBeforeBraces: Attach
 BreakBeforeTernaryOperators: true
 BreakStringLiterals: true
-ColumnLimit:     80
+ColumnLimit:     120
 ContinuationIndentWidth: 4
 DerivePointerAlignment: false
 IncludeBlocks:   Preserve

include/aws/common/array_list.h

@@ -60,11 +60,7 @@ int aws_array_list_init_dynamic(
  * is full, new items will be rejected.
  */
 AWS_COMMON_API
-void aws_array_list_init_static(
-    struct aws_array_list *list,
-    void *raw_array,
-    size_t item_count,
-    size_t item_size);
+void aws_array_list_init_static(struct aws_array_list *list, void *raw_array, size_t item_count, size_t item_size);
 
 /**
  * Deallocates any memory that was allocated for this list, and resets list for
@@ -138,18 +134,14 @@ int aws_array_list_shrink_to_fit(struct aws_array_list *list);
  * copy.
  */
 AWS_COMMON_API
-int aws_array_list_copy(
-    const struct aws_array_list *from,
-    struct aws_array_list *to);
+int aws_array_list_copy(const struct aws_array_list *from, struct aws_array_list *to);
 
 /**
  * Swap contents between two dynamic lists. Both lists must use the same
  * allocator.
  */
 AWS_COMMON_API
-void aws_array_list_swap_contents(
-    struct aws_array_list *list_a,
-    struct aws_array_list *list_b);
+void aws_array_list_swap_contents(struct aws_array_list *list_a, struct aws_array_list *list_b);
 
 /**
  * Returns the number of elements that can fit in the internal array. If list is
@@ -169,20 +161,14 @@ size_t aws_array_list_length(const struct aws_array_list *list);
  * AWS_ERROR_INVALID_INDEX will be raised.
  */
 AWS_COMMON_API
-int aws_array_list_get_at(
-    const struct aws_array_list *list,
-    void *val,
-    size_t index);
+int aws_array_list_get_at(const struct aws_array_list *list, void *val, size_t index);
 
 /**
  * Copies the memory address of the element at index to *val. If element does
  * not exist, AWS_ERROR_INVALID_INDEX will be raised.
  */
 AWS_COMMON_API
-int aws_array_list_get_at_ptr(
-    const struct aws_array_list *list,
-    void **val,
-    size_t index);
+int aws_array_list_get_at_ptr(const struct aws_array_list *list, void **val, size_t index);
 
 /**
  * Copies the the memory pointed to by val into the array at index. If in
@@ -191,10 +177,7 @@ int aws_array_list_get_at_ptr(
  * the bounds of the array.
  */
 AWS_COMMON_API
-int aws_array_list_set_at(
-    struct aws_array_list *list,
-    const void *val,
-    size_t index);
+int aws_array_list_set_at(struct aws_array_list *list, const void *val, size_t index);
 
 /**
  * Swap elements at the specified indices.
@@ -206,9 +189,7 @@ void aws_array_list_swap(struct aws_array_list *list, size_t a, size_t b);
  * Sort elements in the list in-place according to the comparator function.
  */
 AWS_COMMON_API
-void aws_array_list_sort(
-    struct aws_array_list *list,
-    aws_array_list_comparator compare_fn);
+void aws_array_list_sort(struct aws_array_list *list, aws_array_list_comparator compare_fn);
 
 #ifdef __cplusplus
 }

include/aws/common/byte_buf.h

@@ -50,10 +50,8 @@ extern "C" {
 #endif
 
 AWS_COMMON_API
-int aws_byte_buf_init(
-    struct aws_allocator *allocator,
-    struct aws_byte_buf *buf,
-    size_t len);
+int aws_byte_buf_init(struct aws_allocator *allocator, struct aws_byte_buf *buf, size_t len);
+
 AWS_COMMON_API
 void aws_byte_buf_clean_up(struct aws_byte_buf *buf);
 
@@ -90,10 +88,7 @@ AWS_COMMON_API void aws_byte_buf_secure_clean_up(struct aws_byte_buf *buf);
  * long enough to use the results.
  */
 AWS_COMMON_API
-int aws_byte_buf_split_on_char(
-    struct aws_byte_buf *input_str,
-    char split_on,
-    struct aws_array_list *output);
+int aws_byte_buf_split_on_char(struct aws_byte_buf *input_str, char split_on, struct aws_array_list *output);
 
 /**
  * No copies, no buffer allocations. Fills in output with a list of
@@ -156,9 +151,7 @@ static inline struct aws_byte_buf aws_byte_buf_from_c_str(const char *c_str) {
     return buf;
 }
 
-static inline struct aws_byte_buf aws_byte_buf_from_array(
-    const uint8_t *bytes,
-    size_t len) {
+static inline struct aws_byte_buf aws_byte_buf_from_array(const uint8_t *bytes, size_t len) {
     struct aws_byte_buf buf;
     buf.buffer = (uint8_t *)bytes;
     buf.len = len;
@@ -167,17 +160,14 @@ static inline struct aws_byte_buf aws_byte_buf_from_array(
     return buf;
 }
 
-static inline struct aws_byte_cursor aws_byte_cursor_from_buf(
-    const struct aws_byte_buf *buf) {
+static inline struct aws_byte_cursor aws_byte_cursor_from_buf(const struct aws_byte_buf *buf) {
     struct aws_byte_cursor cur;
     cur.ptr = buf->buffer;
     cur.len = buf->len;
     return cur;
 }
 
-static inline struct aws_byte_cursor aws_byte_cursor_from_array(
-    const void *bytes,
-    size_t len) {
+static inline struct aws_byte_cursor aws_byte_cursor_from_array(const void *bytes, size_t len) {
     struct aws_byte_cursor cur;
     cur.ptr = (uint8_t *)bytes;
     cur.len = len;
@@ -259,12 +249,9 @@ static inline size_t aws_nospec_index(size_t index, size_t bound) {
  * Note that if len is above (SIZE_MAX / 2), this function will also treat it as
  * a buffer overflow, and return NULL without changing *buf.
  */
-static inline struct aws_byte_cursor aws_byte_cursor_advance(
-    struct aws_byte_cursor *cursor,
-    size_t len) {
+static inline struct aws_byte_cursor aws_byte_cursor_advance(struct aws_byte_cursor *cursor, size_t len) {
     struct aws_byte_cursor rv;
-    if (cursor->len > (SIZE_MAX >> 1) || len > (SIZE_MAX >> 1) ||
-        len > cursor->len) {
+    if (cursor->len > (SIZE_MAX >> 1) || len > (SIZE_MAX >> 1) || len > cursor->len) {
         rv.ptr = NULL;
         rv.len = 0;
     } else {
@@ -288,13 +275,10 @@ static inline struct aws_byte_cursor aws_byte_cursor_advance(
  * cursor->ptr points outside the true ptr length.
  */
 
-static inline struct aws_byte_cursor aws_byte_cursor_advance_nospec(
-    struct aws_byte_cursor *cursor,
-    size_t len) {
+static inline struct aws_byte_cursor aws_byte_cursor_advance_nospec(struct aws_byte_cursor *cursor, size_t len) {
     struct aws_byte_cursor rv;
 
-    if (len <= cursor->len && len <= (SIZE_MAX >> 1) &&
-        cursor->len <= (SIZE_MAX >> 1)) {
+    if (len <= cursor->len && len <= (SIZE_MAX >> 1) && cursor->len <= (SIZE_MAX >> 1)) {
         /*
          * Pass the length through aws_nospec_index. We do this after the
          * branch, as otherwise we'd treat an out-of-bounds read as a
@@ -323,10 +307,7 @@ static inline struct aws_byte_cursor aws_byte_cursor_advance_nospec(
  * If there is insufficient space in the cursor, returns false, leaving the
  * cursor unchanged.
  */
-static inline bool aws_byte_cursor_read(
-    struct aws_byte_cursor *AWS_RESTRICT cur,
-    void *AWS_RESTRICT dest,
-    size_t len) {
+static inline bool aws_byte_cursor_read(struct aws_byte_cursor *AWS_RESTRICT cur, void *AWS_RESTRICT dest, size_t len) {
     struct aws_byte_cursor slice = aws_byte_cursor_advance_nospec(cur, len);
 
     if (slice.ptr) {
@@ -360,9 +341,7 @@ static inline bool aws_byte_cursor_read_and_fill_buffer(
  * If there is insufficient space in the cursor, returns false, leaving the
  * cursor unchanged.
  */
-static inline bool aws_byte_cursor_read_u8(
-    struct aws_byte_cursor *AWS_RESTRICT cur,
-    uint8_t *AWS_RESTRICT var) {
+static inline bool aws_byte_cursor_read_u8(struct aws_byte_cursor *AWS_RESTRICT cur, uint8_t *AWS_RESTRICT var) {
     return aws_byte_cursor_read(cur, var, 1);
 }
 
@@ -374,9 +353,7 @@ static inline bool aws_byte_cursor_read_u8(
  * If there is insufficient space in the cursor, returns false, leaving the
  * cursor unchanged.
  */
-static inline bool aws_byte_cursor_read_be16(
-    struct aws_byte_cursor *cur,
-    uint16_t *var) {
+static inline bool aws_byte_cursor_read_be16(struct aws_byte_cursor *cur, uint16_t *var) {
     bool rv = aws_byte_cursor_read(cur, var, 2);
 
     if (AWS_LIKELY(rv)) {
@@ -394,9 +371,7 @@ static inline bool aws_byte_cursor_read_be16(
  * If there is insufficient space in the cursor, returns false, leaving the
  * cursor unchanged.
  */
-static inline bool aws_byte_cursor_read_be32(
-    struct aws_byte_cursor *cur,
-    uint32_t *var) {
+static inline bool aws_byte_cursor_read_be32(struct aws_byte_cursor *cur, uint32_t *var) {
     bool rv = aws_byte_cursor_read(cur, var, 4);
 
     if (AWS_LIKELY(rv)) {
@@ -414,9 +389,7 @@ static inline bool aws_byte_cursor_read_be32(
  * If there is insufficient space in the cursor, returns false, leaving the
  * cursor unchanged.
  */
-static inline bool aws_byte_cursor_read_be64(
-    struct aws_byte_cursor *cur,
-    uint64_t *var) {
+static inline bool aws_byte_cursor_read_be64(struct aws_byte_cursor *cur, uint64_t *var) {
     bool rv = aws_byte_cursor_read(cur, var, sizeof(*var));
 
     if (AWS_LIKELY(rv)) {
@@ -468,9 +441,7 @@ static inline bool aws_byte_cursor_write_from_whole_buffer(
  * If there is insufficient space in the cursor, returns false, leaving the
  cursor unchanged.
  */
-static inline bool aws_byte_cursor_write_u8(
-    struct aws_byte_cursor *AWS_RESTRICT cur,
-    uint8_t c) {
+static inline bool aws_byte_cursor_write_u8(struct aws_byte_cursor *AWS_RESTRICT cur, uint8_t c) {
     return aws_byte_cursor_write(cur, &c, 1);
 }
 
@@ -481,9 +452,7 @@ static inline bool aws_byte_cursor_write_u8(
  * If there is insufficient space in the cursor, returns false, leaving the
  * cursor unchanged.
  */
-static inline bool aws_byte_cursor_write_be16(
-    struct aws_byte_cursor *cur,
-    uint16_t x) {
+static inline bool aws_byte_cursor_write_be16(struct aws_byte_cursor *cur, uint16_t x) {
     x = aws_hton16(x);
     return aws_byte_cursor_write(cur, (uint8_t *)&x, 2);
 }
@@ -495,9 +464,7 @@ static inline bool aws_byte_cursor_write_be16(
  * If there is insufficient space in the cursor, returns false, leaving the
  * cursor unchanged.
  */
-static inline bool aws_byte_cursor_write_be32(
-    struct aws_byte_cursor *cur,
-    uint32_t x) {
+static inline bool aws_byte_cursor_write_be32(struct aws_byte_cursor *cur, uint32_t x) {
     x = aws_hton32(x);
     return aws_byte_cursor_write(cur, (uint8_t *)&x, 4);
 }
@@ -509,9 +476,7 @@ static inline bool aws_byte_cursor_write_be32(
  * If there is insufficient space in the cursor, returns false, leaving the
  * cursor unchanged.
  */
-static inline bool aws_byte_cursor_write_be64(
-    struct aws_byte_cursor *cur,
-    uint64_t x) {
+static inline bool aws_byte_cursor_write_be64(struct aws_byte_cursor *cur, uint64_t x) {
     x = aws_hton64(x);
     return aws_byte_cursor_write(cur, (uint8_t *)&x, 8);
 }

include/aws/common/common.h

@@ -21,10 +21,8 @@
 #include <stddef.h>
 #include <string.h>
 
-#define AWS_STATIC_ASSERT0(cond, msg)                                      \
-        typedef char static_assertion_##msg[(!!(cond)) * 2 - 1]
-#define AWS_STATIC_ASSERT1(cond, line)                                     \
-        AWS_STATIC_ASSERT0(cond, static_assertion_at_line_##line)
+#define AWS_STATIC_ASSERT0(cond, msg) typedef char static_assertion_##msg[(!!(cond)) * 2 - 1]
+#define AWS_STATIC_ASSERT1(cond, line) AWS_STATIC_ASSERT0(cond, static_assertion_at_line_##line)
 #define AWS_STATIC_ASSERT(cond) AWS_STATIC_ASSERT1(cond, __LINE__)
 
 #if defined(_MSC_VER)
@@ -53,8 +51,7 @@
 #ifndef NO_STDINT
 #    include <stdint.h> /* NOLINT(fuchsia-restrict-system-includes) */
 #else
-#    if defined(__x86_64__) || defined(_M_AMD64) ||                        \
-            defined(__aarch64__) || defined(__ia64__) ||                       \
+#    if defined(__x86_64__) || defined(_M_AMD64) || defined(__aarch64__) || defined(__ia64__) ||                   \
             defined(__powerpc64__)
 #        define PTR_SIZE 8
 #    else
@@ -138,11 +135,7 @@ struct aws_allocator {
     void *(*mem_acquire)(struct aws_allocator *allocator, size_t size);
     void (*mem_release)(struct aws_allocator *allocator, void *ptr);
     /* Optional method; if not supported, this pointer must be NULL */
-    void *(*mem_realloc)(
-        struct aws_allocator *allocator,
-        void *oldptr,
-        size_t oldsize,
-        size_t newsize);
+    void *(*mem_realloc)(struct aws_allocator *allocator, void *oldptr, size_t oldsize, size_t newsize);
     void *impl;
 };
 
@@ -197,11 +190,7 @@ void aws_mem_release(struct aws_allocator *allocator, void *ptr);
  * AWS_ERROR_OOM error.
  */
 AWS_COMMON_API
-int aws_mem_realloc(
-    struct aws_allocator *allocator,
-    void **ptr,
-    size_t oldsize,
-    size_t newsize);
+int aws_mem_realloc(struct aws_allocator *allocator, void **ptr, size_t oldsize, size_t newsize);
 /*
  * Maintainer note: The above function doesn't return the pointer (as with
  * standard C realloc) as this pattern becomes error-prone when OOMs occur.
@@ -319,21 +308,20 @@ static inline void aws_secure_zero(void *pBuf, size_t bufsize) {
      * (somehow) still used after the zero, and therefore that the optimizer
      * can't eliminate the memset.
      */
-    __asm__ __volatile__(
-        "" /* The asm doesn't actually do anything. */
-        :  /* no outputs */
-        /* Tell the compiler that the asm code has access to the pointer to the
-         * buffer, and therefore it might be reading the (now-zeroed) buffer.
-         * Without this. clang/LLVM 9.0.0 optimizes away a memset of a stack
-         * buffer.
-         */
-        : "r"(pBuf)
-        /* Also clobber memory. While this seems like it might be unnecessary -
-         * after all, it's enough that the asm might read the buffer, right? -
-         * in practice GCC 7.3.0 seems to optimize a zero of a stack buffer
-         * without it.
-         */
-        : "memory");
+    __asm__ __volatile__("" /* The asm doesn't actually do anything. */
+                         :  /* no outputs */
+                         /* Tell the compiler that the asm code has access to the pointer to the
+                          * buffer, and therefore it might be reading the (now-zeroed) buffer.
+                          * Without this. clang/LLVM 9.0.0 optimizes away a memset of a stack
+                          * buffer.
+                          */
+                         : "r"(pBuf)
+                         /* Also clobber memory. While this seems like it might be unnecessary -
+                          * after all, it's enough that the asm might read the buffer, right? -
+                          * in practice GCC 7.3.0 seems to optimize a zero of a stack buffer
+                          * without it.
+                          */
+                         : "memory");
 #    else  // not GCC/clang
     /* We don't have access to inline asm, since we're on a non-GCC platform.
      * Move the pointer through a volatile pointer in an attempt to confuse the