Add -Wconversion compiler warning

axelo · axelo · commit b73e71356bda · 2021-12-26T10:53:51.000+01:00
diff --git a/Day01.c b/Day01.c
@@ -3,7 +3,7 @@
 #define CAP 4096
 
 static int parse(const char *input, int depths[CAP]) {
-    size_t n = 0;
+    int n = 0;
     int charsRead = 0;
     int filled = 0;
 
diff --git a/Day03.c b/Day03.c
@@ -24,7 +24,7 @@ static int parse(const char *input, int diags[CAP]) {
 
         input += charsRead;
 
-        diags[n++] = strtoimax(diagString, NULL, 2);
+        diags[n++] = (int)strtoimax(diagString, NULL, 2);
 
         assert(n < CAP);
     }
@@ -58,7 +58,7 @@ static int partTwoRating(int n, const int diags[n], Rating rating) {
     int filtered[n];
     int filteredCount = n;
 
-    memcpy(filtered, diags, sizeof(*diags) * n);
+    memcpy(filtered, diags, sizeof(*diags) * (uint32_t)n);
 
     int bitMask = 1 << (BIT_WIDTH - 1);
 
diff --git a/Day04.c b/Day04.c
@@ -69,7 +69,7 @@ static void playBingo(Input *input, Bingo *bingo) {
     bool firstWin = false;
 
     bool alreadyWonBoards[input->boardsCount];
-    memset(alreadyWonBoards, false, input->boardsCount * sizeof(bool));
+    memset(alreadyWonBoards, false, (uint32_t)input->boardsCount * sizeof(bool));
 
     for (int i = 0; i < input->numbersCount; ++i) {
         int number = input->numbers[i];
diff --git a/Day05.c b/Day05.c
@@ -96,7 +96,7 @@ static int countOverlaps(int h, int w, const int diagram[h][w]) {
 
 static int partOne(int count, const Line lines[count]) {
     Line vhLines[count];
-    memset(vhLines, 0, sizeof(Line) * count);
+    memset(vhLines, 0, sizeof(Line) * (uint32_t)count);
 
     int countVH = 0;
 
@@ -109,7 +109,7 @@ static int partOne(int count, const Line lines[count]) {
     DiagramSize size = diagramSizeFromLines(countVH, vhLines);
 
     int diagram[size.h][size.w];
-    memset(diagram, 0, size.w * size.h * sizeof(int));
+    memset(diagram, 0, (uint32_t)size.w * (uint32_t)size.h * sizeof(int));
 
     drawLines(countVH, vhLines, size.h, size.w, diagram);
 
@@ -120,7 +120,7 @@ static int partTwo(int count, const Line lines[count]) {
     DiagramSize size = diagramSizeFromLines(count, lines);
 
     int diagram[size.h][size.w];
-    memset(diagram, 0, size.w * size.h * sizeof(int));
+    memset(diagram, 0, (uint32_t)size.w * (uint32_t)size.h * sizeof(int));
 
     drawLines(count, lines, size.h, size.w, diagram);
 
diff --git a/Day07.c b/Day07.c
@@ -30,12 +30,12 @@ static int compareInt(const void *a, const void *b) {
 
 static int partOne(int n, const int xs[n]) {
     int sortedXs[n];
-    memcpy(sortedXs, xs, n * sizeof(xs[0]));
+    memcpy(sortedXs, xs, (uint32_t)n * sizeof(xs[0]));
 
-    qsort(sortedXs, n, sizeof(xs[0]), compareInt); // O(n * log n)
+    qsort(sortedXs, (uint32_t)n, sizeof(xs[0]), compareInt); // O(n * log n)
 
     int fuels[n];
-    memset(fuels, 0, n * sizeof(fuels[0]));
+    memset(fuels, 0, (uint32_t)n * sizeof(fuels[0]));
 
     int midpoint = sortedXs[n / 2]; // Midpoint is the median position
     int fuel = 0;
diff --git a/Day09.c b/Day09.c
@@ -23,7 +23,7 @@ static Dim parse(const char *input, uint8_t heightmap[CAP][CAP]) {
             int height = c - 48;
             assert(height >= 0 && height <= 9);
 
-            heightmap[dim.h][x++] = height;
+            heightmap[dim.h][x++] = (uint8_t)height;
             assert(x < CAP);
         }
 
diff --git a/Day10.c b/Day10.c
@@ -75,7 +75,7 @@ static void validateSyntax(const char *line, SyntaxResult *result) {
                 --result->nOpen;
                 break;
             } else {
-                result->position = line - lineBegin;
+                result->position = (int)(line - lineBegin);
                 return;
             }
         }
@@ -124,7 +124,7 @@ static int64_t partTwo(int n, const char lines[n][SYNTAX_CAP]) {
         }
     }
 
-    qsort(scores, nScores, sizeof(scores[0]), compareInt64); // O(n * log n)
+    qsort(scores, (uint32_t)nScores, sizeof(scores[0]), compareInt64); // O(n * log n)
 
     return scores[nScores / 2];
 }
diff --git a/Day12.c b/Day12.c
@@ -18,8 +18,8 @@ static CaveId idFromString(const char *s) {
     switch (strnlen(s, 6)) {
     case 5: return START_CAVE_ID;
     case 3: return END_CAVE_ID;
-    case 2: return (s[0] << 8) | s[1];
-    case 1: return (s[0] << 8) | s[0];
+    case 2: return (CaveId)((s[0] << 8) | s[1]);
+    case 1: return (CaveId)((s[0] << 8) | s[0]);
     default: assert(false);
     }
 }
diff --git a/Day14.c b/Day14.c
@@ -27,7 +27,7 @@ static int parse(const char *input, uint8_t template[TEMPLATE_CAP], uint8_t rule
 static int64_t pairFromTemplate(int n, const uint8_t template[n], const uint8_t rules[26][26], int steps) {
     // Allocate stack memory for all possible pair combinations for all steps.
     int64_t pairsByStep[steps + 1][26][26];
-    memset(pairsByStep, 0, sizeof(int64_t) * 26 * 26 * (steps + 1));
+    memset(pairsByStep, 0, sizeof(int64_t) * 26 * 26 * (uint32_t)(steps + 1));
 
     // Insert initial pairs from template into step 0.
     for (int i = 0; i < n - 1; ++i) {
diff --git a/Day15.c b/Day15.c
@@ -87,7 +87,7 @@ static int parseSize(const char *input) {
         ++inputFirstLine;
     }
 
-    return inputFirstLine - input;
+    return (int)(inputFirstLine - input);
 }
 
 static void parseMap(const char *input, int n, uint8_t map[n][n]) {
@@ -100,7 +100,7 @@ static void parseMap(const char *input, int n, uint8_t map[n][n]) {
         input += charsRead;
 
         for (int x = 0; x < n; ++x) {
-            map[y][x] = row[x] - '0';
+            map[y][x] = (uint8_t)(row[x] - '0');
         }
     }
 }
@@ -114,17 +114,17 @@ static uint32_t aStarSearch(int n, const uint8_t map[n][n]) {
 
     // Cost of the shortest path from start to node n currently known.
     uint32_t gScore[n][n];
-    memset(gScore, UINT32_MAX, n * n * sizeof(gScore[0][0])); // Fill with "infinity".
+    memset(gScore, INT32_MAX, (uint32_t)n * (uint32_t)n * sizeof(gScore[0][0])); // Fill with "infinity".
 
     // Current best guess to how short a path from start to goal can be if it goes through node n.
     uint32_t fScore[n][n];
-    memset(fScore, UINT32_MAX, n * n * sizeof(fScore[0][0])); // Fill with "infinity".
+    memset(fScore, INT32_MAX, (uint32_t)n * (uint32_t)n * sizeof(fScore[0][0])); // Fill with "infinity".
 
     // Set initial score to 0 at (0, 0)
     gScore[0][0] = 0;
 
     // Best case scenario from (0, 0) to (n - 1, n - 1).
-    fScore[0][0] = (n - 1 - 0) + (n - 1 - 0); // h((0,0))
+    fScore[0][0] = (uint32_t)((n - 1 - 0) + (n - 1 - 0)); // h((0,0))
 
     // Insert start node.
     PrioQueue_enqueue(fScore[0][0], (0 << 16) | 0, &nodeByLowestPrio);
@@ -158,21 +158,21 @@ static uint32_t aStarSearch(int n, const uint8_t map[n][n]) {
                 if (tentativeGScore < gScore[ny][nx]) {
                     // Found a cheaper path than recorded, record this one.
                     gScore[ny][nx] = tentativeGScore;
-                    fScore[ny][nx] = tentativeGScore + ((n - 1 - ny) + (n - 1 - nx));
+                    fScore[ny][nx] = tentativeGScore + (uint32_t)((n - 1 - ny) + (n - 1 - nx));
 
                     // Insert neighbor node. O(log n).
-                    PrioQueue_enqueue(fScore[ny][nx], (ny << 16) | nx, &nodeByLowestPrio);
+                    PrioQueue_enqueue(fScore[ny][nx], (uint32_t)(ny << 16) | nx, &nodeByLowestPrio);
                 }
             }
         }
     }
 }
 
-static int partOne(int n, const uint8_t map[n][n]) {
+static uint32_t partOne(int n, const uint8_t map[n][n]) {
     return aStarSearch(n, map);
 }
 
-static int partTwo(int n, const uint8_t tile[n][n]) {
+static uint32_t partTwo(int n, const uint8_t tile[n][n]) {
     int m = n * 5;
     uint8_t map[m][m];
 
diff --git a/Day16.c b/Day16.c
@@ -3,7 +3,7 @@
 #define CAP 10000
 
 static int parse(const char *input, uint8_t bits[CAP]) {
-    int nInput = strlen(input);
+    int nInput = (int)strlen(input);
 
     int n = 0;
 
@@ -12,7 +12,7 @@ static int parse(const char *input, uint8_t bits[CAP]) {
             break;
         }
 
-        uint8_t nibble = input[i] > '9' ? input[i] - 'A' + 10 : input[i] - '0';
+        uint8_t nibble = (uint8_t)(input[i] > '9' ? input[i] - 'A' + 10 : input[i] - '0');
         assert(nibble >= 0 && nibble <= 15);
 
         for (int j = 3; j >= 0; --j) {
@@ -45,9 +45,9 @@ static int decode(int nBits, const uint8_t bits[nBits], int *versionSum, int64_t
                    (bits[1] << 1) |
                    bits[2];
 
-    uint8_t typeId = (bits[3] << 2) |
-                     (bits[4] << 1) |
-                     bits[5];
+    uint8_t typeId = (uint8_t)((bits[3] << 2) |
+                               (bits[4] << 1) |
+                               bits[5]);
 
     int bitIndex = 6;
 
diff --git a/Day18.c b/Day18.c
@@ -12,17 +12,17 @@ typedef struct {
 } Node;
 
 typedef struct {
-    int n;
+    uint16_t n;
     Node ns[NODES_CAP];
-    int nReuse;
+    uint16_t nReuse;
     int reuse[NODES_REUSE_CAP];
 } Nodes;
 
-static int parse(const char *input, Nodes *nodes, int numbers[NUMBERS_CAP]) {
+static int parse(const char *input, Nodes *nodes, uint16_t numbers[NUMBERS_CAP]) {
     int nNumbers = 0;
     nodes->n = 1;
 
-    int current = nodes->n;
+    uint16_t current = nodes->n;
 
     while (*input != 0) {
         numbers[nNumbers++] = nodes->n;
@@ -40,20 +40,20 @@ static int parse(const char *input, Nodes *nodes, int numbers[NUMBERS_CAP]) {
             if (c == '[') {
                 assert(nodes->ns[current].left == 0 && "Left already occupied");
 
-                int left = nodes->n++;
+                uint16_t left = nodes->n++;
                 nodes->ns[left].parent = current;
 
                 nodes->ns[current].left = left;
 
                 current = left;
             } else if (c >= '0' && c <= '9') {
-                nodes->ns[current].value = c - '0';
+                nodes->ns[current].value = (uint16_t)(c - '0');
 
                 current = nodes->ns[current].parent;
             } else if (c == ',') {
                 assert(nodes->ns[current].right == 0 && "Right already occupied");
 
-                int right = nodes->n++;
+                uint16_t right = nodes->n++;
                 nodes->ns[right].parent = current;
 
                 nodes->ns[current].right = right;
@@ -76,14 +76,14 @@ static int parse(const char *input, Nodes *nodes, int numbers[NUMBERS_CAP]) {
     return nNumbers;
 }
 
-static inline int emptyNodeIndex(Nodes *nodes) {
-    int i = (nodes->nReuse - 1) & (NODES_REUSE_CAP - 1);
+static inline uint16_t emptyNodeIndex(Nodes *nodes) {
+    uint16_t i = (nodes->nReuse - 1) & (NODES_REUSE_CAP - 1);
     int j = nodes->reuse[i];
 
     if (j) {
         nodes->reuse[i] = -1;
         nodes->nReuse = i;
-        return j;
+        return (uint16_t)j;
     } else {
         return nodes->n++;
     }
@@ -94,8 +94,8 @@ static inline void markReusableNodeIndex(int i, Nodes *nodes) {
     nodes->nReuse = (nodes->nReuse + 1) & (NODES_REUSE_CAP - 1);
 }
 
-static int addition(int ia, int ib, Nodes *nodes) {
-    int root = emptyNodeIndex(nodes);
+static uint16_t addition(uint16_t ia, uint16_t ib, Nodes *nodes) {
+    uint16_t root = emptyNodeIndex(nodes);
 
     nodes->ns[root].parent = 0;
     nodes->ns[root].left = ia;
@@ -220,15 +220,15 @@ static bool split(int i, Nodes *nodes) {
     int j = findNodeToSplit(i, nodes);
 
     if (j != -1) {
-        int left = emptyNodeIndex(nodes);
-        nodes->ns[left].parent = j;
+        uint16_t left = emptyNodeIndex(nodes);
+        nodes->ns[left].parent = (uint16_t)j;
         nodes->ns[left].value = nodes->ns[j].value / 2;
 
         assert(nodes->n < NODES_CAP);
 
-        int right = emptyNodeIndex(nodes);
-        nodes->ns[right].parent = j;
-        nodes->ns[right].value = ((float)nodes->ns[j].value / 2) + 0.5;
+        uint16_t right = emptyNodeIndex(nodes);
+        nodes->ns[right].parent = (uint16_t)j;
+        nodes->ns[right].value = (uint16_t)(((float)nodes->ns[j].value / 2) + 0.5);
 
         assert(nodes->n < NODES_CAP);
 
@@ -270,11 +270,11 @@ static void dump(int i, const Nodes *nodes) {
     }
 }
 
-static int partOne(const Nodes *nodes, int n, int numbers[n]) {
+static int partOne(const Nodes *nodes, int n, uint16_t numbers[n]) {
     Nodes ns;
     memcpy(&ns, nodes, sizeof(Nodes));
 
-    int number = numbers[0];
+    uint16_t number = numbers[0];
 
     for (int i = 1; i < n; ++i) {
         number = addition(number, numbers[i], &ns);
@@ -286,7 +286,7 @@ static int partOne(const Nodes *nodes, int n, int numbers[n]) {
     return magnitude(number, &ns);
 }
 
-static int partTwo(const Nodes *nodes, int n, int numbers[n]) {
+static int partTwo(const Nodes *nodes, int n, uint16_t numbers[n]) {
     Nodes ns;
 
     int largestMagnitude = INT_MIN;
@@ -296,7 +296,7 @@ static int partTwo(const Nodes *nodes, int n, int numbers[n]) {
             if (i != j) {
                 memcpy(&ns, nodes, sizeof(Nodes));
 
-                int number = addition(numbers[i], numbers[j], &ns);
+                uint16_t number = addition(numbers[i], numbers[j], &ns);
                 reduce(number, &ns);
 
                 int m = magnitude(number, &ns);
@@ -315,7 +315,7 @@ int main() {
     const char *input = Helpers_readInputFile(__FILE__);
 
     Nodes nodes = {0};
-    int numbers[NUMBERS_CAP] = {0};
+    uint16_t numbers[NUMBERS_CAP] = {0};
     int n = parse(input, &nodes, numbers);
 
     Helpers_assert(PART1, Helpers_clock(),
diff --git a/Day20.c b/Day20.c
diff --git a/Day21.c b/Day21.c
diff --git a/Helpers.c b/Helpers.c
diff --git a/run.bash b/run.bash

Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ static Dim parse(const char *input, uint8_t heightmap[CAP][CAP]) {`
`23`	`23`	`int height = c - 48;`
`24`	`24`	`assert(height >= 0 && height <= 9);`
`25`	`25`
`26`		`- heightmap[dim.h][x++] = height;`
	`26`	`+ heightmap[dim.h][x++] = (uint8_t)height;`
`27`	`27`	`assert(x < CAP);`
`28`	`28`	`}`
`29`	`29`
Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ static void validateSyntax(const char line, SyntaxResult result) {`
`75`	`75`	`--result->nOpen;`
`76`	`76`	`break;`
`77`	`77`	`} else {`
`78`		`- result->position = line - lineBegin;`
	`78`	`+ result->position = (int)(line - lineBegin);`
`79`	`79`	`return;`
`80`	`80`	`}`
`81`	`81`	`}`
`@@ -124,7 +124,7 @@ static int64_t partTwo(int n, const char lines[n][SYNTAX_CAP]) {`
`124`	`124`	`}`
`125`	`125`	`}`
`126`	`126`
`127`		`- qsort(scores, nScores, sizeof(scores[0]), compareInt64); // O(n * log n)`
	`127`	`+ qsort(scores, (uint32_t)nScores, sizeof(scores[0]), compareInt64); // O(n * log n)`
`128`	`128`
`129`	`129`	`return scores[nScores / 2];`
`130`	`130`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,8 +18,8 @@ static CaveId idFromString(const char *s) {`
`18`	`18`	`switch (strnlen(s, 6)) {`
`19`	`19`	`case 5: return START_CAVE_ID;`
`20`	`20`	`case 3: return END_CAVE_ID;`
`21`		`- case 2: return (s[0] << 8) \| s[1];`
`22`		`- case 1: return (s[0] << 8) \| s[0];`
	`21`	`+ case 2: return (CaveId)((s[0] << 8) \| s[1]);`
	`22`	`+ case 1: return (CaveId)((s[0] << 8) \| s[0]);`
`23`	`23`	`default: assert(false);`
`24`	`24`	`}`
`25`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,7 @@ static int parseSize(const char *input) {`
`87`	`87`	`++inputFirstLine;`
`88`	`88`	`}`
`89`	`89`
`90`		`- return inputFirstLine - input;`
	`90`	`+ return (int)(inputFirstLine - input);`
`91`	`91`	`}`
`92`	`92`
`93`	`93`	`static void parseMap(const char *input, int n, uint8_t map[n][n]) {`
`@@ -100,7 +100,7 @@ static void parseMap(const char *input, int n, uint8_t map[n][n]) {`
`100`	`100`	`input += charsRead;`
`101`	`101`
`102`	`102`	`for (int x = 0; x < n; ++x) {`
`103`		`- map[y][x] = row[x] - '0';`
	`103`	`+ map[y][x] = (uint8_t)(row[x] - '0');`
`104`	`104`	`}`
`105`	`105`	`}`
`106`	`106`	`}`
`@@ -114,17 +114,17 @@ static uint32_t aStarSearch(int n, const uint8_t map[n][n]) {`
`114`	`114`
`115`	`115`	`// Cost of the shortest path from start to node n currently known.`
`116`	`116`	`uint32_t gScore[n][n];`
`117`		`- memset(gScore, UINT32_MAX, n * n * sizeof(gScore[0][0])); // Fill with "infinity".`
	`117`	`+ memset(gScore, INT32_MAX, (uint32_t)n * (uint32_t)n * sizeof(gScore[0][0])); // Fill with "infinity".`
`118`	`118`
`119`	`119`	`// Current best guess to how short a path from start to goal can be if it goes through node n.`
`120`	`120`	`uint32_t fScore[n][n];`
`121`		`- memset(fScore, UINT32_MAX, n * n * sizeof(fScore[0][0])); // Fill with "infinity".`
	`121`	`+ memset(fScore, INT32_MAX, (uint32_t)n * (uint32_t)n * sizeof(fScore[0][0])); // Fill with "infinity".`
`122`	`122`
`123`	`123`	`// Set initial score to 0 at (0, 0)`
`124`	`124`	`gScore[0][0] = 0;`
`125`	`125`
`126`	`126`	`// Best case scenario from (0, 0) to (n - 1, n - 1).`
`127`		`- fScore[0][0] = (n - 1 - 0) + (n - 1 - 0); // h((0,0))`
	`127`	`+ fScore[0][0] = (uint32_t)((n - 1 - 0) + (n - 1 - 0)); // h((0,0))`
`128`	`128`
`129`	`129`	`// Insert start node.`
`130`	`130`	`PrioQueue_enqueue(fScore[0][0], (0 << 16) \| 0, &nodeByLowestPrio);`
`@@ -158,21 +158,21 @@ static uint32_t aStarSearch(int n, const uint8_t map[n][n]) {`
`158`	`158`	`if (tentativeGScore < gScore[ny][nx]) {`
`159`	`159`	`// Found a cheaper path than recorded, record this one.`
`160`	`160`	`gScore[ny][nx] = tentativeGScore;`
`161`		`- fScore[ny][nx] = tentativeGScore + ((n - 1 - ny) + (n - 1 - nx));`
	`161`	`+ fScore[ny][nx] = tentativeGScore + (uint32_t)((n - 1 - ny) + (n - 1 - nx));`
`162`	`162`
`163`	`163`	`// Insert neighbor node. O(log n).`
`164`		`- PrioQueue_enqueue(fScore[ny][nx], (ny << 16) \| nx, &nodeByLowestPrio);`
	`164`	`+ PrioQueue_enqueue(fScore[ny][nx], (uint32_t)(ny << 16) \| nx, &nodeByLowestPrio);`
`165`	`165`	`}`
`166`	`166`	`}`
`167`	`167`	`}`
`168`	`168`	`}`
`169`	`169`	`}`
`170`	`170`
`171`		`-static int partOne(int n, const uint8_t map[n][n]) {`
	`171`	`+static uint32_t partOne(int n, const uint8_t map[n][n]) {`
`172`	`172`	`return aStarSearch(n, map);`
`173`	`173`	`}`
`174`	`174`
`175`		`-static int partTwo(int n, const uint8_t tile[n][n]) {`
	`175`	`+static uint32_t partTwo(int n, const uint8_t tile[n][n]) {`
`176`	`176`	`int m = n * 5;`
`177`	`177`	`uint8_t map[m][m];`
`178`	`178`