Stricter warnings

Author: ryanplusplus

Makefile

@@ -23,7 +23,7 @@ SANITIZE_FLAGS := -fsanitize=address -fsanitize=undefined
 
 CFLAGS += -std=c11 -pedantic
 CPPFLAGS += $(SANITIZE_FLAGS) -fno-omit-frame-pointer
-CPPFLAGS += $(INC_FLAGS) -MMD -MP -g -Wall -Wextra -Wcast-qual -Werror
+CPPFLAGS += $(INC_FLAGS) -MMD -MP -g -Wall -Wextra -Wcast-qual -Wconversion -pedantic -Werror
 CXXFLAGS += -std=c++17
 LDFLAGS := $(SANITIZE_FLAGS)
 LDLIBS := -lstdc++ -lCppUTest -lCppUTestExt -lm

include/tiny_queue.h

@@ -21,7 +21,7 @@ typedef struct {
 void tiny_queue_init(
   tiny_queue_t* self,
   void* buffer,
-  size_t buffer_size);
+  unsigned buffer_size);
 
 /*!
  * Add an element to the queue. Returns true if the element was successfully enqueued, false otherwise

src/tiny_comm.c

@@ -71,7 +71,7 @@ static void send_complete(void* context, const void* args)
 
   switch(self->send_state) {
     case send_state_send_crc_msb:
-      if(send_byte(self, self->send_crc >> 8)) {
+      if(send_byte(self, (uint8_t)(self->send_crc >> 8))) {
         self->send_state = send_state_send_crc_lsb;
       }
       break;

src/tiny_crc16.c

@@ -8,9 +8,9 @@
 uint16_t tiny_crc16_byte(uint16_t seed, uint8_t byte)
 {
   uint16_t crc = seed;
-  byte = crc >> 8 ^ byte;
+  byte = (uint8_t)(crc >> 8 ^ byte);
   byte ^= byte >> 4;
-  return (crc << 8) ^ ((uint16_t)(byte << 12)) ^ ((uint16_t)(byte << 5)) ^ ((uint16_t)byte);
+  return (uint16_t)((crc << 8) ^ ((uint16_t)(byte << 12)) ^ ((uint16_t)(byte << 5)) ^ ((uint16_t)byte));
 }
 
 uint16_t tiny_crc16_block(uint16_t seed, const uint8_t* bytes, size_t byte_count)

src/tiny_queue.c

@@ -64,7 +64,7 @@ static uint16_t ring_buffer_index_for_element_index(tiny_queue_t* self, uint16_t
   uint16_t location = 0;
   for(uint16_t i = 0; i < element_index; i++) {
     peek_element_size_at_ring_buffer_index(self, &element_size, location);
-    location += element_size + sizeof(uint16_t);
+    location += (uint16_t)(element_size + sizeof(uint16_t));
   }
   return location;
 }
@@ -136,7 +136,7 @@ uint16_t tiny_queue_count(tiny_queue_t* self)
 void tiny_queue_init(
   tiny_queue_t* self,
   void* storage,
-  size_t storageSize)
+  unsigned storageSize)
 {
   self->element_count = 0;
   tiny_ring_buffer_init(&self->ring_buffer, storage, sizeof(uint8_t), storageSize);

test/src/tiny_timer_group_double.cpp

@@ -19,8 +19,8 @@ void tiny_timer_group_double_elapse_time(
   tiny_timer_ticks_t ticks)
 {
   while(ticks) {
-    tiny_time_source_ticks_t ticks_to_elapse =
-      std::min(ticks, tiny_timer_ticks_until_next_ready(&self->timer_group));
+    auto ticks_to_elapse =
+      (tiny_time_source_ticks_t)std::min(ticks, tiny_timer_ticks_until_next_ready(&self->timer_group));
 
     tiny_time_source_double_tick(&self->time_source, ticks_to_elapse);
     tiny_timer_group_run(&self->timer_group);

test/tests/tiny_comm_test.cpp

@@ -98,9 +98,9 @@ TEST_GROUP(tiny_comm)
   static constexpr uint16_t calculate_crc(uint16_t seed, uint8_t byte)
   {
     uint16_t crc = seed;
-    byte = crc >> 8 ^ byte;
-    byte ^= byte >> 4;
-    return (crc << 8) ^ ((uint16_t)(byte << 12)) ^ ((uint16_t)(byte << 5)) ^ ((uint16_t)byte);
+    byte = (uint8_t)(crc >> 8 ^ byte);
+    byte ^= (uint8_t)(byte >> 4);
+    return (uint16_t)((crc << 8) ^ ((uint16_t)(byte << 12)) ^ ((uint16_t)(byte << 5)) ^ ((uint16_t)byte));
   }
 
 #define crc_msb(...) _crc_msb<__VA_ARGS__>()

test/tests/tiny_event_queue_test.cpp

@@ -45,7 +45,7 @@ TEST_GROUP(tiny_event_queue)
     mock().actualCall("unable_to_enqueue");
   }
 
-  void given_that_the_queue_has_been_initialized_with_buffer_size(size_t buffer_size)
+  void given_that_the_queue_has_been_initialized_with_buffer_size(unsigned buffer_size)
   {
     tiny_event_queue_init(&self, buffer, buffer_size, unable_to_enqueue);
   }

test/tests/tiny_hsm_test.cpp

@@ -36,7 +36,7 @@ typedef uint8_t state_t;
 #define state_function(_name)                                                                    \
   static tiny_hsm_result_t _##_name(tiny_hsm_t* hsm, tiny_hsm_signal_t signal, const void* data) \
   {                                                                                              \
-    return mock()                                                                                \
+    return (tiny_hsm_result_t)mock()                                                             \
       .actualCall(#_name)                                                                        \
       .withParameter("hsm", hsm)                                                                 \
       .withParameter("signal", signal)                                                           \

test/tests/tiny_queue_test.cpp

@@ -3,6 +3,7 @@
  * @brief
  */
 
+#include <limits>
 extern "C" {
 #include <string.h>
 #include "tiny_queue.h"
@@ -136,7 +137,7 @@ TEST_GROUP(tiny_queue)
 
   void peeking_should_yield(uint8_t * element, size_t element_size, uint16_t element_index)
   {
-    uint8_t peekedElementStorage[element_size];
+    uint8_t peekedElementStorage[std::numeric_limits<uint8_t>::max()];
     memset(peekedElementStorage, 0, sizeof(peekedElementStorage));
     uint16_t dequeued_element_size = 0;
 
@@ -187,7 +188,7 @@ TEST_GROUP(tiny_queue)
     }
   }
 
-  void given_that_n_elements_have_been_enqueued(uint16_t element_count)
+  void given_that_n_elements_have_been_enqueued(uint8_t element_count)
   {
     enqueue_one_byte_elements_such_that_each_element_is_incremented(0, element_count);
   }