Fix macro usage (#411)

* consistent macro calls

Author: DmitriyMusatkin

source/h2_connection.c

@@ -1565,15 +1565,15 @@ static struct aws_h2err s_decoder_on_window_update(uint32_t stream_id, uint32_t
         /* Let's update the connection flow-control window size */
         if (window_size_increment == 0) {
             /* flow-control window increment of 0 MUST be treated as error (RFC7540 6.9.1) */
-            CONNECTION_LOG(ERROR, connection, "Window update frame with 0 increment size")
+            CONNECTION_LOG(ERROR, connection, "Window update frame with 0 increment size");
             return aws_h2err_from_h2_code(AWS_HTTP2_ERR_PROTOCOL_ERROR);
         }
         if (connection->thread_data.window_size_peer + window_size_increment > AWS_H2_WINDOW_UPDATE_MAX) {
             /* We MUST NOT allow a flow-control window to exceed the max */
             CONNECTION_LOG(
                 ERROR,
                 connection,
-                "Window update frame causes the connection flow-control window exceeding the maximum size")
+                "Window update frame causes the connection flow-control window exceeding the maximum size");
             return aws_h2err_from_h2_code(AWS_HTTP2_ERR_FLOW_CONTROL_ERROR);
         }
         if (connection->thread_data.window_size_peer <= AWS_H2_MIN_WINDOW_SIZE) {

source/h2_decoder.c

@@ -37,7 +37,7 @@ static const size_t s_decoder_cookie_buffer_initial_size = 512;
 #define DECODER_CALL_VTABLE(decoder, fn)                                                                               \
     do {                                                                                                               \
         if ((decoder)->vtable->fn) {                                                                                   \
-            DECODER_LOG(TRACE, decoder, "Invoking callback " #fn)                                                      \
+            DECODER_LOG(TRACE, decoder, "Invoking callback " #fn);                                                     \
             struct aws_h2err vtable_err = (decoder)->vtable->fn((decoder)->userdata);                                  \
             if (aws_h2err_failed(vtable_err)) {                                                                        \
                 DECODER_LOGF(                                                                                          \
@@ -53,7 +53,7 @@ static const size_t s_decoder_cookie_buffer_initial_size = 512;
 #define DECODER_CALL_VTABLE_ARGS(decoder, fn, ...)                                                                     \
     do {                                                                                                               \
         if ((decoder)->vtable->fn) {                                                                                   \
-            DECODER_LOG(TRACE, decoder, "Invoking callback " #fn)                                                      \
+            DECODER_LOG(TRACE, decoder, "Invoking callback " #fn);                                                     \
             struct aws_h2err vtable_err = (decoder)->vtable->fn(__VA_ARGS__, (decoder)->userdata);                     \
             if (aws_h2err_failed(vtable_err)) {                                                                        \
                 DECODER_LOGF(                                                                                          \

source/hpack_decoder.c

@@ -35,7 +35,7 @@ void aws_hpack_decoder_clean_up(struct aws_hpack_decoder *decoder) {
 
 static const struct aws_http_header *s_get_header_u64(const struct aws_hpack_decoder *decoder, uint64_t index) {
     if (index > SIZE_MAX) {
-        HPACK_LOG(ERROR, decoder, "Header index is absurdly large")
+        HPACK_LOG(ERROR, decoder, "Header index is absurdly large");
         aws_raise_error(AWS_ERROR_INVALID_INDEX);
         return NULL;
     }

source/hpack_encoder.c

@@ -382,7 +382,7 @@ int aws_hpack_encode_header_block(
                     ERROR,
                     encoder,
                     "Integer encoding failed for table size update entry, integer: %zu",
-                    smallest_update_value)
+                    smallest_update_value);
                 return AWS_OP_ERR;
             }
         }
@@ -396,7 +396,7 @@ int aws_hpack_encode_header_block(
         uint8_t num_prefix_bits = s_hpack_entry_num_prefix_bits[AWS_HPACK_ENTRY_DYNAMIC_TABLE_RESIZE];
         if (aws_hpack_encode_integer(last_update_value, starting_bit_pattern, num_prefix_bits, output)) {
             HPACK_LOGF(
-                ERROR, encoder, "Integer encoding failed for table size update entry, integer: %zu", last_update_value)
+                ERROR, encoder, "Integer encoding failed for table size update entry, integer: %zu", last_update_value);
             return AWS_OP_ERR;
         }
 

source/websocket.c

@@ -1683,8 +1683,8 @@ struct aws_http_message *aws_http_message_new_websocket_handshake_request(
     struct aws_byte_cursor host) {
 
     AWS_PRECONDITION(allocator);
-    AWS_PRECONDITION(aws_byte_cursor_is_valid(&path))
-    AWS_PRECONDITION(aws_byte_cursor_is_valid(&host))
+    AWS_PRECONDITION(aws_byte_cursor_is_valid(&path));
+    AWS_PRECONDITION(aws_byte_cursor_is_valid(&host));
 
     struct aws_http_message *request = aws_http_message_new_request(allocator);
     if (!request) {

tests/fuzz/fuzz_h2_decoder_correct.c

@@ -253,7 +253,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
 
             struct aws_stream_status body_status;
             aws_input_stream_get_status(body, &body_status);
-            AWS_FATAL_ASSERT(body_complete == body_status.is_end_of_stream)
+            AWS_FATAL_ASSERT(body_complete == body_status.is_end_of_stream);
             aws_input_stream_release(body);
             break;
         }

tests/test_websocket_bootstrap.c

@@ -236,7 +236,7 @@ static struct aws_websocket *s_mock_websocket = (void *)"websocket";
 
 static int s_mock_http_client_connect(const struct aws_http_client_connection_options *options) {
     AWS_FATAL_ASSERT(options);
-    AWS_FATAL_ASSERT(!s_tester.http_connect_called_successfully)
+    AWS_FATAL_ASSERT(!s_tester.http_connect_called_successfully);
 
     if (s_tester.fail_at_step == BOOT_STEP_HTTP_CONNECT) {
         return aws_raise_error(BOOT_STEP_HTTP_CONNECT);