Rewrite font_compile.pl to C

tools/.gitignore

@@ -1,3 +1,4 @@
 /memdump
 /blkdump
 /upload
+/fontcompile

tools/Makefile

@@ -1,10 +1,8 @@
 MEMDUMP_TGT = memdump
-MEMDUMP_SRC = memdump.c
 BLKDUMP_TGT = blkdump
-BLKDUMP_SRC = blkdump.c
 UPLOAD_TGT = upload
-UPLOAD_SRC = upload.c
+FONTCOMPILE_TGT = fontcompile
-TARGETS = $(MEMDUMP_TGT) $(BLKDUMP_TGT) $(UPLOAD_TGT)
+TARGETS = $(MEMDUMP_TGT) $(BLKDUMP_TGT) $(UPLOAD_TGT) $(FONTCOMPILE_TGT)
 OBJS = common.o
 
 all: $(TARGETS)
@@ -13,14 +11,8 @@ all: $(TARGETS)
 .c.o:
 	$(CC) $(CFLAGS) -c $< -o $@
 
-$(MEMDUMP_TGT): $(MEMDUMP_SRC) $(OBJS)
+$(TARGETS): $@.c $(OBJS)
-	$(CC) $(CFLAGS) $(MEMDUMP_SRC) $(OBJS) -o $@
+	$(CC) $(CFLAGS) $@.c $(OBJS) -o $@
-
-$(BLKDUMP_TGT): $(BLKDUMP_SRC) $(OBJS)
-	$(CC) $(CFLAGS) $(BLKDUMP_SRC) $(OBJS) -o $@
-
-$(UPLOAD_TGT): $(UPLOAD_SRC) $(OBJS)
-	$(CC) $(CFLAGS) $(UPLOAD_SRC) $(OBJS) -o $@
 
 .PHONY: clean
 clean:

tools/font_compile.pl

@@ -1,35 +0,0 @@
-#!/usr/bin/perl
-use strict;
-
-# This script converts "space-dot" fonts to binary "glyph rows". One byte for
-# each row. In a 5x7 font, each glyph thus use 7 bytes.
-# Resulting bytes are aligned to the **left** of the byte. Therefore, for
-# a 5-bit wide char, ". . ." translates to 0b10101000
-# Left-aligned bytes are easier to work with when compositing glyphs.
-
-my $fn = @ARGV[0];
-unless ($fn =~ /.*(\d)x(\d)\.txt/) { die "$fn isn't a font filename" };
-my ($width, $height) = ($1, $2);
-
-if ($width > 8) { die "Can't have a width > 8"; }
-
-print STDERR "Reading a $width x $height font.\n";
-
-my $handle;
-unless (open($handle, '<', $fn)) { die "Can't open $fn"; }
-
-# We start the binary data with our first char, space, which is not in our input
-# but needs to be in our output.
-print pack('C*', (0) x $height);
-
-while (<$handle>) {
-    unless (/( |\.){0,${width}}\n/) { die "Invalid line format '$_'"; }
-    my @line = split //, $_;
-    my $num = 0;
-    for (my $i=0; $i<$width; $i++) {
-        if (@line[$i] eq '.') {
-            $num += (1 << (7-$i));
-        }
-    }
-    print pack('C', $num);
-}

tools/fontcompile.c

@@ -0,0 +1,71 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <libgen.h>
+
+/* This script converts "space-dot" fonts to binary "glyph rows". One byte for
+ * each row. In a 5x7 font, each glyph thus use 7 bytes.
+ * Resulting bytes are aligned to the **left** of the byte. Therefore, for
+ * a 5-bit wide char, ". . ." translates to 0b10101000
+ * Left-aligned bytes are easier to work with when compositing glyphs.
+ */
+
+int main(int argc, char **argv)
+{
+    if (argc != 2) {
+        fprintf(stderr, "Usage: ./fontcompile fpath\n");
+        return 1;
+    }
+    char *fn = basename(argv[1]);
+    if (!fn) {
+        return 1;
+    }
+    int w = 0;
+    if ((fn[0] >= '3') && (fn[0] <= '8')) {
+        w = fn[0] - '0';
+    }
+    int h = 0;
+    if ((fn[2] >= '3') && (fn[2] <= '8')) {
+        h = fn[2] - '0';
+    }
+    if (!w || !h || fn[1] != 'x') {
+        fprintf(stderr, "Not a font filename: (3-8)x(3-8).txt.\n");
+        return 1;
+    }
+    fprintf(stderr, "Reading a %d x %d font\n", w, h);
+    FILE *fp = fopen(argv[1], "r");
+    if (!fp) {
+        fprintf(stderr, "Can't open %s.\n", argv[1]);
+        return 1;
+    }
+    // We start the binary data with our first char, space, which is not in our
+    // input but needs to be in our output.
+    for (int i=0; i<h; i++) {
+        putchar(0);
+    }
+    int lineno = 1;
+    char buf[0x10];
+    while (fgets(buf, 0x10, fp)) {
+        size_t l = strlen(buf);
+        if (l > w+1) { // +1 because of the newline char.
+            fprintf(stderr, "Line %d too long.\n", lineno);
+            fclose(fp);
+            return 1;
+        }
+        // line can be narrower than width. It's padded with spaces.
+        while (l < w+1) {
+            buf[l] = ' ';
+            l++;
+        }
+        unsigned char c = 0;
+        for (int i=0; i<w; i++) {
+            if (buf[i] == '.') {
+                c |= (1 << (7-i));
+            }
+        }
+        putchar(c);
+        lineno++;
+    }
+    fclose(fp);
+    return 0;
+}