Style fixes (too big to really review, just make sure the build passes). Updates code to coding standards. (awslabs#103)

* code style updates, and coding standards applied to code-base.

* Run clang-format

* Fixed botched merge on windows/clock.c.

Author: JonathanHenson

README.md

@@ -138,7 +138,7 @@ Example:
         do_something();
     } else {
         do_something_else();
-    }    
+    }
 * Avoid C99 features in header files. For some types such as bool, uint32_t etc..., these are defined if not available for the language
 standard being used in `aws/common/common.h`, so feel free to use them.
 * For C++ compatibility, don't put const members in structs.
@@ -151,42 +151,37 @@ standard being used in `aws/common/common.h`, so feel free to use them.
 
 Example:
 
-    
+
     #ifdef FOO
         do_something();
-    
+
     #   ifdef BAR
         do_something_else();
     #   endif
     #endif
-          
+
 
 * For all error code names with the exception of aws-c-common, use `AWS_ERROR_<lib name>_<error name>`.
 * All error strings should be written using correct English grammar.
 * SNAKE_UPPER_CASE constants, macros, and enum members.
 * snake_lower_case everything else.
-* File scope (static) variables and functions are prefixed with s_.
-* For constants, use anonymous enums.
+* `static` (local file scope) variables that are not `const` are prefixed by `s_` and lower snake case.
+* Global variables not prefixed as `const` are prefixed by `g_` and lower snake case.
+* Thread local variables are prefixed as `tl_` and lower snake case.
+* Macros and `const` variables are upper snake case.
+* For constants, prefer anonymous enums.
+* Don't typedef structs. It breaks forward declaration ability.
+* Don't typedef enums. It breaks forward declaration ability.
+* typedef function definitions for use as function pointers as values and suffixed with _fn.
 
 Example:
-  
-    enum { THE_ANSWER_TO_LIFE_THE_UNIVERSE_AND_EVERYTHING = 42 };
-    
-* Use typedef struct by suffixing _t to the typedef for the struct name. 
-
-Example:
-
-    typdef struct my_struct { ... } my_struct_t;
-* Use typedef enum by suffixing _t to the typedef for the enum name.
 
-Example:
+    typedef int(fn_name_fn)(void *);
 
-    typdef struct my_enum { ... } my_enum_t;
-* typedef function definitions for use as function pointers as values and suffixed with _fn. 
+Not:
 
-Example:
+    typedef int(*fn_name_fn)(void *);
 
-    typedef int(fn_name_fn)(void *);
 * Every source and header file must have a copyright header (The standard AWS one for apache 2).
 * Use standard include guards (e.g. #IFNDEF HEADER_NAME #define HEADER_NAME etc...).
 * Include order should be:
@@ -203,11 +198,15 @@ not always required if a conflict is not likely and it provides better ergonomic
 
 Example:
 
-    AWS_COMMON_API int aws_module_init(aws_module_t *module);
-    AWS_COMMON_API void aws_module_clean_up(aws_module_t *module);
-    AWS_COMMON_API aws_module_t *aws_module_new(aws_allocator_t *allocator);
-    AWS_COMMON_API void aws_module_destroy(aws_module_t *module);
-        
+    AWS_COMMON_API
+ int aws_module_init(aws_module_t *module);
+    AWS_COMMON_API
+ void aws_module_clean_up(aws_module_t *module);
+    AWS_COMMON_API
+ aws_module_t *aws_module_new(aws_allocator_t *allocator);
+    AWS_COMMON_API
+ void aws_module_destroy(aws_module_t *module);
+
 * Avoid c-strings, and don't write code that depends on `NULL` terminators. Expose `struct aws_byte_buf` APIs
 and let the user figure it out.
 * There is only one valid character encoding-- UTF-8. Try not to ever need to care about character encodings, but

include/aws/common/array_list.h

@@ -33,18 +33,17 @@ struct aws_array_list {
  * return a positive number if a > b, zero if a = b, and a negative number
  * if a < b.
  */
-typedef int (*aws_array_list_comparator)(const void *a, const void *b);
+typedef int(aws_array_list_comparator_fn)(const void *a, const void *b);
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /**
- * Initializes an array list with an array of size initial_item_allocation *
- * item_size. In this mode, the array size will grow by a factor of 2 upon
- * insertion if space is not available. initial_item_allocation is the number of
- * elements you want space allocated for. item_size is the size of each element
- * in bytes. Mixing items types is not supported by this API.
+ * Initializes an array list with an array of size initial_item_allocation * item_size. In this mode, the array size
+ * will grow by a factor of 2 upon insertion if space is not available. initial_item_allocation is the number of
+ * elements you want space allocated for. item_size is the size of each element in bytes. Mixing items types is not
+ * supported by this API.
  */
 AWS_COMMON_API
 int aws_array_list_init_dynamic(
@@ -54,17 +53,15 @@ int aws_array_list_init_dynamic(
     size_t item_size);
 
 /**
- * Initializes an array list with a preallocated array of void *. item_count is
- * the number of elements in the array, and item_size is the size in bytes of
- * each element. Mixing items types is not supported by this API. Once this list
- * is full, new items will be rejected.
+ * Initializes an array list with a preallocated array of void *. item_count is the number of elements in the array,
+ * and item_size is the size in bytes of each element. Mixing items types is not supported
+ * by this API. Once this list 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);
 
 /**
- * Deallocates any memory that was allocated for this list, and resets list for
- * reuse or deletion.
+ * Deallocates any memory that was allocated for this list, and resets list for reuse or deletion.
  */
 AWS_COMMON_API
 void aws_array_list_clean_up(struct aws_array_list *list);
@@ -76,17 +73,15 @@ AWS_COMMON_API
 int aws_array_list_push_back(struct aws_array_list *list, const void *val);
 
 /**
- * Copies the element at the front of the list if it exists. If list is empty,
- * AWS_ERROR_LIST_EMPTY will be raised
+ * Copies the element at the front of the list if it exists. If list is empty, AWS_ERROR_LIST_EMPTY will be raised
  */
 AWS_COMMON_API
 int aws_array_list_front(const struct aws_array_list *list, void *val);
 
 /**
- * Deletes the element at the front of the list if it exists. If list is empty,
- * AWS_ERROR_LIST_EMPTY will be raised. This call results in shifting all of the
- * elements at the end of the array to the front. Avoid this call unless that is
- * intended behavior.
+ * Deletes the element at the front of the list if it exists. If list is empty, AWS_ERROR_LIST_EMPTY will be raised.
+ * This call results in shifting all of the elements at the end of the array to the front. Avoid this call unless that
+ * is intended behavior.
  */
 AWS_COMMON_API
 int aws_array_list_pop_front(struct aws_array_list *list);
@@ -101,51 +96,45 @@ AWS_COMMON_API
 void aws_array_list_pop_front_n(struct aws_array_list *list, size_t n);
 
 /**
- * Copies the element at the end of the list if it exists. If list is empty,
- * AWS_ERROR_LIST_EMPTY will be raised.
+ * Copies the element at the end of the list if it exists. If list is empty, AWS_ERROR_LIST_EMPTY will be raised.
  */
 AWS_COMMON_API
 int aws_array_list_back(const struct aws_array_list *list, void *val);
 
 /**
- * Deletes the element at the end of the list if it exists. If list is empty,
- * AWS_ERROR_LIST_EMPTY will be raised.
+ * Deletes the element at the end of the list if it exists. If list is empty, AWS_ERROR_LIST_EMPTY will be raised.
  */
 AWS_COMMON_API
 int aws_array_list_pop_back(struct aws_array_list *list);
 
 /**
- * Clears all elements in the array and resets length to zero. Size does not
- * change in this operation.
+ * Clears all elements in the array and resets length to zero. Size does not change in this operation.
  */
 AWS_COMMON_API
 void aws_array_list_clear(struct aws_array_list *list);
 
 /**
- * If in dynamic mode, shrinks the allocated array size to the minimum amount
- * necessary to store its elements.
+ * If in dynamic mode, shrinks the allocated array size to the minimum amount necessary to store its elements.
  */
 AWS_COMMON_API
 int aws_array_list_shrink_to_fit(struct aws_array_list *list);
 
 /**
- * Copies the elements from from to to. If to is in static mode, it must at
- * least be the same length as from. Any data in to will be overwritten in this
- * copy.
+ * Copies the elements from from to to. If to is in static mode, it must at least be the same length as from. Any data
+ * in to will be overwritten in this copy.
  */
 AWS_COMMON_API
 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.
+ * 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);
 
 /**
- * Returns the number of elements that can fit in the internal array. If list is
- * initialized in dynamic mode, the capacity changes over time.
+ * Returns the number of elements that can fit in the internal array. If list is initialized in dynamic mode,
+ * the capacity changes over time.
  */
 AWS_COMMON_API
 size_t aws_array_list_capacity(const struct aws_array_list *list);
@@ -157,24 +146,22 @@ AWS_COMMON_API
 size_t aws_array_list_length(const struct aws_array_list *list);
 
 /**
- * Copies the memory at index to val. If element does not exist,
- * AWS_ERROR_INVALID_INDEX will be raised.
+ * Copies the memory 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(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.
+ * 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);
 
 /**
- * Copies the the memory pointed to by val into the array at index. If in
- * dynamic mode, the size will grow by a factor of two when the array is full.
- * In static mode, AWS_ERROR_INVALID_INDEX will be raised if the index is past
- * the bounds of the array.
+ * Copies the the memory pointed to by val into the array at index. If in dynamic mode, the size will grow by a factor
+ * of two when the array is full. In static mode, AWS_ERROR_INVALID_INDEX will be raised if the index is past 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);
@@ -189,10 +176,10 @@ 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_fn *compare_fn);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /* AWS_COMMON_ARRAY_LIST_H */
+#endif /*AWS_COMMON_ARRAY_LIST_H */

include/aws/common/byte_buf.h

@@ -77,9 +77,8 @@ AWS_COMMON_API void aws_byte_buf_secure_clean_up(struct aws_byte_buf *buf);
  * be inserted into the output. if the input ends with split_on, an empty cursor
  * will be appended to the output.
  *
- * It is the user's responsibility to properly initialize output. Recommended
- * number of preallocated elements from output is your most likely guess for the
- * upper bound of the number of elements resulting from the split.
+ * It is the user's responsibility to properly initialize output. Recommended number of preallocated elements from
+ * output is your most likely guess for the upper bound of the number of elements resulting from the split.
  *
  * The type that will be stored in output is struct aws_byte_cursor (you'll need
  * this for the item size param).
@@ -91,26 +90,21 @@ AWS_COMMON_API
 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
- * aws_byte_cursor instances where buffer is an offset into the input_str and
- * len is the length of that string in the original buffer. N is the max number
- * of splits, if this value is zero, it will add all splits to the output.
+ * No copies, no buffer allocations. Fills in output with a list of aws_byte_cursor instances where buffer is
+ * an offset into the input_str and len is the length of that string in the original buffer. N is the max number of
+ * splits, if this value is zero, it will add all splits to the output.
  *
  * Edge case rules are as follows:
- * if the input begins with split_on, an empty cursor will be the first entry in
- * output if the input has two adjacent split_on tokens, an empty cursor will be
- * inserted into the output. if the input ends with split_on, an empty cursor
- * will be appended to the output.
+ * if the input begins with split_on, an empty cursor will be the first entry in output
+ * if the input has two adjacent split_on tokens, an empty cursor will be inserted into the output.
+ * if the input ends with split_on, an empty cursor will be appended to the output.
  *
- * It is the user's responsibility to properly initialize output. Recommended
- * number of preallocated elements from output is your most likely guess for the
- * upper bound of the number of elements resulting from the split.
+ * It is the user's responsibility to properly initialize output. Recommended number of preallocated elements from
+ * output is your most likely guess for the upper bound of the number of elements resulting from the split.
  *
- * The type that will be stored in output is struct aws_byte_cursor (you'll need
- * this for the item size param).
+ * The type that will be stored in output is struct aws_byte_cursor (you'll need this for the item size param).
  *
- * It is the user's responsibility to make sure the input buffer stays in memory
- * long enough to use the results.
+ * It is the user's responsibility to make sure the input buffer stays in memory long enough to use the results.
  */
 AWS_COMMON_API
 int aws_byte_buf_split_on_char_n(

include/aws/common/clock.h

@@ -22,17 +22,15 @@
 extern "C" {
 #endif
 /**
- * Get ticks in nanoseconds (usually 100 nanosecond precision) on the high
- * resolution clock (most-likely TSC). This clock has no bearing on the actual
- * system time. On success, timestamp will be set.
+ * Get ticks in nanoseconds (usually 100 nanosecond precision) on the high resolution clock (most-likely TSC). This
+ * clock has no bearing on the actual system time. On success, timestamp will be set.
  */
 AWS_COMMON_API
 int aws_high_res_clock_get_ticks(uint64_t *timestamp);
 
 /**
- * Get ticks in nanoseconds (usually 100 nanosecond precision) on the system
- * clock. Reflects actual system time via nanoseconds since unix epoch. Use with
- * care since an inaccurately set clock will probably cause bugs. On success,
+ * Get ticks in nanoseconds (usually 100 nanosecond precision) on the system clock. Reflects actual system time via
+ * nanoseconds since unix epoch. Use with care since an inaccurately set clock will probably cause bugs. On success,
  * timestamp will be set.
  */
 AWS_COMMON_API