address unused function warnings

Author: dannyvankooten

2018-c/.clangd

@@ -1,2 +1,2 @@
 CompileFlags:
-  Add: [-std=c17, -Wall, -Wextra, -Wpedantic, -Wundef, -Winline, -Wimplicit-fallthrough, -Wformat=2, -Wconversion ]
+  Add: [-std=c17, -Wall, -Wextra, -Wpedantic, -Wundef, -Winline, -Wimplicit-fallthrough, -Wformat=2, -Wvla, -Wconversion, -Wstringop-overflow=3 ]

2018-c/06.c

@@ -1,7 +1,7 @@
 #include "adventofcode.h"
+#include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
 #include <time.h>
 
 #define PUZZLE_NAME "Day 6: Chronal Coordinates"
@@ -32,10 +32,10 @@ void determine_bounds(struct Point *points, size_t n, int bounds[4]) {
   }
 }
 
-size_t parse(const char *s, struct Point *points, int bounds[4]) {
+static size_t parse(const char *s, struct Point points[static 64], int bounds[4]) {
   size_t n = 0;
 
-  while (*s != 0x0) {
+  while (*s != 0x0 && n < 64) {
     s = parse_int(&points[n].x, s);
     s = skip(", ", s);
     s = parse_int(&points[n].y, s);
@@ -48,7 +48,7 @@ size_t parse(const char *s, struct Point *points, int bounds[4]) {
   return n;
 }
 
-int get_closest_point(struct Point *points, size_t n, int x, int y) {
+static int get_closest_point(const struct Point points[static 64], const size_t n, const int x, const int y) {
   int closest_idx = -1;
   int closest_distance = 1 << 30;
 
@@ -67,12 +67,10 @@ int get_closest_point(struct Point *points, size_t n, int x, int y) {
   return closest_idx;
 }
 
-int pt1(struct Point points[], size_t n, int bounds[4]) {
-  int areas[n];
-  memset(areas, 0, n * sizeof(int));
-
-  char infinite[n];
-  memset(areas, 0, n * sizeof(*infinite));
+unsigned int pt1(const struct Point points[static 64], const size_t n, const int bounds[4]) {
+  assert(n <= 64);
+  unsigned int areas[64] = {0};
+  unsigned int infinite[64] = {0};
 
   for (int x = bounds[0], y = bounds[1]; x <= bounds[2] && y <= bounds[3];) {
     int closest_idx = get_closest_point(points, n, x, y);
@@ -103,11 +101,13 @@ int pt1(struct Point points[], size_t n, int bounds[4]) {
     }
   }
 
+
   return areas[largest];
 }
 
-int pt2(struct Point points[], size_t n, int bounds[4]) {
-  int count = 0;
+unsigned int pt2(const struct Point points[static 64], const size_t n, const int bounds[static 4]) {
+  assert(n <= 64);
+  unsigned int count = 0;
   for (int x = bounds[0], y = bounds[1]; x <= bounds[2] && y <= bounds[3];) {
     int distance = 0;
 
@@ -138,24 +138,15 @@ int main(void) {
   read_input_file(input, 64 * 1024, "06.txt");
 
   int bounds[4];
-  struct Point *points = malloc_or_die(50 * sizeof(*points));
+  struct Point points[64];
   size_t n = parse(input, points, bounds);
 
-  // printf("%ld coords: (%d, %d) to (%d, %d)\n", n, bounds[0], bounds[1],
-  //        bounds[2], bounds[3]);
-
-  int a1 = pt1(points, n, bounds);
-  int a2 = pt2(points, n, bounds);
-
-  free(points);
+  unsigned int a1 = pt1(points, n, bounds);
+  unsigned int a2 = pt2(points, n, bounds);
 
   printf("--- %s ---\n", PUZZLE_NAME);
   printf("Part 1: %d\n", a1);
   printf("Part 2: %d\n", a2);
   printf("Time: %.2fms\n", clock_time_since(t));
   return EXIT_SUCCESS;
 }
-
-// part 1: 3890 CORRECT
-// part 2: 99540 too high
-// part 2: 40284 CORRECT

2018-c/07.c

@@ -72,19 +72,19 @@ static void pt1(char *buf, struct step **steps, const size_t nsteps) {
 }
 
 static int pt2(struct step **steps, const size_t nsteps) {
-  const size_t nworkers = 5;
+  #define NWORKERS 5
   int delay_s = 60;
-  int worker_finish_times[nworkers];
-  struct step *worker_tasks[nworkers];
-  memset(worker_finish_times, 0, sizeof(*worker_finish_times) * nworkers);
-  memset(worker_tasks, 0, sizeof(struct step *) * nworkers);
+  int worker_finish_times[NWORKERS];
+  struct step *worker_tasks[NWORKERS];
+  memset(worker_finish_times, 0, sizeof(*worker_finish_times) * NWORKERS);
+  memset(worker_tasks, 0, sizeof(struct step *) * NWORKERS);
   size_t ndone = 0;
 
   // loop over seconds
   for (int s = 0;; s++) {
 
     // first loop, mark steps as done
-    for (size_t w = 0; w < nworkers; w++) {
+    for (size_t w = 0; w < NWORKERS; w++) {
       if (worker_finish_times[w] != s) {
         continue;
       }
@@ -104,7 +104,7 @@ static int pt2(struct step **steps, const size_t nsteps) {
     }
 
     // second loop: assign new tasks
-    for (size_t w = 0; w < nworkers; w++) {
+    for (size_t w = 0; w < NWORKERS; w++) {
       if (worker_tasks[w] != NULL) {
         continue;
       }

2018-c/08.c

@@ -1,12 +1,13 @@
 #include "adventofcode.h"
+#include <assert.h>
 #include <linux/limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
 
 #define PUZZLE_NAME "Day 8: Memory Maneuver"
 
-const char *pt1(const char *s, int *sum) {
+static const char *pt1(const char *s, int *sum) {
   int nchilds;
   int nmetadata;
 
@@ -30,7 +31,7 @@ const char *pt1(const char *s, int *sum) {
   return s;
 }
 
-const char *pt2(const char *s, int *sum) {
+static const char *pt2(const char *s, int *sum) {
   int nchilds;
   int nmetadata;
 
@@ -39,11 +40,11 @@ const char *pt2(const char *s, int *sum) {
   s = parse_int(&nmetadata, s);
   s = skip(" ", s);
 
-  int child_values[nchilds+1];
+  int child_values[32];
+  assert(nchilds <= 32);
   for (int i = 0; i < nchilds; i++) {
     child_values[i] = 0;
     s = pt2(s, &child_values[i]);
-    // sum += child_values[i];
   }
 
   for (int i = 0; i < nmetadata; i++) {
@@ -64,8 +65,8 @@ const char *pt2(const char *s, int *sum) {
 
 int main(void) {
   clock_t t = clock_time();
-  char input[1024 * 64];
-  read_input_file(input, 1024 * 64, "08.txt");
+  char input[64 << 10];
+  read_input_file(input, 64 << 10, "08.txt");
 
   int a1 = 0;
   pt1(input, &a1);

2018-c/09.c

@@ -6,16 +6,19 @@
 
 #define PUZZLE_NAME "Day 9: Marble Mania"
 
+// Puzzle input
+#define NPLAYERS 458
+#define NMARBLES 72019
+
 struct node {
   unsigned long value;
   struct node *next;
   struct node *prev;
 };
 
-static inline unsigned long max(const unsigned int size,
-                                const unsigned long arr[size]) {
+static unsigned long max(const unsigned long arr[static NPLAYERS]) {
   unsigned int mi = 1;
-  for (unsigned int i = 2; i < size; i++) {
+  for (unsigned int i = 2; i < NPLAYERS; i++) {
     if (arr[i] > arr[mi]) {
       mi = i;
     }
@@ -24,27 +27,25 @@ static inline unsigned long max(const unsigned int size,
   return arr[mi];
 }
 
-unsigned long play(const unsigned int nplayers, const unsigned long nmarbles) {
+static unsigned long play(const unsigned long nmarbles) {
   struct node *marbles = malloc_or_die(sizeof(struct node) * (nmarbles + 1));
   for (unsigned long m = 0; m <= nmarbles; m++) {
     marbles[m].value = m;
     marbles[m].prev = NULL;
     marbles[m].next = NULL;
   }
 
-  unsigned long scores[nplayers];
-  memset(scores, 0, sizeof(unsigned long) * (unsigned long)(nplayers));
-
+  unsigned long scores[NPLAYERS] = {0};
   struct node *cur = &marbles[0];
   cur->next = cur;
   cur->prev = cur;
   unsigned int player = 0;
-  for (unsigned long m = 1; m <= nmarbles; m++, player++, player %= nplayers) {
+  for (unsigned long m = 1; m <= nmarbles; m++, player++, player %= NPLAYERS) {
 
     if (m % 23 == 0) {
       scores[player] += m;
       struct node *item = cur;
-      for (int i = 0; i < 7; i++) {
+      for (unsigned int i = 0; i < 7; i++) {
         item = item->prev;
       }
       scores[player] += item->value;
@@ -64,17 +65,14 @@ unsigned long play(const unsigned int nplayers, const unsigned long nmarbles) {
   }
 
   free(marbles);
-  return max(nplayers, scores);
+  return max( scores);
 }
 
 int main(void) {
   clock_t t = clock_time();
 
-  const unsigned int nplayers = 458;
-  const unsigned long nmarbles = 72019;
-
-  unsigned long pt1 = play(nplayers, nmarbles);
-  unsigned long pt2 = play(nplayers, nmarbles * 100);
+  unsigned long pt1 = play(NMARBLES);
+  unsigned long pt2 = play(NMARBLES * 100);
 
   printf("--- %s ---\n", PUZZLE_NAME);
   printf("Part 1: %ld\n", pt1);

2018-c/10.c

@@ -13,12 +13,15 @@ struct Point {
   int vx, vy;
 };
 
-static void print(const struct Point points[], const unsigned int npoints,
+static void print(const struct Point points[static 512], const unsigned int npoints,
                   const int x1, const int y1, const int x2, const int y2) {
   unsigned w = (unsigned) (x2 - x1) + 1;
   unsigned h = (unsigned) (y2 - y1) + 1;
-  char grid[h][w];
-  memset(grid, ' ', (unsigned int)w * (unsigned int)h * sizeof(char));
+
+  assert(h <= 12);
+  assert(w <= 64);
+  char grid[12][64];
+  memset(grid, ' ', 12 * 64 * sizeof(char));
 
   for (unsigned p = 0; p < npoints; p++) {
     unsigned y = (unsigned) (points[p].py - y1);

2018-c/11.c

@@ -28,7 +28,7 @@ static inline int power_level(const unsigned x, const unsigned y,
   return -5;
 }
 
-struct Answer solve_pt1(const int serial_number) {
+static struct Answer solve_pt1(const int serial_number) {
   int max = INT_MIN;
   unsigned xmax = 0;
   unsigned ymax = 0;
@@ -52,7 +52,7 @@ struct Answer solve_pt1(const int serial_number) {
   return (struct Answer){xmax + 1, ymax + 1, 3};
 }
 
-struct Answer solve_pt2(const int serial_number) {
+static struct Answer solve_pt2(const int serial_number) {
   int max = INT_MIN;
   struct Answer a;
 

2018-c/12.c

@@ -5,17 +5,16 @@
 #include <time.h>
 
 #define PUZZLE_NAME "Day 12: Subterranean Sustainability"
-
-static const unsigned PADDING = 200; // should be larger than # of cycles
-static const unsigned INITIAL_PLANTS = 99;
-static const unsigned WIDTH = INITIAL_PLANTS + PADDING * 2;
+#define PADDING 200 // should be larger than # of cycles
+#define INITIAL_PLANTS 99
+#define WIDTH (INITIAL_PLANTS + PADDING * 2)
 
 struct Pattern {
   char in[5];
   char out;
 };
 
-unsigned long count_plants(const char plants[WIDTH], unsigned long offset) {
+static unsigned long count_plants(const char plants[static WIDTH], const unsigned long offset) {
   unsigned long count = 0;
 
   // for part 2 I noticed the grid would stabilise
@@ -31,7 +30,7 @@ unsigned long count_plants(const char plants[WIDTH], unsigned long offset) {
   return count;
 }
 
-void growth_cycles(char plants[WIDTH], const struct Pattern patterns[],
+static void growth_cycles(char plants[static WIDTH], const struct Pattern patterns[],
                    const unsigned npatterns, const unsigned ncycles) {
   char next[WIDTH];
   for (unsigned g = 0; g < ncycles; g++) {
@@ -68,8 +67,7 @@ int main(void) {
 
   unsigned npatterns = 0;
   struct Pattern patterns[64];
-  while (fgets(line, 1024, stdin)) {
-
+  while (fgets(line, 1024, stdin) && npatterns < 64) {
     // we only need to know about the patterns that result into a plant
     if (line[9] != '#') {
       continue;

2018-c/18.c

@@ -25,7 +25,7 @@ struct Count {
   int open;
 };
 
-static struct Count visit_adjacent(const char *grid, const size_t width,
+static struct Count visit_adjacent(const char grid[static 50*50], const size_t width,
                                    const unsigned int r1,
                                    const unsigned int c1) {
   struct Count cnt = {0, 0, 0};
@@ -59,8 +59,8 @@ static struct Count visit_adjacent(const char *grid, const size_t width,
   return cnt;
 }
 
-static void step(const size_t width, char grid[width * width],
-                 char next[width * width]) {
+static void step(const size_t width, char grid[static 50*50],
+                 char next[static 50*50]) {
   for (unsigned r = 0; r < width; r++) {
     for (unsigned c = 0; c < width; c++) {
       const struct Count cnt = visit_adjacent(grid, width, r, c);
@@ -95,10 +95,7 @@ static void step(const size_t width, char grid[width * width],
   }
 
   // swap pointers
-  // char *tmp = grid;
   memcpy(grid, next, width * width * sizeof(char));
-  // grid = next;
-  // next = tmp;
 }
 
 struct Cycle {
@@ -113,7 +110,7 @@ struct Cycle {
 Floyd's tortoise and hare cycle-finding algorithm
 See https://en.wikipedia.org/wiki/Cycle_detection
 */
-static struct Cycle floyd(const size_t width, const char grid[width * width]) {
+static struct Cycle floyd(const size_t width, const char grid[static 50*50]) {
   const size_t n = width * width * sizeof(char);
   char *tortoise = malloc(n);
   char *hare = malloc(n);
@@ -180,7 +177,7 @@ static struct Cycle floyd(const size_t width, const char grid[width * width]) {
   return (struct Cycle){mu, lam};
 }
 
-static unsigned grid_value(const size_t width, const char grid[width * width]) {
+static unsigned grid_value(const size_t width, const char grid[static 50*50]) {
   unsigned trees = 0;
   unsigned lumberyards = 0;
   const size_t sz = width * width;
@@ -198,7 +195,7 @@ static unsigned grid_value(const size_t width, const char grid[width * width]) {
   return trees * lumberyards;
 }
 
-static unsigned int nsteps(const size_t width, const char grid[width * width],
+static unsigned int nsteps(const size_t width, const char grid[static 50*50],
                           unsigned nsteps) {
   const size_t n = width * width * sizeof(char);
   char *cur = malloc(n);
@@ -226,6 +223,7 @@ int main(void) {
   char *grid = malloc(grid_size * sizeof(char));
   assert(grid != NULL);
   const size_t width = parse(grid);
+  assert(width <= 50);
 
   const unsigned int pt1 = nsteps(width, grid, 10);