create a macro to reduce the head strain of getting the width of a type

Was facing issues with integer wrapping

.github/workflows/publish.yaml

@@ -0,0 +1,34 @@
+name: publish
+on:
+  release:
+    types: published
+  workflow_dispatch:
+    inputs:
+      release_tag:
+        required: true
+        description: the tag to release for
+        default: ""
+jobs:
+  release_bin:
+    runs-on: ${{matrix.os}}
+    strategy:
+      matrix:
+        os:
+          - ubuntu-24.04
+          - ubuntu-24.04-arm
+    steps:
+      - uses: actions/checkout@v4
+      - run: make compile
+      - run: echo "FNAME=coinflip-$(uname -s)-$(uname -m)" >>"$GITHUB_ENV"
+      - run: mv bin/coinflip "$FNAME"
+      - uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{github.event.release.tag_name || github.event.inputs.release_tag}}
+          files: ${{env.FNAME}}
+          fail_on_unmatched_files: true
+        env:
+          GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}
+      - if: ${{env.ACT}}
+        uses: actions/upload-artifact@v4
+        with:
+          path: ${{env.FNAME}}

.gitignore

@@ -1,3 +1,8 @@
-.vscode
-build
-package/usr
+.*
+
+!.github/
+!.gitignore
+
+/bin/
+/obj/
+/compile_commands.json

makefile

@@ -0,0 +1,32 @@
+CC      ?= cc
+CFLAGS  += -Wall -Wextra -Wpedantic -O3 -MD -MP -std=gnu99 -DNDEBUG
+LDFLAGS +=
+
+SRC = $(shell find src/ -name '*.c')
+OBJ := $(patsubst src/%,obj/%,$(SRC:.c=.o))
+BIN := bin/coinflip
+
+compile: compile_commands.json $(BIN)
+clean:
+	rm -rf obj/ bin/ compile_commands.json
+
+# link the .o files
+$(BIN): $(OBJ)
+	@mkdir -p $(@D)
+	$(CC) $(LDFLAGS) $(OBJ) -o $(BIN)
+
+# compile .o files (w/ .d files)
+obj/%.o: src/%.c
+	@mkdir -p $(@D)
+	$(CC) -c $(CFLAGS) -o $@ $<
+
+ifneq ($(shell which bear),)
+compile_commands.json: makefile
+	$(MAKE) clean
+	@touch compile_commands.json
+	bear -- make compile
+else
+compile_commands.json:
+endif
+
+-include $(OBJ:.o=.d)

package/DEBIAN/control

@@ -1,6 +0,0 @@
-Package: coinflip
-Version: 1.0
-Architecture: all
-Priority: optional
-Maintainer: Quinn
-Description: adds a coinflip command which has a 50% chance of printing "heads" and 50% chance of printing "tails"

src/main.c

@@ -1,18 +1,91 @@
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdint.h>
 #include <stdio.h>
-#include <time.h>
 #include <stdlib.h>
+#include <sys/random.h>
+#include <time.h>
 
-int main(void) {
-    srand(time(NULL)); // set the random seed to the system time
-    char* result = NULL;
+#define error(ret, s, ...)                             \
+	do {                                               \
+		fprintf(stderr, (s)__VA_OPT__(, __VA_ARGS__)); \
+		exit(ret);                                     \
+	} while (0)
 
-    if (rand() & (~1) != 0) {
-        result = "heads";
-    }
-    else {
-        result = "tails";
-    }
+#define WIDTHOF(x) (sizeof(x) * 8)
 
-    printf("%s\n", result);
-    return 0;
+typedef unsigned long long ull;
+
+typedef struct dynrdat {
+	size_t cap;
+	ull dat[];
+} dynrdat;
+
+dynrdat* rdat = NULL;
+
+static inline ull pow2_ceil(ull x) {
+	x -= !!x; // if x=0, remains 0; else x -= 1
+	return 1ULL << (WIDTHOF(ull) - __builtin_clzll(x | 1));
+}
+
+static void quit(void) {
+	free(rdat);
+}
+
+int main(int argc, char** argv) {
+	// return the result if no input
+	if (argc <= 1) return printf("%s\n", (clock() & 1) ? "heads" : "tails");
+	atexit(quit);
+
+	// loop through arguments
+	for (unsigned i = 1; i < (unsigned)argc; ++i) {
+		// parse the argument
+		errno = 0;
+		ull c = strtoull(argv[i], NULL, 10);
+		if (errno != 0) error(errno, "parse error for string: '%s'\n", argv[i]);
+
+		// acquire random data (compiler will optimize MOD and DIV away since they're both base-2 constant values)
+		int mod = c % WIDTHOF(ull); // get the remainder of the available random bits
+		c = c / WIDTHOF(ull);       // compute our "word count"
+
+		// dynamically scale the array to our needs, ensuring 2^n scaling
+		size_t cap = pow2_ceil(c + !!mod);
+		if (!rdat || rdat->cap < cap) {
+			void* ptr = realloc(rdat, sizeof(dynrdat) + sizeof(ull) * cap);
+			if (!ptr) error(1, "insufficient memory\n", );
+
+			rdat = ptr;
+			rdat->cap = cap;
+		}
+
+		// populate the array with random data
+		if (getrandom(rdat->dat, (c + !!mod) * sizeof(ull), 0) < 0)
+			error(1, "failed to acquire random data!\n", );
+
+		// perform for the input count
+		ull headsc = 0; // amount of heads
+		ull tailsc = 0; // amount of tails
+
+		// loop through how many full words there are available
+		ull* n = rdat->dat; // initialize the pointer to the start of our random data
+		for (; n < (rdat->dat + c); n++) {
+			int cnt = __builtin_popcountll(*n); // counts the set bits
+			headsc += cnt;
+			tailsc += WIDTHOF(ull) - cnt;
+		}
+
+		// if there is a remainder, use the last N to get this
+		if (mod) {
+			ull msk = (1 << mod) - 1; // get a mask with the set word size
+			int cnt = __builtin_popcountll(*n & msk);
+			headsc += cnt;
+			tailsc += mod - cnt;
+		}
+
+		// print the results of this cycle
+		printf("results:\n heads: %llu\n tails: %llu\n", headsc, tailsc);
+	}
+
+	return 0;
 }