Tidy.

Update ab.

.github/workflows/ccpp.yml

@@ -2,88 +2,97 @@ name: C/C++ CI
 
 on: [push]
 
+concurrency: 
+  group: environment-${{ github.head_ref }}
+  cancel-in-progress: true
+
 jobs:
   build-linux:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v4
+      with:
+        repository: 'davidgiven/fluxengine'
+        path: 'fluxengine'
+    - uses: actions/checkout@v4
+      with:
+        repository: 'davidgiven/fluxengine-testdata'
+        path: 'fluxengine-testdata'
     - name: apt
-      run: sudo apt update && sudo apt install libudev-dev libsqlite3-dev protobuf-compiler libwxgtk3.0-gtk3-dev libfmt-dev
+      run: |
+        sudo apt install libudev-dev libsqlite3-dev protobuf-compiler libwxgtk3.0-gtk3-dev libfmt-dev libprotobuf-dev wx-common
     - name: make
-      run: CXXFLAGS="-Wp,-D_GLIBCXX_ASSERTIONS" make -j2
+      run: CXXFLAGS="-Wp,-D_GLIBCXX_ASSERTIONS" make -j`nproc` -C fluxengine
 
   build-macos-current:
-    runs-on: macos-latest
+    runs-on: macos-13
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
+      with:
+        repository: 'davidgiven/fluxengine'
+        path: 'fluxengine'
+    - uses: actions/checkout@v4
+      with:
+        repository: 'davidgiven/fluxengine-testdata'
+        path: 'fluxengine-testdata'
     - name: brew
       run: brew install sqlite pkg-config libusb protobuf wxwidgets fmt make coreutils dylibbundler libjpeg
     - name: make
-      run: gmake -j2
+      run: gmake -j`nproc` -C fluxengine
 
     - name: Upload build artifacts
-      uses: actions/upload-artifact@v2
+      uses: actions/upload-artifact@v4
       with:
-        name: ${{ github.event.repository.name }}.${{ github.sha }}
-        path: FluxEngine.pkg
-
-  build-macos-10-15:
-    runs-on: macos-10.15
-    steps:
-    - uses: actions/checkout@v2
-    - name: brew
-      run: brew install sqlite pkg-config libusb protobuf wxwidgets fmt make coreutils dylibbundler libjpeg
-    - name: make
-      run: |
-        gmake -j2
-        mv FluxEngine.pkg FluxEngine-10.15.pkg
-
-    - name: Upload build artifacts
-      uses: actions/upload-artifact@v2
-      with:
-        name: ${{ github.event.repository.name }}.${{ github.sha }}
-        path: FluxEngine-10.15.pkg
+        name: ${{ github.event.repository.name }}.${{ github.sha }}.fluxengine.pkg
+        path: fluxengine/FluxEngine.pkg
 
   build-windows:
     runs-on: windows-latest
-    defaults:
-      run:
-        shell: msys2 {0}
+
     steps:
-    - uses: msys2/setup-msys2@v2
+    - name: setup WSL
+      run: |
+        curl -L https://github.com/WhitewaterFoundry/Fedora-Remix-for-WSL/releases/download/40.1.0/Fedora-Remix-for-WSL-SL_40.1.0.0_x64_arm64.msixbundle -o fedora.msixbundle
+        unzip fedora.msixbundle Fedora-Remix-for-WSL-SL_40.1.0.0_x64.msix
+        unzip Fedora-Remix-for-WSL-SL_40.1.0.0_x64.msix install.tar.gz
+        wsl --update
+        wsl --set-default-version 2
+        wsl --import fedora fedora install.tar.gz
+        wsl --set-default fedora
+        wsl sh -c 'dnf -y install https://github.com/rpmsphere/noarch/raw/master/r/rpmsphere-release-38-1.noarch.rpm'
+        wsl sh -c 'dnf -y install --setop=install_weak_deps=False gcc gcc-c++ protobuf-c-compiler protobuf-devel fmt-devel systemd-devel sqlite-devel wxGTK-devel mingw32-gcc mingw32-gcc-c++ mingw32-zlib-static mingw32-protobuf-static mingw32-sqlite-static mingw32-wxWidgets3-static mingw32-libpng-static mingw32-libjpeg-static mingw32-libtiff-static mingw32-nsis png2ico'
+
+    - name: fix line endings
+      run: |
+        git config --global core.autocrlf false
+        git config --global core.eol lf
+        
+    - uses: actions/checkout@v4
       with:
-        update: true
-        msystem: MINGW32
-        install: >-
-          diffutils
-          make
-          mingw-w64-i686-fmt
-          mingw-w64-i686-gcc
-          mingw-w64-i686-libusb
-          mingw-w64-i686-pkg-config
-          mingw-w64-i686-protobuf
-          mingw-w64-i686-sqlite3
-          mingw-w64-i686-wxWidgets
-          mingw-w64-i686-zlib
-          mingw-w64-i686-nsis
-          zip
-          vim
-    - uses: actions/checkout@v1
-    - name: build
-      run: make -j2
+        repository: 'davidgiven/fluxengine'
+        path: 'fluxengine'
+
+    - uses: actions/checkout@v4
+      with:
+        repository: 'davidgiven/fluxengine-testdata'
+        path: 'fluxengine-testdata'
+
+    - name: run
+      run: |
+        wsl sh -c 'make -C fluxengine BUILDTYPE=windows -j$(nproc)'
 
     - name: nsis
       run: |
-        strip fluxengine.exe -o fluxengine-stripped.exe
-        strip fluxengine-gui.exe -o fluxengine-gui-stripped.exe
-        makensis -v2 -nocd -dOUTFILE=fluxengine-installer.exe extras/windows-installer.nsi
+        wsl sh -c 'cd fluxengine && strip fluxengine.exe -o fluxengine-stripped.exe'
+        wsl sh -c 'cd fluxengine && strip fluxengine-gui.exe -o fluxengine-gui-stripped.exe'
+        wsl sh -c 'cd fluxengine && makensis -v2 -nocd -dOUTFILE=fluxengine-installer.exe extras/windows-installer.nsi'
 
     - name: zip
       run: |
-        zip -9 fluxengine-windows.zip fluxengine.exe fluxengine-gui.exe upgrade-flux-file.exe brother120tool.exe brother240tool.exe FluxEngine.cydsn/CortexM3/ARM_GCC_541/Release/FluxEngine.hex fluxengine-installer.exe
+        wsl sh -c 'cd fluxengine && zip -9 fluxengine-windows.zip fluxengine.exe fluxengine-gui.exe upgrade-flux-file.exe brother120tool.exe brother240tool.exe FluxEngine.cydsn/CortexM3/ARM_GCC_541/Release/FluxEngine.hex fluxengine-installer.exe'
 
     - name: Upload build artifacts
-      uses: actions/upload-artifact@v2
+      uses: actions/upload-artifact@v4
       with:
-        name: ${{ github.event.repository.name }}.${{ github.sha }}
-        path: fluxengine-windows.zip
+        name: ${{ github.event.repository.name }}.${{ github.sha }}.windows.zip
+        path: fluxengine/fluxengine-windows.zip

.github/workflows/release.yml

@@ -1,5 +1,9 @@
 name: Autorelease
 
+concurrency: 
+  group: environment-release-${{ github.head_ref }}
+  cancel-in-progress: true
+
 on:
   push:
     branches:
@@ -8,43 +12,43 @@ on:
 jobs:
   dev-release:
     runs-on: windows-latest
-    defaults:
-      run:
-        shell: msys2 {0}
-    steps:
-    - uses: msys2/setup-msys2@v2
-      with:
-        update: true
-        msystem: MINGW32
-        install: >-
-          diffutils
-          make
-          mingw-w64-i686-fmt
-          mingw-w64-i686-gcc
-          mingw-w64-i686-libusb
-          mingw-w64-i686-pkg-config
-          mingw-w64-i686-protobuf
-          mingw-w64-i686-sqlite3
-          mingw-w64-i686-wxWidgets
-          mingw-w64-i686-zlib
-          mingw-w64-i686-nsis
-          zip
-          vim
-    - uses: actions/checkout@v3
 
-    - name: build
+    steps:
+    - name: setup WSL
       run: |
-        make -j2
+        curl -L https://github.com/WhitewaterFoundry/Fedora-Remix-for-WSL/releases/download/39.0.1/Fedora-Remix-for-WSL-SL_39.0.1.0_x64_arm64.msixbundle -o fedora.msixbundle
+        unzip fedora.msixbundle Fedora-Remix-for-WSL-SL_39.0.1.0_x64.msix
+        unzip Fedora-Remix-for-WSL-SL_39.0.1.0_x64.msix install.tar.gz
+        wsl --update
+        wsl --set-default-version 2
+        wsl --import fedora fedora install.tar.gz
+        wsl --set-default fedora
+        wsl sh -c 'dnf -y install https://github.com/rpmsphere/noarch/raw/master/r/rpmsphere-release-38-1.noarch.rpm'
+        wsl sh -c 'dnf -y install --setop=install_weak_deps=False gcc gcc-c++ protobuf-c-compiler protobuf-devel fmt-devel systemd-devel sqlite-devel wxGTK-devel mingw32-gcc mingw32-gcc-c++ mingw32-zlib-static mingw32-protobuf-static mingw32-sqlite-static mingw32-wxWidgets3-static mingw32-libpng-static mingw32-libjpeg-static mingw32-libtiff-static mingw32-nsis png2ico'
+
+    - name: fix line endings
+      run: |
+        git config --global core.autocrlf false
+        git config --global core.eol lf
+        
+    - uses: actions/checkout@v4
+      with:
+        repository: 'davidgiven/fluxengine'
+        path: 'fluxengine'
+
+    - name: run
+      run: |
+        wsl sh -c 'cd fluxengine && make BUILDTYPE=windows -j$(nproc)'
 
     - name: nsis
       run: |
-        strip fluxengine.exe -o fluxengine-stripped.exe
-        strip fluxengine-gui.exe -o fluxengine-gui-stripped.exe
-        makensis -v2 -nocd -dOUTFILE=fluxengine-installer.exe extras/windows-installer.nsi
+        wsl sh -c 'cd fluxengine && strip fluxengine.exe -o fluxengine-stripped.exe'
+        wsl sh -c 'cd fluxengine && strip fluxengine-gui.exe -o fluxengine-gui-stripped.exe'
+        wsl sh -c 'cd fluxengine && makensis -v2 -nocd -dOUTFILE=fluxengine-installer.exe extras/windows-installer.nsi'
 
     - name: zip
       run: |
-        zip -9 fluxengine.zip fluxengine.exe fluxengine-gui.exe upgrade-flux-file.exe brother120tool.exe brother240tool.exe FluxEngine.cydsn/CortexM3/ARM_GCC_541/Release/FluxEngine.hex
+        wsl sh -c 'cd fluxengine && zip -9 fluxengine-windows.zip fluxengine.exe fluxengine-gui.exe upgrade-flux-file.exe brother120tool.exe brother240tool.exe FluxEngine.cydsn/CortexM3/ARM_GCC_541/Release/FluxEngine.hex fluxengine-installer.exe'
 
     - name: date
       run: |
@@ -55,6 +59,7 @@ jobs:
       with:
         tag-name: dev
         force-branch: false
+        git-directory: 'fluxengine'
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
@@ -73,20 +78,22 @@ jobs:
       with:
         name: Development build ${{ env.RELEASE_DATE }}
         files: |
-          fluxengine.zip
-          fluxengine-installer.exe
+          fluxengine/fluxengine.zip
+          fluxengine/fluxengine-installer.exe
         tag_name: dev
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
   build-macos:
-    runs-on: macos-latest
+    runs-on: macos-13
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
+
     - name: brew
       run: brew install sqlite pkg-config libusb protobuf wxwidgets fmt make coreutils dylibbundler libjpeg
+
     - name: make
-      run: gmake
+      run: gmake -j`nproc`
 
     - name: tag
       uses: EndBug/latest-tag@latest

.hgignore

@@ -1,4 +1,5 @@
 .obj
+.git
 streams
 .*\.flux
 .*\.img

Makefile

@@ -1,256 +1,96 @@
+export BUILDTYPE
+BUILDTYPE ?= host
+
+ifeq ($(BUILDTYPE),windows)
+	MINGW = i686-w64-mingw32-
+	CC = $(MINGW)gcc
+	CXX = $(MINGW)g++ -std=c++17
+	CFLAGS += -g -O3
+	CXXFLAGS += \
+		-fext-numeric-literals \
+		-Wno-deprecated-enum-float-conversion \
+		-Wno-deprecated-enum-enum-conversion
+	LDFLAGS += -static
+	AR = $(MINGW)ar
+	PKG_CONFIG = $(MINGW)pkg-config -static
+	WINDRES = $(MINGW)windres
+	WX_CONFIG = /usr/i686-w64-mingw32/sys-root/mingw/bin/wx-config-3.0 --static=yes
+	EXT = .exe
+else
+	CC = gcc
+	CXX = g++ -std=c++17
+	CFLAGS = -g -O3
+	LDFLAGS =
+	AR = ar
+	PKG_CONFIG = pkg-config
+endif
+
+HOSTCC = gcc
+HOSTCXX = g++ -std=c++17
+HOSTCFLAGS = -g -O3
+HOSTLDFLAGS =
+
+REALOBJ = .obj
+OBJ = $(REALOBJ)/$(BUILDTYPE)
+DESTDIR ?=
+PREFIX ?= /usr/local
+BINDIR ?= $(PREFIX)/bin
+
 # Special Windows settings.
 
 ifeq ($(OS), Windows_NT)
+	EXT ?= .exe
 	MINGWBIN = /mingw32/bin
 	CCPREFIX = $(MINGWBIN)/
-	LUA = $(MINGWBIN)/lua
 	PKG_CONFIG = $(MINGWBIN)/pkg-config
 	WX_CONFIG = /usr/bin/sh $(MINGWBIN)/wx-config --static=yes
 	PROTOC = $(MINGWBIN)/protoc
-	PLATFORM = WINDOWS
+	WINDRES = windres
 	LDFLAGS += \
 		-static
 	CXXFLAGS += \
-		-std=c++17 \
 		-fext-numeric-literals \
 		-Wno-deprecated-enum-float-conversion \
 		-Wno-deprecated-enum-enum-conversion
 
-	# Required to get the gcc run-time libraries on the path.
+	# Required to get the gcc run - time libraries on the path.
 	export PATH := $(PATH):$(MINGWBIN)
-	EXT ?= .exe
 endif
 
 # Special OSX settings.
 
 ifeq ($(shell uname),Darwin)
-	PLATFORM = OSX
 	LDFLAGS += \
 		-framework IOKit \
-		-framework Foundation
+		-framework Foundation 
 endif
 
-# Check the Make version.
+.PHONY: all
+all: +all README.md
 
+.PHONY: binaries tests
+binaries: all
+tests: all
+	
+README.md: $(OBJ)/scripts/+mkdocindex/mkdocindex$(EXT)
+	@echo MKDOC $@
+	@csplit -s -f$(OBJ)/README. README.md '/<!-- FORMATSSTART -->/' '%<!-- FORMATSEND -->%'
+	@(cat $(OBJ)/README.00 && $< && cat $(OBJ)/README.01) > README.md
 
-ifeq ($(findstring 4.,$(MAKE_VERSION)),)
-$(error You need GNU Make 4.x for this (if you're on OSX, use gmake).)
-endif
+.PHONY: tests
 
-# Normal settings.
+.PHONY: install install-bin
+install:: all install-bin
 
-OBJDIR ?= .obj
-CCPREFIX ?=
-LUA ?= lua
-CC ?= $(CCPREFIX)gcc
-CXX ?= $(CCPREFIX)g++
-AR ?= $(CCPREFIX)ar
-PKG_CONFIG ?= pkg-config
-WX_CONFIG ?= wx-config
-PROTOC ?= protoc
-CFLAGS ?= -g -O3
-CXXFLAGS += -std=c++17
-LDFLAGS ?=
-PLATFORM ?= UNIX
-TESTS ?= yes
-EXT ?=
-DESTDIR ?=
-PREFIX ?= /usr/local
-BINDIR ?= $(PREFIX)/bin
+clean::
+	$(hide) rm -rf $(REALOBJ)
 
-CFLAGS += \
-	-Iarch \
-	-Ilib \
-	-I. \
-	-I$(OBJDIR)/arch \
-	-I$(OBJDIR)/lib \
-	-I$(OBJDIR) \
+install-bin:
+	@echo "INSTALL"
+	$(hide) install -D -v "$(OBJ)/src+fluxengine/src+fluxengine" "$(DESTDIR)$(BINDIR)/fluxengine"
+	$(hide) install -D -v "$(OBJ)/src/gui+gui/gui+gui" "$(DESTDIR)$(BINDIR)/fluxengine-gui"
+	$(hide) install -D -v "$(OBJ)/tools+brother120tool/tools+brother120tool" "$(DESTDIR)$(BINDIR)/brother120tool"
+	$(hide) install -D -v "$(OBJ)/tools+brother240tool/tools+brother240tool" "$(DESTDIR)$(BINDIR)/brother240tool"
+	$(hide) install -D -v "$(OBJ)/tools+upgrade-flux-file/tools+upgrade-flux-file" "$(DESTDIR)$(BINDIR)/upgrade-flux-file"
 
-LDFLAGS += \
-	-lz \
-	-lfmt
-
-.SUFFIXES:
-.DELETE_ON_ERROR:
-
-define nl
-
-endef
-
-use-library = $(eval $(use-library-impl))
-define use-library-impl
-$1: $(call $3_LIB)
-$1: private LDFLAGS += $(call $3_LDFLAGS)
-$2: private CFLAGS += $(call $3_CFLAGS)
-endef
-
-use-pkgconfig = $(eval $(use-pkgconfig-impl))
-define use-pkgconfig-impl
-ifneq ($(strip $(shell $(PKG_CONFIG) $3; echo $$?)),0)
-$$(error Missing required pkg-config dependency: $3)
-endif
-
-$(1): private LDFLAGS += $(shell $(PKG_CONFIG) --libs $(3))
-$(2): private CFLAGS += $(shell $(PKG_CONFIG) --cflags $(3))
-endef
-
-.PHONY: all binaries tests clean install install-bin
-all: binaries tests
-
-PROTOS = \
-	arch/aeslanier/aeslanier.proto \
-	arch/agat/agat.proto \
-	arch/amiga/amiga.proto \
-	arch/apple2/apple2.proto \
-	arch/brother/brother.proto \
-	arch/c64/c64.proto \
-	arch/f85/f85.proto \
-	arch/fb100/fb100.proto \
-	arch/ibm/ibm.proto \
-	arch/macintosh/macintosh.proto \
-	arch/micropolis/micropolis.proto \
-	arch/mx/mx.proto \
-	arch/northstar/northstar.proto \
-	arch/smaky6/smaky6.proto \
-	arch/tids990/tids990.proto \
-	arch/victor9k/victor9k.proto \
-	arch/zilogmcz/zilogmcz.proto \
-	lib/common.proto \
-	lib/config.proto \
-	lib/decoders/decoders.proto \
-	lib/drive.proto \
-	lib/encoders/encoders.proto \
-	lib/fl2.proto \
-	lib/fluxsink/fluxsink.proto \
-	lib/fluxsource/fluxsource.proto \
-	lib/imagereader/imagereader.proto \
-	lib/imagewriter/imagewriter.proto \
-	lib/layout.proto \
-	lib/usb/usb.proto \
-	lib/vfs/vfs.proto \
-	tests/testproto.proto \
-
-PROTO_HDRS = $(patsubst %.proto, $(OBJDIR)/%.pb.h, $(PROTOS))
-PROTO_SRCS = $(patsubst %.proto, $(OBJDIR)/%.pb.cc, $(PROTOS))
-PROTO_OBJS = $(patsubst %.cc, %.o, $(PROTO_SRCS))
-PROTO_CFLAGS = $(shell $(PKG_CONFIG) --cflags protobuf)
-$(PROTO_SRCS): | $(PROTO_HDRS)
-$(PROTO_OBJS): CFLAGS += $(PROTO_CFLAGS)
-PROTO_LIB = $(OBJDIR)/libproto.a
-$(PROTO_LIB): $(PROTO_OBJS)
-PROTO_LDFLAGS = $(shell $(PKG_CONFIG) --libs protobuf) -pthread $(PROTO_LIB)
-.PRECIOUS: $(PROTO_HDRS) $(PROTO_SRCS)
-
-include dep/agg/build.mk
-include dep/libusbp/build.mk
-include dep/stb/build.mk
-include dep/emu/build.mk
-include dep/fatfs/build.mk
-include dep/adflib/build.mk
-include dep/hfsutils/build.mk
-include scripts/build.mk
-
-include lib/build.mk
-include arch/build.mk
-include src/build.mk
-include src/gui/build.mk
-include tools/build.mk
-include tests/build.mk
-
-do-encodedecodetest = $(eval $(do-encodedecodetest-impl))
-define do-encodedecodetest-impl
-
-tests: $(OBJDIR)/$1$3.flux.encodedecode
-$(OBJDIR)/$1$3.flux.encodedecode: scripts/encodedecodetest.sh $(FLUXENGINE_BIN) $2
-	@mkdir -p $(dir $$@)
-	@echo ENCODEDECODETEST $1 flux $(FLUXENGINE_BIN) $2 $3
-	@scripts/encodedecodetest.sh $1 flux $(FLUXENGINE_BIN) $2 $3 > $$@
-
-tests: $(OBJDIR)/$1$3.scp.encodedecode
-$(OBJDIR)/$1$3.scp.encodedecode: scripts/encodedecodetest.sh $(FLUXENGINE_BIN) $2
-	@mkdir -p $(dir $$@)
-	@echo ENCODEDECODETEST $1 scp $(FLUXENGINE_BIN) $2 $3
-	@scripts/encodedecodetest.sh $1 scp $(FLUXENGINE_BIN) $2 $3 > $$@
-
-endef
-
-$(call do-encodedecodetest,agat840)
-$(call do-encodedecodetest,amiga)
-$(call do-encodedecodetest,appleii140)
-$(call do-encodedecodetest,atarist360)
-$(call do-encodedecodetest,atarist370)
-$(call do-encodedecodetest,atarist400)
-$(call do-encodedecodetest,atarist410)
-$(call do-encodedecodetest,atarist720)
-$(call do-encodedecodetest,atarist740)
-$(call do-encodedecodetest,atarist800)
-$(call do-encodedecodetest,atarist820)
-$(call do-encodedecodetest,bk800)
-$(call do-encodedecodetest,brother120)
-$(call do-encodedecodetest,brother240)
-$(call do-encodedecodetest,commodore1541,scripts/commodore1541_test.textpb,--35)
-$(call do-encodedecodetest,commodore1541,scripts/commodore1541_test.textpb,--40)
-$(call do-encodedecodetest,commodore1581)
-$(call do-encodedecodetest,cmd_fd2000)
-$(call do-encodedecodetest,hp9121)
-$(call do-encodedecodetest,ibm1200)
-$(call do-encodedecodetest,ibm1232)
-$(call do-encodedecodetest,ibm1440)
-$(call do-encodedecodetest,ibm180)
-$(call do-encodedecodetest,ibm360)
-$(call do-encodedecodetest,ibm720)
-$(call do-encodedecodetest,mac400,scripts/mac400_test.textpb)
-$(call do-encodedecodetest,mac800,scripts/mac800_test.textpb)
-$(call do-encodedecodetest,n88basic)
-$(call do-encodedecodetest,rx50)
-$(call do-encodedecodetest,tids990)
-$(call do-encodedecodetest,victor9k_ss)
-$(call do-encodedecodetest,victor9k_ds)
-
-$(OBJDIR)/%.a:
-	@mkdir -p $(dir $@)
-	@echo AR $@
-	@$(AR) rc $@ $^
-
-%.exe:
-	@mkdir -p $(dir $@)
-	@echo LINK $@
-	@$(CXX) -o $@ $^ $(LDFLAGS) $(LDFLAGS)
-
-$(OBJDIR)/%.o: %.cpp
-	@mkdir -p $(dir $@)
-	@echo CXX $<
-	@$(CXX) $(CFLAGS) $(CXXFLAGS) -MMD -MP -MF $(@:.o=.d) -c -o $@ $<
-
-$(OBJDIR)/%.o: %.cc
-	@mkdir -p $(dir $@)
-	@echo CXX $<
-	@$(CXX) $(CFLAGS) $(CXXFLAGS) -MMD -MP -MF $(@:.o=.d) -c -o $@ $<
-
-$(OBJDIR)/%.o: $(OBJDIR)/%.cc
-	@mkdir -p $(dir $@)
-	@echo CXX $<
-	@$(CXX) $(CFLAGS) $(CXXFLAGS) -MMD -MP -MF $(@:.o=.d) -c -o $@ $<
-
-$(OBJDIR)/%.o: %.c
-	@mkdir -p $(dir $@)
-	@echo CC $<
-	@$(CC) $(CFLAGS) $(CFLAGS) -MMD -MP -MF $(@:.o=.d) -c -o $@ $<
-
-$(OBJDIR)/%.pb.h: %.proto
-	@mkdir -p $(dir $@)
-	@echo PROTOC $@
-	@$(PROTOC) -I. --cpp_out=$(OBJDIR) $<
-
-clean:
-	rm -rf $(OBJDIR)
-
-install: install-bin # install-man install-docs ...
-
-install-bin: fluxengine$(EXT) fluxengine-gui$(EXT) brother120tool$(EXT) brother240tool$(EXT) upgrade-flux-file$(EXT)
-	install -d "$(DESTDIR)$(BINDIR)"
-	for target in $^; do \
-		install $$target "$(DESTDIR)$(BINDIR)/$$target"; \
-	done
-
--include $(OBJS:%.o=%.d)
+include build/ab.mk

README.md

@@ -35,11 +35,11 @@ Don't believe me? Watch the demo reel!
 </div>
 
 **New!** The FluxEngine client software now works with
-[GreaseWeazle](https://github.com/keirf/Greaseweazle/wiki) hardware. So, if you
+[Greaseweazle](https://github.com/keirf/Greaseweazle/wiki) hardware. So, if you
 can't find a PSoC5 development kit, or don't want to use the Cypress Windows
 tools for programming it, you can use one of these instead. Very nearly all
-FluxEngine features are available with the GreaseWeazle and it works out-of-the
-box. See the [dedicated GreaseWeazle documentation page](doc/greaseweazle.md)
+FluxEngine features are available with the Greaseweazle and it works out-of-the
+box. See the [dedicated Greaseweazle documentation page](doc/greaseweazle.md)
 for more information.
 
 Where?
@@ -65,7 +65,7 @@ following friendly articles:
   - [Using a FluxEngine](doc/using.md) ∾ what to do with your new hardware ∾
     flux files and image files ∾ knowing what you're doing
 
-  - [Using GreaseWeazle hardware with the FluxEngine client
+  - [Using Greaseweazle hardware with the FluxEngine client
     software](doc/greaseweazle.md) ∾ what works ∾ what doesn't work ∾ where to
     go for help
 
@@ -88,63 +88,62 @@ Which?
 
 The current support state is as follows.
 
-Dinosaurs (🦖) have yet to be observed in real life --- I've written the
-decoder based on Kryoflux (or other) dumps I've found. I don't (yet) have
-real, physical disks in my hand to test the capture process.
+Dinosaurs (🦖) have yet to be observed in real life --- I've written the encoder
+and/or decoder based on Kryoflux (or other) dumps I've found. I don't (yet) have
+real, physical disks in my hand to test the capture process, or hardware to
+verify that written disks work.
 
-Unicorns (🦄) are completely real --- this means that I've read actual,
-physical disks with these formats and so know they work (or had reports from
-people who've had it work).
+Unicorns (🦄) are completely real --- this means that I've read actual, physical
+disks with these formats and/or written real, physical disks and then used them
+on real hardware, and so know they work (or had reports from people who've had
+it work).
 
-### Old disk formats
+If a filesystem is listed, this means that FluxEngine natively supports that
+particular filesystem and can read (and sometimes write, support varies) files
+directly from disks, flux files or disk images. Some formats have multiple
+choices because they can store multiple types of file system.
 
-| Format                                    | Read? | Write? | Notes |
-|:------------------------------------------|:-----:|:------:|-------|
-| [IBM PC compatible](doc/disk-ibm.md)      |  🦄   |   🦄   | and compatibles (like the Atari ST) |
-| [Atari ST](doc/disk-atarist.md)           |  🦄   |   🦄   | technically the same as IBM, almost |
-| [Acorn ADFS](doc/disk-acornadfs.md)       |  🦄   |   🦖*  | single- and double- sided           |
-| [Acorn DFS](doc/disk-acorndfs.md)         |  🦄   |   🦖*  |                                     |
-| [Ampro Little Board](doc/disk-ampro.md)   |  🦖   |   🦖*  |                                     |
-| [Agat](doc/disk-agat.md)                  |  🦖   |        | Soviet Union Apple-II-like computer |
-| [Apple II](doc/disk-apple2.md)            |  🦄   |   🦄   | both 140kB and 640kB formats        |
-| [Amiga](doc/disk-amiga.md)                |  🦄   |   🦄   |                                     |
-| [Commodore 64 1541/1581](doc/disk-c64.md) |  🦄   |   🦄   | and probably the other formats      |
-| [Brother 120kB](doc/disk-brother.md)      |  🦄   |   🦄   |                                     |
-| [Brother 240kB](doc/disk-brother.md)      |  🦄   |   🦄   |                                     |
-| [Brother FB-100](doc/disk-fb100.md)       |  🦖   |        | Tandy Model 100, Husky Hunter, knitting machines |
-| [Elektronika BK](doc/disk-bd.md)          |  🦄   |   🦄   | Soviet Union PDP-11 clone           |
-| [Macintosh 400kB/800kB](doc/disk-macintosh.md)  |  🦄   |   🦄   |                                     |
-| [NEC PC-98](doc/disk-ibm.md)              |  🦄   |   🦄   | trimode drive not required          |
-| [pSOS](doc/disk-ibm.md)                   |  🦄   |   🦖*  | pSOS PHILE file system              |
-| [Sharp X68000](doc/disk-ibm.md)           |  🦄   |   🦄   | yet another IBM scheme             |
-| [Smaky 6](doc/disk-smaky6.md)             |  🦖   |       | 5.25" hard sectored |
-| [TRS-80](doc/disk-trs80.md)               |  🦖   |   🦖*  | a minor variation of the IBM scheme |
+<!-- FORMATSSTART -->
+<!-- This section is automatically generated. Do not edit. -->
+
+| Profile | Format | Read? | Write? | Filesystem? |
+|:--------|:-------|:-----:|:------:|:------------|
+| [`acornadfs`](doc/disk-acornadfs.md) | Acorn ADFS: BBC Micro, Archimedes | 🦖 |  |  |
+| [`acorndfs`](doc/disk-acorndfs.md) | Acorn DFS: Acorn Atom, BBC Micro series | 🦄 |  | ACORNDFS  |
+| [`aeslanier`](doc/disk-aeslanier.md) | AES Lanier "No Problem": 616kB 5.25" 77-track SSDD hard sectored | 🦖 |  |  |
+| [`agat`](doc/disk-agat.md) | Agat: 840kB 5.25" 80-track DS | 🦖 | 🦖 |  |
+| [`amiga`](doc/disk-amiga.md) | Amiga: 880kB 3.5" DSDD | 🦄 | 🦄 | AMIGAFFS  |
+| [`ampro`](doc/disk-ampro.md) | Ampro Little Board: CP/M | 🦖 |  | CPMFS  |
+| [`apple2`](doc/disk-apple2.md) | Apple II: Prodos, Appledos, and CP/M | 🦄 | 🦄 | APPLEDOS CPMFS PRODOS  |
+| [`atarist`](doc/disk-atarist.md) | Atari ST: Almost PC compatible | 🦄 | 🦄 |  |
+| [`bk`](doc/disk-bk.md) | BK: 800kB 5.25"/3.5" 80-track 10-sector DSDD | 🦖 | 🦖 |  |
+| [`brother`](doc/disk-brother.md) | Brother word processors: GCR family | 🦄 | 🦄 | BROTHER120 FATFS  |
+| [`commodore`](doc/disk-commodore.md) | Commodore: 1541, 1581, 8050 and variations | 🦄 | 🦄 | CBMFS  |
+| [`eco1`](doc/disk-eco1.md) | VDS Eco1: CP/M; 1210kB 77-track mixed format DSHD | 🦖 |  | CPMFS  |
+| [`epsonpf10`](doc/disk-epsonpf10.md) | Epson PF-10: CP/M; 3.5" 40-track DSDD | 🦖 |  | CPMFS  |
+| [`f85`](doc/disk-f85.md) | Durango F85: 461kB 5.25" 77-track SS | 🦖 |  |  |
+| [`fb100`](doc/disk-fb100.md) | Brother FB-100: 100kB 3.5" 40-track SSSD | 🦖 |  |  |
+| [`hplif`](doc/disk-hplif.md) | Hewlett-Packard LIF: a variety of disk formats used by HP | 🦄 | 🦄 | LIF  |
+| [`ibm`](doc/disk-ibm.md) | IBM PC: Generic PC 3.5"/5.25" disks | 🦄 | 🦄 | FATFS  |
+| [`icl30`](doc/disk-icl30.md) | ICL Model 30: CP/M; 263kB 35-track DSSD | 🦖 |  | CPMFS  |
+| [`mac`](doc/disk-mac.md) | Macintosh: 400kB/800kB 3.5" GCR | 🦄 | 🦄 | MACHFS  |
+| [`micropolis`](doc/disk-micropolis.md) | Micropolis: 100tpi MetaFloppy disks | 🦄 | 🦄 |  |
+| [`ms2000`](doc/disk-ms2000.md) | : MS2000 Microdisk Development System |  |  | MICRODOS  |
+| [`mx`](doc/disk-mx.md) | DVK MX: Soviet-era PDP-11 clone | 🦖 |  |  |
+| [`n88basic`](doc/disk-n88basic.md) | N88-BASIC: PC8800/PC98 5.25" 77-track 26-sector DSHD | 🦄 | 🦄 |  |
+| [`northstar`](doc/disk-northstar.md) | Northstar: 5.25" hard sectored | 🦄 | 🦄 |  |
+| [`psos`](doc/disk-psos.md) | pSOS: 800kB DSDD with PHILE | 🦄 | 🦄 | PHILE  |
+| [`rolandd20`](doc/disk-rolandd20.md) | Roland D20: 3.5" electronic synthesiser disks | 🦄 | 🦖 | ROLAND  |
+| [`rx50`](doc/disk-rx50.md) | Digital RX50: 400kB 5.25" 80-track 10-sector SSDD | 🦖 | 🦖 |  |
+| [`smaky6`](doc/disk-smaky6.md) | Smaky 6: 308kB 5.25" 77-track 16-sector SSDD, hard sectored | 🦖 |  | SMAKY6  |
+| [`tartu`](doc/disk-tartu.md) | Tartu: The Palivere and variations | 🦄 | 🦖 | CPMFS  |
+| [`tids990`](doc/disk-tids990.md) | Texas Instruments DS990: 1126kB 8" DSSD | 🦖 | 🦖 |  |
+| [`tiki`](doc/disk-tiki.md) | Tiki 100: CP/M |  |  | CPMFS  |
+| [`victor9k`](doc/disk-victor9k.md) | Victor 9000 / Sirius One: 1224kB 5.25" DSDD GCR | 🦖 | 🦖 |  |
+| [`zilogmcz`](doc/disk-zilogmcz.md) | Zilog MCZ: 320kB 8" 77-track SSSD hard-sectored | 🦖 |  | ZDOS  |
 {: .datatable }
 
-`*`: these formats are variations of the generic IBM format, and since the
-IBM writer is completely generic, it should be configurable for these
-formats... theoretically. I don't have the hardware to try it.
-
-### Even older disk formats
-
-These formats are for particularly old, weird architectures, even by the
-standards of floppy disks. They've largely been implemented from single flux
-files with no access to physical hardware. Typically the reads were pretty
-bad and I've had to make a number of guesses as to how things work. They do,
-at least, check the CRC so what data's there is probably good.
-
-| Format                                   | Read? | Write? | Notes |
-|:-----------------------------------------|:-----:|:------:|-------|
-| [AES Superplus / No Problem](doc/disk-aeslanier.md) |  🦖   | | hard sectors! |
-| [Durango F85](doc/disk-durangof85.md)    |  🦖   |        | 5.25" |
-| [DVK MX](doc/disk-mx.md)                 |  🦖   |        | Soviet PDP-11 clone |
-| [VDS Eco1](doc/disk-eco1.md)             |  🦖   |        | 8" mixed format |
-| [Micropolis](doc/disk-micropolis.md)     |  🦄   |        | Micropolis 100tpi drives |
-| [Northstar](doc/disk-northstar.md)       |  🦖   |   🦖   | 5.25" hard sectors |
-| [TI DS990 FD1000](doc/disk-tids990.md)   |  🦄   |  🦄    | 8" |
-| [Victor 9000](doc/disk-victor9k.md)      |  🦖   |        | 5.25" GCR encoded |
-| [Zilog MCZ](doc/disk-zilogmcz.md)        |  🦖   |        | 8" _and_ hard sectors |
-{: .datatable }
+<!-- FORMATSEND -->
 
 ### Notes
 
@@ -263,5 +262,3 @@ __Important:__ Because of all these exceptions, if you distribute the
 FluxEngine package as a whole, you must comply with the terms of _all_ of the
 licensing terms. This means that __effectively the FluxEngine package is
 distributable under the terms of the GPL 2.0__.
-
-

arch/aeslanier/aeslanier.h

@@ -2,9 +2,10 @@
 #define AESLANIER_H
 
 #define AESLANIER_RECORD_SEPARATOR 0x55555122
-#define AESLANIER_SECTOR_LENGTH    256
-#define AESLANIER_RECORD_SIZE      (AESLANIER_SECTOR_LENGTH + 5)
+#define AESLANIER_SECTOR_LENGTH 256
+#define AESLANIER_RECORD_SIZE (AESLANIER_SECTOR_LENGTH + 5)
 
-extern std::unique_ptr<Decoder> createAesLanierDecoder(const DecoderProto& config);
+extern std::unique_ptr<Decoder> createAesLanierDecoder(
+    const DecoderProto& config);
 
 #endif

arch/aeslanier/decoder.cc

@@ -1,66 +1,64 @@
-#include "globals.h"
-#include "decoders/decoders.h"
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
 #include "aeslanier.h"
-#include "crc.h"
-#include "fluxmap.h"
-#include "decoders/fluxmapreader.h"
-#include "sector.h"
-#include "bytes.h"
+#include "lib/crc.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
+#include "lib/sector.h"
+#include "lib/bytes.h"
 #include "fmt/format.h"
 #include <string.h>
 
 static const FluxPattern SECTOR_PATTERN(32, AESLANIER_RECORD_SEPARATOR);
 
-/* This is actually M2FM, rather than MFM, but it our MFM/FM decoder copes fine with it. */
+/* This is actually M2FM, rather than MFM, but it our MFM/FM decoder copes fine
+ * with it. */
 
 class AesLanierDecoder : public Decoder
 {
 public:
-	AesLanierDecoder(const DecoderProto& config):
-		Decoder(config)
-	{}
+    AesLanierDecoder(const DecoderProto& config): Decoder(config) {}
 
     nanoseconds_t advanceToNextRecord() override
-	{
-		return seekToPattern(SECTOR_PATTERN);
-	}
+    {
+        return seekToPattern(SECTOR_PATTERN);
+    }
 
     void decodeSectorRecord() override
-	{
-		/* Skip ID mark (we know it's a AESLANIER_RECORD_SEPARATOR). */
+    {
+        /* Skip ID mark (we know it's a AESLANIER_RECORD_SEPARATOR). */
 
-		readRawBits(16);
+        readRawBits(16);
 
-		const auto& rawbits = readRawBits(AESLANIER_RECORD_SIZE*16);
-		const auto& bytes = decodeFmMfm(rawbits).slice(0, AESLANIER_RECORD_SIZE);
-		const auto& reversed = bytes.reverseBits();
+        const auto& rawbits = readRawBits(AESLANIER_RECORD_SIZE * 16);
+        const auto& bytes =
+            decodeFmMfm(rawbits).slice(0, AESLANIER_RECORD_SIZE);
+        const auto& reversed = bytes.reverseBits();
 
-		_sector->logicalTrack = reversed[1];
-		_sector->logicalSide = 0;
-		_sector->logicalSector = reversed[2];
+        _sector->logicalTrack = reversed[1];
+        _sector->logicalSide = 0;
+        _sector->logicalSector = reversed[2];
 
-		/* Check header 'checksum' (which seems far too simple to mean much). */
+        /* Check header 'checksum' (which seems far too simple to mean much). */
 
-		{
-			uint8_t wanted = reversed[3];
-			uint8_t got = reversed[1] + reversed[2];
-			if (wanted != got)
-				return;
-		}
+        {
+            uint8_t wanted = reversed[3];
+            uint8_t got = reversed[1] + reversed[2];
+            if (wanted != got)
+                return;
+        }
 
-		/* Check data checksum, which also includes the header and is
-			* significantly better. */
+        /* Check data checksum, which also includes the header and is
+         * significantly better. */
 
-		_sector->data = reversed.slice(1, AESLANIER_SECTOR_LENGTH);
-		uint16_t wanted = reversed.reader().seek(0x101).read_le16();
-		uint16_t got = crc16ref(MODBUS_POLY_REF, _sector->data);
-		_sector->status = (wanted == got) ? Sector::OK : Sector::BAD_CHECKSUM;
-	}
+        _sector->data = reversed.slice(1, AESLANIER_SECTOR_LENGTH);
+        uint16_t wanted = reversed.reader().seek(0x101).read_le16();
+        uint16_t got = crc16ref(MODBUS_POLY_REF, _sector->data);
+        _sector->status = (wanted == got) ? Sector::OK : Sector::BAD_CHECKSUM;
+    }
 };
 
 std::unique_ptr<Decoder> createAesLanierDecoder(const DecoderProto& config)
 {
-	return std::unique_ptr<Decoder>(new AesLanierDecoder(config));
+    return std::unique_ptr<Decoder>(new AesLanierDecoder(config));
 }
-
-

arch/agat/agat.cc

@@ -1,22 +1,20 @@
-#include "globals.h"
-#include "decoders/decoders.h"
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
 #include "agat.h"
-#include "bytes.h"
+#include "lib/bytes.h"
 #include "fmt/format.h"
 
 uint8_t agatChecksum(const Bytes& bytes)
 {
     uint16_t checksum = 0;
 
-	for (uint8_t b : bytes)
-	{
-		if (checksum > 0xff)
-			checksum = (checksum + 1) & 0xff;
+    for (uint8_t b : bytes)
+    {
+        if (checksum > 0xff)
+            checksum = (checksum + 1) & 0xff;
 
-		checksum += b;
-	}
+        checksum += b;
+    }
 
-	return checksum & 0xff;
+    return checksum & 0xff;
 }
-
-

arch/agat/agat.h

@@ -17,4 +17,3 @@ extern std::unique_ptr<Encoder> createAgatEncoder(const EncoderProto& config);
 extern uint8_t agatChecksum(const Bytes& bytes);
 
 #endif
-

arch/agat/decoder.cc

@@ -1,21 +1,22 @@
-#include "globals.h"
-#include "decoders/decoders.h"
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
 #include "agat.h"
-#include "crc.h"
-#include "fluxmap.h"
-#include "decoders/fluxmapreader.h"
-#include "sector.h"
-#include "bytes.h"
+#include "lib/crc.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
+#include "lib/sector.h"
+#include "lib/bytes.h"
 #include "fmt/format.h"
 #include <string.h>
 
+// clang-format off
 /*
  * data:    X  X  X  X   X  X  X  X   X  -  -  X   -  X  -  X   -  X  X  -   X  -  X  -  = 0xff956a
  * flux:   01 01 01 01  01 01 01 01  01 00 10 01  00 01 00 01  00 01 01 00  01 00 01 00  = 0x555549111444
  * 
  * data:    X  X  X  X   X  X  X  X   -  X  X  -   X  -  X  -   X  -  -  X   -  X  -  X  = 0xff6a95
  * flux:   01 01 01 01  01 01 01 01  00 01 01 00  01 00 01 00  01 00 10 01  00 01 00 01  = 0x555514444911
- * 
+ *
  * Each pattern is prefixed with this one:
  *
  * data:          -  -   -  X   -  -   X  - = 0x12
@@ -30,65 +31,59 @@
  *          0100010010010010  = MFM encoded
  *           1000100100100100 = with trailing zero
  *            - - - X - - X - = effective bitstream = 0x12
- *
  */
+// clang-format on
 
 static const FluxPattern SECTOR_PATTERN(64, SECTOR_ID);
 static const FluxPattern DATA_PATTERN(64, DATA_ID);
 
-static const FluxMatchers ALL_PATTERNS = {
-	&SECTOR_PATTERN,
-	&DATA_PATTERN
-};
+static const FluxMatchers ALL_PATTERNS = {&SECTOR_PATTERN, &DATA_PATTERN};
 
 class AgatDecoder : public Decoder
 {
 public:
-	AgatDecoder(const DecoderProto& config):
-		Decoder(config)
-	{}
+    AgatDecoder(const DecoderProto& config): Decoder(config) {}
 
     nanoseconds_t advanceToNextRecord() override
-	{
-		return seekToPattern(ALL_PATTERNS);
-	}
+    {
+        return seekToPattern(ALL_PATTERNS);
+    }
 
     void decodeSectorRecord() override
-	{
-		if (readRaw64() != SECTOR_ID)
-			return;
+    {
+        if (readRaw64() != SECTOR_ID)
+            return;
 
-		auto bytes = decodeFmMfm(readRawBits(64)).slice(0, 4);
-		if (bytes[3] != 0x5a)
-			return;
+        auto bytes = decodeFmMfm(readRawBits(64)).slice(0, 4);
+        if (bytes[3] != 0x5a)
+            return;
 
-		_sector->logicalTrack = bytes[1] >> 1;
-		_sector->logicalSector = bytes[2];
-		_sector->logicalSide = bytes[1] & 1;
-		_sector->status = Sector::DATA_MISSING; /* unintuitive but correct */
-	}
+        _sector->logicalTrack = bytes[1] >> 1;
+        _sector->logicalSector = bytes[2];
+        _sector->logicalSide = bytes[1] & 1;
+        _sector->status = Sector::DATA_MISSING; /* unintuitive but correct */
+    }
 
-	void decodeDataRecord() override
-	{
-		if (readRaw64() != DATA_ID)
-			return;
+    void decodeDataRecord() override
+    {
+        if (readRaw64() != DATA_ID)
+            return;
 
-		Bytes bytes = decodeFmMfm(readRawBits((AGAT_SECTOR_SIZE+2)*16)).slice(0, AGAT_SECTOR_SIZE+2);
+        Bytes bytes = decodeFmMfm(readRawBits((AGAT_SECTOR_SIZE + 2) * 16))
+                          .slice(0, AGAT_SECTOR_SIZE + 2);
 
-		if (bytes[AGAT_SECTOR_SIZE+1] != 0x5a)
-			return;
+        if (bytes[AGAT_SECTOR_SIZE + 1] != 0x5a)
+            return;
 
-		_sector->data = bytes.slice(0, AGAT_SECTOR_SIZE);
-		uint8_t wantChecksum = bytes[AGAT_SECTOR_SIZE];
-		uint8_t gotChecksum = agatChecksum(_sector->data);
-		_sector->status = (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
-	}
+        _sector->data = bytes.slice(0, AGAT_SECTOR_SIZE);
+        uint8_t wantChecksum = bytes[AGAT_SECTOR_SIZE];
+        uint8_t gotChecksum = agatChecksum(_sector->data);
+        _sector->status =
+            (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
+    }
 };
 
 std::unique_ptr<Decoder> createAgatDecoder(const DecoderProto& config)
 {
-	return std::unique_ptr<Decoder>(new AgatDecoder(config));
+    return std::unique_ptr<Decoder>(new AgatDecoder(config));
 }
-
-
-

arch/agat/encoder.cc

@@ -95,7 +95,7 @@ public:
         }
 
         if (_cursor >= _bits.size())
-            Error() << "track data overrun";
+            error("track data overrun");
         fillBitmapTo(_bits, _cursor, _bits.size(), {true, false});
 
         auto fluxmap = std::make_unique<Fluxmap>();

arch/amiga/amiga.cc

@@ -1,7 +1,7 @@
-#include "globals.h"
-#include "decoders/decoders.h"
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
 #include "amiga.h"
-#include "bytes.h"
+#include "lib/bytes.h"
 #include "fmt/format.h"
 
 uint32_t amigaChecksum(const Bytes& bytes)
@@ -18,61 +18,61 @@ uint32_t amigaChecksum(const Bytes& bytes)
 
 static uint8_t everyother(uint16_t x)
 {
-	                  /* aabb ccdd eeff gghh */
-	x &= 0x6666;      /* 0ab0 0cd0 0ef0 0gh0 */
-	x >>= 1;          /* 00ab 00cd 00ef 00gh */
-	x |= x << 2;      /* abab cdcd efef ghgh */
-	x &= 0x3c3c;      /* 00ab cd00 00ef gh00 */
-	x >>= 2;          /* 0000 abcd 0000 efgh */
-	x |= x >> 4;      /* 0000 abcd abcd efgh */
-	return x;
+    /* aabb ccdd eeff gghh */
+    x &= 0x6666; /* 0ab0 0cd0 0ef0 0gh0 */
+    x >>= 1;     /* 00ab 00cd 00ef 00gh */
+    x |= x << 2; /* abab cdcd efef ghgh */
+    x &= 0x3c3c; /* 00ab cd00 00ef gh00 */
+    x >>= 2;     /* 0000 abcd 0000 efgh */
+    x |= x >> 4; /* 0000 abcd abcd efgh */
+    return x;
 }
 
 Bytes amigaInterleave(const Bytes& input)
 {
-	Bytes output;
-	ByteWriter bw(output);
+    Bytes output;
+    ByteWriter bw(output);
 
-	/* Write all odd bits. (Numbering starts at 0...) */
+    /* Write all odd bits. (Numbering starts at 0...) */
 
-	{
-		ByteReader br(input);
-		while (!br.eof())
-		{
-			uint16_t x = br.read_be16();
-			x &= 0xaaaa;       /* a0b0 c0d0 e0f0 g0h0 */
-			x |= x >> 1;       /* aabb ccdd eeff gghh */
-			x = everyother(x); /* 0000 0000 abcd efgh */
-			bw.write_8(x);
-		}
-	}
+    {
+        ByteReader br(input);
+        while (!br.eof())
+        {
+            uint16_t x = br.read_be16();
+            x &= 0xaaaa;       /* a0b0 c0d0 e0f0 g0h0 */
+            x |= x >> 1;       /* aabb ccdd eeff gghh */
+            x = everyother(x); /* 0000 0000 abcd efgh */
+            bw.write_8(x);
+        }
+    }
 
-	/* Write all even bits. */
+    /* Write all even bits. */
 
-	{
-		ByteReader br(input);
-		while (!br.eof())
-		{
-			uint16_t x = br.read_be16();
-			x &= 0x5555;       /* 0a0b 0c0d 0e0f 0g0h */
-			x |= x << 1;       /* aabb ccdd eeff gghh */
-			x = everyother(x); /* 0000 0000 abcd efgh */
-			bw.write_8(x);
-		}
-	}
+    {
+        ByteReader br(input);
+        while (!br.eof())
+        {
+            uint16_t x = br.read_be16();
+            x &= 0x5555;       /* 0a0b 0c0d 0e0f 0g0h */
+            x |= x << 1;       /* aabb ccdd eeff gghh */
+            x = everyother(x); /* 0000 0000 abcd efgh */
+            bw.write_8(x);
+        }
+    }
 
-	return output;
+    return output;
 }
 
 Bytes amigaDeinterleave(const uint8_t*& input, size_t len)
 {
     assert(!(len & 1));
     const uint8_t* odds = &input[0];
-    const uint8_t* evens = &input[len/2];
+    const uint8_t* evens = &input[len / 2];
     Bytes output;
     ByteWriter bw(output);
 
-    for (size_t i=0; i<len/2; i++)
+    for (size_t i = 0; i < len / 2; i++)
     {
         uint8_t o = *odds++;
         uint8_t e = *evens++;
@@ -81,11 +81,15 @@ Bytes amigaDeinterleave(const uint8_t*& input, size_t len)
          * http://graphics.stanford.edu/~seander/bithacks.html#InterleaveBMN
          */
         uint16_t result =
-            (((e * 0x0101010101010101ULL & 0x8040201008040201ULL)
-                * 0x0102040810204081ULL >> 49) & 0x5555) |
-            (((o * 0x0101010101010101ULL & 0x8040201008040201ULL)
-                * 0x0102040810204081ULL >> 48) & 0xAAAA);
-        
+            (((e * 0x0101010101010101ULL & 0x8040201008040201ULL) *
+                     0x0102040810204081ULL >>
+                 49) &
+                0x5555) |
+            (((o * 0x0101010101010101ULL & 0x8040201008040201ULL) *
+                     0x0102040810204081ULL >>
+                 48) &
+                0xAAAA);
+
         bw.write_be16(result);
     }
 
@@ -95,6 +99,6 @@ Bytes amigaDeinterleave(const uint8_t*& input, size_t len)
 
 Bytes amigaDeinterleave(const Bytes& input)
 {
-	const uint8_t* ptr = input.cbegin();
-	return amigaDeinterleave(ptr, input.size());
+    const uint8_t* ptr = input.cbegin();
+    return amigaDeinterleave(ptr, input.size());
 }

arch/amiga/amiga.h

@@ -1,7 +1,7 @@
 #ifndef AMIGA_H
 #define AMIGA_H
 
-#include "encoders/encoders.h"
+#include "lib/encoders/encoders.h"
 
 #define AMIGA_SECTOR_RECORD 0xaaaa44894489LL
 

arch/amiga/decoder.cc

@@ -1,80 +1,84 @@
-#include "globals.h"
-#include "fluxmap.h"
-#include "decoders/fluxmapreader.h"
+#include "lib/globals.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "decoders/decoders.h"
-#include "sector.h"
+#include "lib/decoders/decoders.h"
+#include "lib/sector.h"
 #include "amiga.h"
-#include "bytes.h"
+#include "lib/bytes.h"
 #include "fmt/format.h"
 #include "lib/decoders/decoders.pb.h"
 #include <string.h>
 #include <algorithm>
 
-/* 
+/*
  * Amiga disks use MFM but it's not quite the same as IBM MFM. They only use
  * a single type of record with a different marker byte.
- * 
+ *
  * See the big comment in the IBM MFM decoder for the gruesome details of how
  * MFM works.
  */
-         
+
 static const FluxPattern SECTOR_PATTERN(48, AMIGA_SECTOR_RECORD);
 
 class AmigaDecoder : public Decoder
 {
 public:
-	AmigaDecoder(const DecoderProto& config):
-		Decoder(config),
-		_config(config.amiga())
-	{}
+    AmigaDecoder(const DecoderProto& config):
+        Decoder(config),
+        _config(config.amiga())
+    {
+    }
 
     nanoseconds_t advanceToNextRecord() override
-	{
-		return seekToPattern(SECTOR_PATTERN);
-	}
+    {
+        return seekToPattern(SECTOR_PATTERN);
+    }
 
     void decodeSectorRecord() override
-	{
-		if (readRaw48() != AMIGA_SECTOR_RECORD)
-			return;
-			
-		const auto& rawbits = readRawBits(AMIGA_RECORD_SIZE*16);
-		if (rawbits.size() < (AMIGA_RECORD_SIZE*16))
-			return;
-		const auto& rawbytes = toBytes(rawbits).slice(0, AMIGA_RECORD_SIZE*2);
-		const auto& bytes = decodeFmMfm(rawbits).slice(0, AMIGA_RECORD_SIZE);
+    {
+        if (readRaw48() != AMIGA_SECTOR_RECORD)
+            return;
 
-		const uint8_t* ptr = bytes.begin();
+        const auto& rawbits = readRawBits(AMIGA_RECORD_SIZE * 16);
+        if (rawbits.size() < (AMIGA_RECORD_SIZE * 16))
+            return;
+        const auto& rawbytes = toBytes(rawbits).slice(0, AMIGA_RECORD_SIZE * 2);
+        const auto& bytes = decodeFmMfm(rawbits).slice(0, AMIGA_RECORD_SIZE);
 
-		Bytes header = amigaDeinterleave(ptr, 4);
-		Bytes recoveryinfo = amigaDeinterleave(ptr, 16);
+        const uint8_t* ptr = bytes.begin();
 
-		_sector->logicalTrack = header[1] >> 1;
-		_sector->logicalSide = header[1] & 1;
-		_sector->logicalSector = header[2];
+        Bytes header = amigaDeinterleave(ptr, 4);
+        Bytes recoveryinfo = amigaDeinterleave(ptr, 16);
 
-		uint32_t wantedheaderchecksum = amigaDeinterleave(ptr, 4).reader().read_be32();
-		uint32_t gotheaderchecksum = amigaChecksum(rawbytes.slice(0, 40));
-		if (gotheaderchecksum != wantedheaderchecksum)
-			return;
+        _sector->logicalTrack = header[1] >> 1;
+        _sector->logicalSide = header[1] & 1;
+        _sector->logicalSector = header[2];
 
-		uint32_t wanteddatachecksum = amigaDeinterleave(ptr, 4).reader().read_be32();
-		uint32_t gotdatachecksum = amigaChecksum(rawbytes.slice(56, 1024));
+        uint32_t wantedheaderchecksum =
+            amigaDeinterleave(ptr, 4).reader().read_be32();
+        uint32_t gotheaderchecksum = amigaChecksum(rawbytes.slice(0, 40));
+        if (gotheaderchecksum != wantedheaderchecksum)
+            return;
 
-		Bytes data;
-		data.writer().append(amigaDeinterleave(ptr, 512)).append(recoveryinfo);
-		_sector->data = data;
-		_sector->status = (gotdatachecksum == wanteddatachecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
-	}
+        uint32_t wanteddatachecksum =
+            amigaDeinterleave(ptr, 4).reader().read_be32();
+        uint32_t gotdatachecksum = amigaChecksum(rawbytes.slice(56, 1024));
+
+        Bytes data;
+        data.writer().append(amigaDeinterleave(ptr, 512)).append(recoveryinfo);
+        _sector->data = data;
+        _sector->status = (gotdatachecksum == wanteddatachecksum)
+                              ? Sector::OK
+                              : Sector::BAD_CHECKSUM;
+    }
 
 private:
-	const AmigaDecoderProto& _config;
-	nanoseconds_t _clock;
+    const AmigaDecoderProto& _config;
+    nanoseconds_t _clock;
 };
 
 std::unique_ptr<Decoder> createAmigaDecoder(const DecoderProto& config)
 {
-	return std::unique_ptr<Decoder>(new AmigaDecoder(config));
+    return std::unique_ptr<Decoder>(new AmigaDecoder(config));
 }
-

arch/amiga/encoder.cc

@@ -1,10 +1,10 @@
-#include "globals.h"
-#include "decoders/decoders.h"
-#include "encoders/encoders.h"
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
 #include "amiga.h"
-#include "crc.h"
-#include "readerwriter.h"
-#include "image.h"
+#include "lib/crc.h"
+#include "lib/readerwriter.h"
+#include "lib/image.h"
 #include "arch/amiga/amiga.pb.h"
 #include "lib/encoders/encoders.pb.h"
 
@@ -59,7 +59,7 @@ static void write_sector(std::vector<bool>& bits,
     const std::shared_ptr<const Sector>& sector)
 {
     if ((sector->data.size() != 512) && (sector->data.size() != 528))
-        Error() << "unsupported sector size --- you must pick 512 or 528";
+        error("unsupported sector size --- you must pick 512 or 528");
 
     uint32_t checksum = 0;
 
@@ -114,7 +114,8 @@ public:
         const std::vector<std::shared_ptr<const Sector>>& sectors,
         const Image& image) override
     {
-        /* Number of bits for one nominal revolution of a real 200ms Amiga disk. */
+        /* Number of bits for one nominal revolution of a real 200ms Amiga disk.
+         */
         int bitsPerRevolution = 200e3 / _config.clock_rate_us();
         std::vector<bool> bits(bitsPerRevolution);
         unsigned cursor = 0;
@@ -129,13 +130,12 @@ public:
             write_sector(bits, cursor, sector);
 
         if (cursor >= bits.size())
-            Error() << "track data overrun";
+            error("track data overrun");
         fillBitmapTo(bits, cursor, bits.size(), {true, false});
 
         auto fluxmap = std::make_unique<Fluxmap>();
         fluxmap->appendBits(bits,
-            calculatePhysicalClockPeriod(
-                _config.clock_rate_us() * 1e3, 200e6));
+            calculatePhysicalClockPeriod(_config.clock_rate_us() * 1e3, 200e6));
         return fluxmap;
     }
 

arch/apple2/apple2.h

@@ -2,19 +2,18 @@
 #define APPLE2_H
 
 #include <memory.h>
-#include "decoders/decoders.h"
-#include "encoders/encoders.h"
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
 
-#define APPLE2_SECTOR_RECORD   0xd5aa96
-#define APPLE2_DATA_RECORD     0xd5aaad
+#define APPLE2_SECTOR_RECORD 0xd5aa96
+#define APPLE2_DATA_RECORD 0xd5aaad
 
-#define APPLE2_SECTOR_LENGTH   256
+#define APPLE2_SECTOR_LENGTH 256
 #define APPLE2_ENCODED_SECTOR_LENGTH 342
 
-#define APPLE2_SECTORS         16
+#define APPLE2_SECTORS 16
 
 extern std::unique_ptr<Decoder> createApple2Decoder(const DecoderProto& config);
 extern std::unique_ptr<Encoder> createApple2Encoder(const EncoderProto& config);
 
 #endif
-

arch/apple2/decoder.cc

@@ -1,13 +1,13 @@
-#include "globals.h"
-#include "fluxmap.h"
-#include "decoders/fluxmapreader.h"
+#include "lib/globals.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "decoders/decoders.h"
-#include "sector.h"
+#include "lib/decoders/decoders.h"
+#include "lib/sector.h"
 #include "apple2.h"
 #include "arch/apple2/apple2.pb.h"
 #include "lib/decoders/decoders.pb.h"
-#include "bytes.h"
+#include "lib/bytes.h"
 #include "fmt/format.h"
 #include <string.h>
 #include <algorithm>

arch/apple2/encoder.cc

@@ -1,14 +1,14 @@
-#include "globals.h"
+#include "lib/globals.h"
 #include "arch/apple2/apple2.h"
-#include "decoders/decoders.h"
-#include "encoders/encoders.h"
-#include "sector.h"
-#include "readerwriter.h"
-#include "image.h"
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
+#include "lib/sector.h"
+#include "lib/readerwriter.h"
+#include "lib/image.h"
 #include "fmt/format.h"
 #include "lib/encoders/encoders.pb.h"
 #include <ctype.h>
-#include "bytes.h"
+#include "lib/bytes.h"
 
 static int encode_data_gcr(uint8_t data)
 {
@@ -50,8 +50,7 @@ public:
             writeSector(bits, cursor, *sector);
 
         if (cursor >= bits.size())
-            Error() << fmt::format(
-                "track data overrun by {} bits", cursor - bits.size());
+            error("track data overrun by {} bits", cursor - bits.size());
         fillBitmapTo(bits, cursor, bits.size(), {true, false});
 
         std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
@@ -118,8 +117,7 @@ private:
 
             // There is data to encode to disk.
             if ((sector.data.size() != APPLE2_SECTOR_LENGTH))
-                Error() << fmt::format(
-                    "unsupported sector size {} --- you must pick 256",
+                error("unsupported sector size {} --- you must pick 256",
                     sector.data.size());
 
             // Write address syncing leader : A sequence of "FF40"s; 5 of them

arch/brother/brother.h

@@ -3,17 +3,19 @@
 
 /* Brother word processor format (or at least, one of them) */
 
-#define BROTHER_SECTOR_RECORD            0xFFFFFD57
-#define BROTHER_DATA_RECORD              0xFFFFFDDB
-#define BROTHER_DATA_RECORD_PAYLOAD      256
-#define BROTHER_DATA_RECORD_CHECKSUM     3
+#define BROTHER_SECTOR_RECORD 0xFFFFFD57
+#define BROTHER_DATA_RECORD 0xFFFFFDDB
+#define BROTHER_DATA_RECORD_PAYLOAD 256
+#define BROTHER_DATA_RECORD_CHECKSUM 3
 #define BROTHER_DATA_RECORD_ENCODED_SIZE 415
 
-#define BROTHER_TRACKS_PER_240KB_DISK    78
-#define BROTHER_TRACKS_PER_120KB_DISK    39
-#define BROTHER_SECTORS_PER_TRACK        12
+#define BROTHER_TRACKS_PER_240KB_DISK 78
+#define BROTHER_TRACKS_PER_120KB_DISK 39
+#define BROTHER_SECTORS_PER_TRACK 12
 
-extern std::unique_ptr<Decoder> createBrotherDecoder(const DecoderProto& config);
-extern std::unique_ptr<Encoder> createBrotherEncoder(const EncoderProto& config);
+extern std::unique_ptr<Decoder> createBrotherDecoder(
+    const DecoderProto& config);
+extern std::unique_ptr<Encoder> createBrotherEncoder(
+    const EncoderProto& config);
 
 #endif

arch/brother/data_gcr.h

@@ -1,13 +1,13 @@
-GCR_ENTRY(0x55, 0) // 00000
-GCR_ENTRY(0x57, 1) // 00001
-GCR_ENTRY(0x5b, 2) // 00010
-GCR_ENTRY(0x5d, 3) // 00011
-GCR_ENTRY(0x5f, 4) // 00100 
-GCR_ENTRY(0x6b, 5) // 00101
-GCR_ENTRY(0x6d, 6) // 00110
-GCR_ENTRY(0x6f, 7) // 00111
-GCR_ENTRY(0x75, 8) // 01000
-GCR_ENTRY(0x77, 9) // 01001
+GCR_ENTRY(0x55, 0)  // 00000
+GCR_ENTRY(0x57, 1)  // 00001
+GCR_ENTRY(0x5b, 2)  // 00010
+GCR_ENTRY(0x5d, 3)  // 00011
+GCR_ENTRY(0x5f, 4)  // 00100
+GCR_ENTRY(0x6b, 5)  // 00101
+GCR_ENTRY(0x6d, 6)  // 00110
+GCR_ENTRY(0x6f, 7)  // 00111
+GCR_ENTRY(0x75, 8)  // 01000
+GCR_ENTRY(0x77, 9)  // 01001
 GCR_ENTRY(0x7b, 10) // 01010
 GCR_ENTRY(0x7d, 11) // 01011
 GCR_ENTRY(0x7f, 12) // 01100
@@ -30,4 +30,3 @@ GCR_ENTRY(0xef, 28) // 11100
 GCR_ENTRY(0xf5, 29) // 11101
 GCR_ENTRY(0xf7, 30) // 11110
 GCR_ENTRY(0xfb, 31) // 11111
-

arch/brother/decoder.cc

@@ -1,17 +1,18 @@
-#include "globals.h"
-#include "fluxmap.h"
-#include "decoders/fluxmapreader.h"
-#include "decoders/decoders.h"
-#include "encoders/encoders.h"
+#include "lib/globals.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
 #include "brother.h"
-#include "sector.h"
-#include "bytes.h"
-#include "crc.h"
+#include "lib/sector.h"
+#include "lib/bytes.h"
+#include "lib/crc.h"
 #include <ctype.h>
 
 const FluxPattern SECTOR_RECORD_PATTERN(32, BROTHER_SECTOR_RECORD);
 const FluxPattern DATA_RECORD_PATTERN(32, BROTHER_DATA_RECORD);
-const FluxMatchers ANY_RECORD_PATTERN({ &SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN });
+const FluxMatchers ANY_RECORD_PATTERN(
+    {&SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN});
 
 static std::vector<uint8_t> outputbuffer;
 
@@ -32,88 +33,89 @@ static int decode_data_gcr(uint8_t gcr)
 {
     switch (gcr)
     {
-		#define GCR_ENTRY(gcr, data) \
-			case gcr: return data;
-		#include "data_gcr.h"
-		#undef GCR_ENTRY
+#define GCR_ENTRY(gcr, data) \
+    case gcr:                \
+        return data;
+#include "data_gcr.h"
+#undef GCR_ENTRY
     }
     return -1;
 }
 
 static int decode_header_gcr(uint16_t word)
 {
-	switch (word)
-	{
-		#define GCR_ENTRY(gcr, data) \
-			case gcr: return data;
-		#include "header_gcr.h"
-		#undef GCR_ENTRY
-	}                       
-	return -1;             
+    switch (word)
+    {
+#define GCR_ENTRY(gcr, data) \
+    case gcr:                \
+        return data;
+#include "header_gcr.h"
+#undef GCR_ENTRY
+    }
+    return -1;
 }
 
 class BrotherDecoder : public Decoder
 {
 public:
-    BrotherDecoder(const DecoderProto& config):
-		Decoder(config)
-	{}
+    BrotherDecoder(const DecoderProto& config): Decoder(config) {}
 
     nanoseconds_t advanceToNextRecord() override
-	{
-		return seekToPattern(ANY_RECORD_PATTERN);
-	}
+    {
+        return seekToPattern(ANY_RECORD_PATTERN);
+    }
 
     void decodeSectorRecord() override
-	{
-		if (readRaw32() != BROTHER_SECTOR_RECORD)
-			return;
+    {
+        if (readRaw32() != BROTHER_SECTOR_RECORD)
+            return;
 
-		const auto& rawbits = readRawBits(32);
-		const auto& bytes = toBytes(rawbits).slice(0, 4);
+        const auto& rawbits = readRawBits(32);
+        const auto& bytes = toBytes(rawbits).slice(0, 4);
 
-		ByteReader br(bytes);
-		_sector->logicalTrack = decode_header_gcr(br.read_be16());
-		_sector->logicalSector = decode_header_gcr(br.read_be16());
+        ByteReader br(bytes);
+        _sector->logicalTrack = decode_header_gcr(br.read_be16());
+        _sector->logicalSector = decode_header_gcr(br.read_be16());
 
-		/* Sanity check the values read; there's no header checksum and
-			* occasionally we get garbage due to bit errors. */
-		if (_sector->logicalSector > 11)
-			return;
-		if (_sector->logicalTrack > 79)
-			return;
+        /* Sanity check the values read; there's no header checksum and
+         * occasionally we get garbage due to bit errors. */
+        if (_sector->logicalSector > 11)
+            return;
+        if (_sector->logicalTrack > 79)
+            return;
+
+        _sector->status = Sector::DATA_MISSING;
+    }
 
-		_sector->status = Sector::DATA_MISSING;
-	}
-	
     void decodeDataRecord() override
-	{
-		if (readRaw32() != BROTHER_DATA_RECORD)
-			return;
+    {
+        if (readRaw32() != BROTHER_DATA_RECORD)
+            return;
 
-		const auto& rawbits = readRawBits(BROTHER_DATA_RECORD_ENCODED_SIZE*8);
-		const auto& rawbytes = toBytes(rawbits).slice(0, BROTHER_DATA_RECORD_ENCODED_SIZE);
+        const auto& rawbits = readRawBits(BROTHER_DATA_RECORD_ENCODED_SIZE * 8);
+        const auto& rawbytes =
+            toBytes(rawbits).slice(0, BROTHER_DATA_RECORD_ENCODED_SIZE);
 
-		Bytes bytes;
-		ByteWriter bw(bytes);
-		BitWriter bitw(bw);
-		for (uint8_t b : rawbytes)
-		{
-			uint32_t nibble = decode_data_gcr(b);
-			bitw.push(nibble, 5);
-		}
-		bitw.flush();
+        Bytes bytes;
+        ByteWriter bw(bytes);
+        BitWriter bitw(bw);
+        for (uint8_t b : rawbytes)
+        {
+            uint32_t nibble = decode_data_gcr(b);
+            bitw.push(nibble, 5);
+        }
+        bitw.flush();
 
-		_sector->data = bytes.slice(0, BROTHER_DATA_RECORD_PAYLOAD);
-		uint32_t realCrc = crcbrother(_sector->data);
-		uint32_t wantCrc = bytes.reader().seek(BROTHER_DATA_RECORD_PAYLOAD).read_be24();
-		_sector->status = (realCrc == wantCrc) ? Sector::OK : Sector::BAD_CHECKSUM;
-	}
+        _sector->data = bytes.slice(0, BROTHER_DATA_RECORD_PAYLOAD);
+        uint32_t realCrc = crcbrother(_sector->data);
+        uint32_t wantCrc =
+            bytes.reader().seek(BROTHER_DATA_RECORD_PAYLOAD).read_be24();
+        _sector->status =
+            (realCrc == wantCrc) ? Sector::OK : Sector::BAD_CHECKSUM;
+    }
 };
 
 std::unique_ptr<Decoder> createBrotherDecoder(const DecoderProto& config)
 {
-	return std::unique_ptr<Decoder>(new BrotherDecoder(config));
+    return std::unique_ptr<Decoder>(new BrotherDecoder(config));
 }
-
-

arch/brother/encoder.cc

@@ -1,10 +1,10 @@
-#include "globals.h"
-#include "decoders/decoders.h"
-#include "encoders/encoders.h"
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
 #include "brother.h"
-#include "crc.h"
-#include "readerwriter.h"
-#include "image.h"
+#include "lib/crc.h"
+#include "lib/readerwriter.h"
+#include "lib/image.h"
 #include "arch/brother/brother.pb.h"
 #include "lib/encoders/encoders.pb.h"
 
@@ -67,7 +67,7 @@ static void write_sector_data(
     int width = 0;
 
     if (data.size() != BROTHER_DATA_RECORD_PAYLOAD)
-        Error() << "unsupported sector size";
+        error("unsupported sector size");
 
     auto write_byte = [&](uint8_t byte)
     {
@@ -107,8 +107,7 @@ public:
     }
 
 public:
-    std::unique_ptr<Fluxmap> encode(
-		std::shared_ptr<const TrackInfo>& trackInfo,
+    std::unique_ptr<Fluxmap> encode(std::shared_ptr<const TrackInfo>& trackInfo,
         const std::vector<std::shared_ptr<const Sector>>& sectors,
         const Image& image) override
     {
@@ -116,8 +115,8 @@ public:
         std::vector<bool> bits(bitsPerRevolution);
         unsigned cursor = 0;
 
-		int sectorCount = 0;
-		for (const auto& sectorData : sectors)
+        int sectorCount = 0;
+        for (const auto& sectorData : sectors)
         {
             double headerMs = _config.post_index_gap_ms() +
                               sectorCount * _config.sector_spacing_ms();
@@ -126,16 +125,18 @@ public:
             unsigned dataCursor = dataMs * 1e3 / _config.clock_rate_us();
 
             fillBitmapTo(bits, cursor, headerCursor, {true, false});
-            write_sector_header(
-                bits, cursor, sectorData->logicalTrack, sectorData->logicalSector);
+            write_sector_header(bits,
+                cursor,
+                sectorData->logicalTrack,
+                sectorData->logicalSector);
             fillBitmapTo(bits, cursor, dataCursor, {true, false});
             write_sector_data(bits, cursor, sectorData->data);
 
-			sectorCount++;
+            sectorCount++;
         }
 
         if (cursor >= bits.size())
-            Error() << "track data overrun";
+            error("track data overrun");
         fillBitmapTo(bits, cursor, bits.size(), {true, false});
 
         std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
@@ -147,8 +148,7 @@ private:
     const BrotherEncoderProto& _config;
 };
 
-std::unique_ptr<Encoder> createBrotherEncoder(
-    const EncoderProto& config)
+std::unique_ptr<Encoder> createBrotherEncoder(const EncoderProto& config)
 {
     return std::unique_ptr<Encoder>(new BrotherEncoder(config));
 }

arch/brother/header_gcr.h

@@ -76,4 +76,3 @@ GCR_ENTRY(0x6BAB, 74)
 GCR_ENTRY(0xAD5F, 75)
 GCR_ENTRY(0xDBED, 76)
 GCR_ENTRY(0x55BB, 77)
-

arch/build.mk

@@ -1,43 +0,0 @@
-LIBARCH_SRCS = \
-	arch/aeslanier/decoder.cc \
-	arch/agat/agat.cc \
-	arch/agat/decoder.cc \
-	arch/agat/encoder.cc \
-	arch/amiga/amiga.cc \
-	arch/amiga/decoder.cc \
-	arch/amiga/encoder.cc \
-	arch/apple2/decoder.cc \
-	arch/apple2/encoder.cc \
-	arch/brother/decoder.cc \
-	arch/brother/encoder.cc \
-	arch/c64/c64.cc \
-	arch/c64/decoder.cc \
-	arch/c64/encoder.cc \
-	arch/f85/decoder.cc \
-	arch/fb100/decoder.cc \
-	arch/ibm/decoder.cc \
-	arch/ibm/encoder.cc \
-	arch/macintosh/decoder.cc \
-	arch/macintosh/encoder.cc \
-	arch/micropolis/decoder.cc \
-	arch/micropolis/encoder.cc \
-	arch/mx/decoder.cc \
-	arch/northstar/decoder.cc \
-	arch/northstar/encoder.cc \
-	arch/smaky6/decoder.cc \
-	arch/tids990/decoder.cc \
-	arch/tids990/encoder.cc \
-	arch/victor9k/decoder.cc \
-	arch/victor9k/encoder.cc \
-	arch/zilogmcz/decoder.cc \
-
-LIBARCH_OBJS = $(patsubst %.cc, $(OBJDIR)/%.o, $(LIBARCH_SRCS))
-OBJS += $(LIBARCH_OBJS)
-$(LIBARCH_SRCS): | $(PROTO_HDRS)
-$(LIBARCH_SRCS): CFLAGS += $(PROTO_CFLAGS)
-LIBARCH_LIB = $(OBJDIR)/libarch.a
-$(LIBARCH_LIB): $(LIBARCH_OBJS)
-
-LIBARCH_LDFLAGS = $(LIBARCH_LIB)
-
-$(call use-pkgconfig, $(LIBARCH_LIB), $(LIBARCH_OBJS), fmt)

arch/build.py

@@ -0,0 +1,27 @@
+from build.c import cxxlibrary
+from build.protobuf import proto, protocc
+
+proto(
+    name="arch_proto",
+    srcs=[
+        "./aeslanier/aeslanier.proto",
+        "./agat/agat.proto",
+        "./amiga/amiga.proto",
+        "./apple2/apple2.proto",
+        "./brother/brother.proto",
+        "./c64/c64.proto",
+        "./f85/f85.proto",
+        "./fb100/fb100.proto",
+        "./ibm/ibm.proto",
+        "./macintosh/macintosh.proto",
+        "./micropolis/micropolis.proto",
+        "./mx/mx.proto",
+        "./northstar/northstar.proto",
+        "./rolandd20/rolandd20.proto",
+        "./smaky6/smaky6.proto",
+        "./tartu/tartu.proto",
+        "./tids990/tids990.proto",
+        "./victor9k/victor9k.proto",
+        "./zilogmcz/zilogmcz.proto",
+    ],
+)

arch/c64/c64.cc

@@ -1,28 +1,28 @@
-#include "globals.h"
+#include "lib/globals.h"
 #include "c64.h"
 
 /*
-    *   Track   Sectors/track   # Sectors   Storage in Bytes   Clock rate
-    *   -----   -------------   ---------   ----------------   ----------
-    *    1-17        21            357           7820             3.25
-    *   18-24        19            133           7170             3.5
-    *   25-30        18            108           6300             3.75
-    *   31-40(*)     17             85           6020             4
-    *                              ---
-    *                              683 (for a 35 track image)
-    * 
-    * The clock rate is normalised for a 200ms drive.
-    */
+ *   Track   Sectors/track   # Sectors   Storage in Bytes   Clock rate
+ *   -----   -------------   ---------   ----------------   ----------
+ *    1-17        21            357           7820             3.25
+ *   18-24        19            133           7170             3.5
+ *   25-30        18            108           6300             3.75
+ *   31-40(*)     17             85           6020             4
+ *                              ---
+ *                              683 (for a 35 track image)
+ *
+ * The clock rate is normalised for a 200ms drive.
+ */
 
 nanoseconds_t clockPeriodForC64Track(unsigned track)
 {
-    constexpr double BYTE_SIZE = 8.0;
+    constexpr double b = 8.0;
 
     if (track < 17)
-        return 26.0 / BYTE_SIZE;
+        return 26.0 / b;
     if (track < 24)
-        return 28.0 / BYTE_SIZE;
+        return 28.0 / b;
     if (track < 30)
-        return 30.0 / BYTE_SIZE;
-    return 32.0 / BYTE_SIZE;
+        return 30.0 / b;
+    return 32.0 / b;
 }

arch/c64/c64.h

@@ -1,14 +1,14 @@
 #ifndef C64_H
 #define C64_H
 
-#include "decoders/decoders.h"
-#include "encoders/encoders.h"
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
 
-#define C64_SECTOR_RECORD    0xffd49
-#define C64_DATA_RECORD      0xffd57
-#define C64_SECTOR_LENGTH    256
+#define C64_SECTOR_RECORD 0xffd49
+#define C64_DATA_RECORD 0xffd57
+#define C64_SECTOR_LENGTH 256
 
-/* Source: http://www.unusedino.de/ec64/technical/formats/g64.html 
+/* Source: http://www.unusedino.de/ec64/technical/formats/g64.html
    1. Header sync       FF FF FF FF FF (40 'on' bits, not GCR)
    2. Header info       52 54 B5 29 4B 7A 5E 95 55 55 (10 GCR bytes)
    3. Header gap        55 55 55 55 55 55 55 55 55 (9 bytes, never read)
@@ -17,18 +17,20 @@
    6. Inter-sector gap  55 55 55 55...55 55 (4 to 12 bytes, never read)
    1. Header sync       (SYNC for the next sector)
 */
-#define C64_HEADER_DATA_SYNC        0xFF
-#define C64_HEADER_BLOCK_ID         0x08
-#define C64_DATA_BLOCK_ID           0x07
-#define C64_HEADER_GAP              0x55
-#define C64_INTER_SECTOR_GAP        0x55
-#define C64_PADDING                 0x0F
+#define C64_HEADER_DATA_SYNC 0xFF
+#define C64_HEADER_BLOCK_ID 0x08
+#define C64_DATA_BLOCK_ID 0x07
+#define C64_HEADER_GAP 0x55
+#define C64_INTER_SECTOR_GAP 0x55
+#define C64_PADDING 0x0F
 
-#define C64_TRACKS_PER_DISK         40
-#define C64_BAM_TRACK               17
+#define C64_TRACKS_PER_DISK 40
+#define C64_BAM_TRACK 17
 
-extern std::unique_ptr<Decoder> createCommodore64Decoder(const DecoderProto& config);
-extern std::unique_ptr<Encoder> createCommodore64Encoder(const EncoderProto& config);
+extern std::unique_ptr<Decoder> createCommodore64Decoder(
+    const DecoderProto& config);
+extern std::unique_ptr<Encoder> createCommodore64Encoder(
+    const EncoderProto& config);
 
 extern nanoseconds_t clockPeriodForC64Track(unsigned track);
 

arch/c64/decoder.cc

@@ -1,12 +1,12 @@
-#include "globals.h"
-#include "fluxmap.h"
-#include "decoders/fluxmapreader.h"
+#include "lib/globals.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "decoders/decoders.h"
-#include "sector.h"
+#include "lib/decoders/decoders.h"
+#include "lib/sector.h"
 #include "c64.h"
-#include "crc.h"
-#include "bytes.h"
+#include "lib/crc.h"
+#include "lib/bytes.h"
 #include "fmt/format.h"
 #include <string.h>
 #include <algorithm>
@@ -96,8 +96,7 @@ public:
     }
 };
 
-std::unique_ptr<Decoder> createCommodore64Decoder(
-    const DecoderProto& config)
+std::unique_ptr<Decoder> createCommodore64Decoder(const DecoderProto& config)
 {
     return std::unique_ptr<Decoder>(new Commodore64Decoder(config));
 }

arch/c64/encoder.cc

@@ -1,17 +1,17 @@
-#include "globals.h"
-#include "decoders/decoders.h"
-#include "encoders/encoders.h"
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
 #include "c64.h"
-#include "crc.h"
-#include "sector.h"
-#include "readerwriter.h"
-#include "image.h"
+#include "lib/crc.h"
+#include "lib/sector.h"
+#include "lib/readerwriter.h"
+#include "lib/image.h"
 #include "fmt/format.h"
 #include "arch/c64/c64.pb.h"
 #include "lib/encoders/encoders.pb.h"
 #include "lib/layout.h"
 #include <ctype.h>
-#include "bytes.h"
+#include "lib/bytes.h"
 
 static bool lastBit;
 
@@ -51,26 +51,6 @@ static void write_bits(
     }
 }
 
-void bindump(std::ostream& stream, std::vector<bool>& buffer)
-{
-    size_t pos = 0;
-
-    while ((pos < buffer.size()) and (pos < 520))
-    {
-        stream << fmt::format("{:5d} : ", pos);
-        for (int i = 0; i < 40; i++)
-        {
-            if ((pos + i) < buffer.size())
-                stream << fmt::format("{:01b}", (buffer[pos + i]));
-            else
-                stream << "-- ";
-            if ((((pos + i + 1) % 8) == 0) and i != 0)
-                stream << "  ";
-        }
-        stream << std::endl;
-        pos += 40;
-    }
-}
 static std::vector<bool> encode_data(uint8_t input)
 {
     /*
@@ -214,8 +194,7 @@ public:
             writeSector(bits, cursor, sector);
 
         if (cursor >= bits.size())
-            Error() << fmt::format(
-                "track data overrun by {} bits", cursor - bits.size());
+            error("track data overrun by {} bits", cursor - bits.size());
         fillBitmapTo(bits, cursor, bits.size(), {true, false});
 
         std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
@@ -243,8 +222,7 @@ private:
         {
             // There is data to encode to disk.
             if ((sector->data.size() != C64_SECTOR_LENGTH))
-                Error() << fmt::format(
-                    "unsupported sector size {} --- you must pick 256",
+                error("unsupported sector size {} --- you must pick 256",
                     sector->data.size());
 
             // 1. Write header Sync (not GCR)

arch/f85/decoder.cc

@@ -1,28 +1,30 @@
-#include "globals.h"
-#include "fluxmap.h"
-#include "decoders/fluxmapreader.h"
+#include "lib/globals.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "decoders/decoders.h"
-#include "sector.h"
+#include "lib/decoders/decoders.h"
+#include "lib/sector.h"
 #include "f85.h"
-#include "crc.h"
-#include "bytes.h"
+#include "lib/crc.h"
+#include "lib/bytes.h"
 #include "fmt/format.h"
 #include <string.h>
 #include <algorithm>
 
 const FluxPattern SECTOR_RECORD_PATTERN(24, F85_SECTOR_RECORD);
 const FluxPattern DATA_RECORD_PATTERN(24, F85_DATA_RECORD);
-const FluxMatchers ANY_RECORD_PATTERN({ &SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN });
+const FluxMatchers ANY_RECORD_PATTERN(
+    {&SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN});
 
 static int decode_data_gcr(uint8_t gcr)
 {
     switch (gcr)
     {
-		#define GCR_ENTRY(gcr, data) \
-			case gcr: return data;
-		#include "data_gcr.h"
-		#undef GCR_ENTRY
+#define GCR_ENTRY(gcr, data) \
+    case gcr:                \
+        return data;
+#include "data_gcr.h"
+#undef GCR_ENTRY
     }
     return -1;
 }
@@ -37,11 +39,11 @@ static Bytes decode(const std::vector<bool>& bits)
     while (ii != bits.end())
     {
         uint8_t inputfifo = 0;
-        for (size_t i=0; i<5; i++)
+        for (size_t i = 0; i < 5; i++)
         {
             if (ii == bits.end())
                 break;
-            inputfifo = (inputfifo<<1) | *ii++;
+            inputfifo = (inputfifo << 1) | *ii++;
         }
 
         bitw.push(decode_data_gcr(inputfifo), 4);
@@ -54,56 +56,55 @@ static Bytes decode(const std::vector<bool>& bits)
 class DurangoF85Decoder : public Decoder
 {
 public:
-	DurangoF85Decoder(const DecoderProto& config):
-		Decoder(config)
-	{}
+    DurangoF85Decoder(const DecoderProto& config): Decoder(config) {}
 
     nanoseconds_t advanceToNextRecord() override
-	{
-		return seekToPattern(ANY_RECORD_PATTERN);
-	}
+    {
+        return seekToPattern(ANY_RECORD_PATTERN);
+    }
 
     void decodeSectorRecord() override
-	{
-		/* Skip sync bits and ID byte. */
+    {
+        /* Skip sync bits and ID byte. */
 
-		if (readRaw24() != F85_SECTOR_RECORD)
-			return;
+        if (readRaw24() != F85_SECTOR_RECORD)
+            return;
 
-		/* Read header. */
+        /* Read header. */
 
-		const auto& bytes = decode(readRawBits(6*10));
+        const auto& bytes = decode(readRawBits(6 * 10));
 
-		_sector->logicalSector = bytes[2];
-		_sector->logicalSide = 0;
-		_sector->logicalTrack = bytes[0];
+        _sector->logicalSector = bytes[2];
+        _sector->logicalSide = 0;
+        _sector->logicalTrack = bytes[0];
 
-		uint16_t wantChecksum = bytes.reader().seek(4).read_be16();
-		uint16_t gotChecksum = crc16(CCITT_POLY, 0xef21, bytes.slice(0, 4));
-		if (wantChecksum == gotChecksum)
-			_sector->status = Sector::DATA_MISSING; /* unintuitive but correct */
-	}
+        uint16_t wantChecksum = bytes.reader().seek(4).read_be16();
+        uint16_t gotChecksum = crc16(CCITT_POLY, 0xef21, bytes.slice(0, 4));
+        if (wantChecksum == gotChecksum)
+            _sector->status =
+                Sector::DATA_MISSING; /* unintuitive but correct */
+    }
 
     void decodeDataRecord() override
-	{
-		/* Skip sync bits ID byte. */
+    {
+        /* Skip sync bits ID byte. */
 
-		if (readRaw24() != F85_DATA_RECORD)
-			return;
+        if (readRaw24() != F85_DATA_RECORD)
+            return;
 
-		const auto& bytes = decode(readRawBits((F85_SECTOR_LENGTH+3)*10))
-			.slice(0, F85_SECTOR_LENGTH+3);
-		ByteReader br(bytes);
+        const auto& bytes = decode(readRawBits((F85_SECTOR_LENGTH + 3) * 10))
+                                .slice(0, F85_SECTOR_LENGTH + 3);
+        ByteReader br(bytes);
 
-		_sector->data = br.read(F85_SECTOR_LENGTH);
-		uint16_t wantChecksum = br.read_be16();
-		uint16_t gotChecksum = crc16(CCITT_POLY, 0xbf84, _sector->data);
-		_sector->status = (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
-	}
+        _sector->data = br.read(F85_SECTOR_LENGTH);
+        uint16_t wantChecksum = br.read_be16();
+        uint16_t gotChecksum = crc16(CCITT_POLY, 0xbf84, _sector->data);
+        _sector->status =
+            (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
+    }
 };
 
 std::unique_ptr<Decoder> createDurangoF85Decoder(const DecoderProto& config)
 {
-	return std::unique_ptr<Decoder>(new DurangoF85Decoder(config));
+    return std::unique_ptr<Decoder>(new DurangoF85Decoder(config));
 }
-

arch/f85/f85.h

@@ -2,9 +2,10 @@
 #define F85_H
 
 #define F85_SECTOR_RECORD 0xffffce /* 1111 1111 1111 1111 1100 1110 */
-#define F85_DATA_RECORD 0xffffcb /* 1111 1111 1111 1111 1100 1101 */
-#define F85_SECTOR_LENGTH    512
+#define F85_DATA_RECORD 0xffffcb   /* 1111 1111 1111 1111 1100 1101 */
+#define F85_SECTOR_LENGTH 512
 
-extern std::unique_ptr<Decoder> createDurangoF85Decoder(const DecoderProto& config);
+extern std::unique_ptr<Decoder> createDurangoF85Decoder(
+    const DecoderProto& config);
 
 #endif

arch/fb100/decoder.cc

@@ -1,23 +1,23 @@
-#include "globals.h"
-#include "fluxmap.h"
-#include "decoders/fluxmapreader.h"
+#include "lib/globals.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "decoders/decoders.h"
-#include "sector.h"
+#include "lib/decoders/decoders.h"
+#include "lib/sector.h"
 #include "fb100.h"
-#include "crc.h"
-#include "bytes.h"
-#include "decoders/rawbits.h"
+#include "lib/crc.h"
+#include "lib/bytes.h"
+#include "lib/decoders/rawbits.h"
 #include "fmt/format.h"
 #include <string.h>
 #include <algorithm>
 
 const FluxPattern SECTOR_ID_PATTERN(16, 0xabaa);
 
-/* 
+/*
  * Reverse engineered from a dump of the floppy drive's ROM. I have no idea how
  * it works.
- * 
+ *
  * LF8BA:
  *         clra
  *         staa    X00B0
@@ -100,45 +100,43 @@ static uint16_t checksum(const Bytes& bytes)
 class Fb100Decoder : public Decoder
 {
 public:
-	Fb100Decoder(const DecoderProto& config):
-		Decoder(config)
-	{}
+    Fb100Decoder(const DecoderProto& config): Decoder(config) {}
 
     nanoseconds_t advanceToNextRecord() override
-	{
-		return seekToPattern(SECTOR_ID_PATTERN);
-	}
+    {
+        return seekToPattern(SECTOR_ID_PATTERN);
+    }
 
     void decodeSectorRecord() override
-	{
-		auto rawbits = readRawBits(FB100_RECORD_SIZE*16);
+    {
+        auto rawbits = readRawBits(FB100_RECORD_SIZE * 16);
 
-		const Bytes bytes = decodeFmMfm(rawbits).slice(0, FB100_RECORD_SIZE);
-		ByteReader br(bytes);
-		br.seek(1);
-		const Bytes id = br.read(FB100_ID_SIZE);
-		uint16_t wantIdCrc = br.read_be16();
-		uint16_t gotIdCrc = checksum(id);
-		const Bytes payload = br.read(FB100_PAYLOAD_SIZE);
-		uint16_t wantPayloadCrc = br.read_be16();
-		uint16_t gotPayloadCrc = checksum(payload);
+        const Bytes bytes = decodeFmMfm(rawbits).slice(0, FB100_RECORD_SIZE);
+        ByteReader br(bytes);
+        br.seek(1);
+        const Bytes id = br.read(FB100_ID_SIZE);
+        uint16_t wantIdCrc = br.read_be16();
+        uint16_t gotIdCrc = checksum(id);
+        const Bytes payload = br.read(FB100_PAYLOAD_SIZE);
+        uint16_t wantPayloadCrc = br.read_be16();
+        uint16_t gotPayloadCrc = checksum(payload);
 
-		if (wantIdCrc != gotIdCrc)
-			return;
+        if (wantIdCrc != gotIdCrc)
+            return;
 
-		uint8_t abssector = id[2];
-		_sector->logicalTrack = abssector >> 1;
-		_sector->logicalSide = 0;
-		_sector->logicalSector = abssector & 1;
-		_sector->data.writer().append(id.slice(5, 12)).append(payload);
+        uint8_t abssector = id[2];
+        _sector->logicalTrack = abssector >> 1;
+        _sector->logicalSide = 0;
+        _sector->logicalSector = abssector & 1;
+        _sector->data.writer().append(id.slice(5, 12)).append(payload);
 
-		_sector->status = (wantPayloadCrc == gotPayloadCrc) ? Sector::OK : Sector::BAD_CHECKSUM;
-	}
+        _sector->status = (wantPayloadCrc == gotPayloadCrc)
+                              ? Sector::OK
+                              : Sector::BAD_CHECKSUM;
+    }
 };
 
 std::unique_ptr<Decoder> createFb100Decoder(const DecoderProto& config)
 {
-	return std::unique_ptr<Decoder>(new Fb100Decoder(config));
+    return std::unique_ptr<Decoder>(new Fb100Decoder(config));
 }
-
-

arch/fb100/fb100.h

@@ -8,4 +8,3 @@
 extern std::unique_ptr<Decoder> createFb100Decoder(const DecoderProto& config);
 
 #endif
-

arch/ibm/decoder.cc

@@ -1,12 +1,12 @@
-#include "globals.h"
-#include "decoders/decoders.h"
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
 #include "ibm.h"
-#include "crc.h"
-#include "fluxmap.h"
-#include "decoders/fluxmapreader.h"
-#include "sector.h"
+#include "lib/crc.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
+#include "lib/sector.h"
 #include "arch/ibm/ibm.pb.h"
-#include "proto.h"
+#include "lib/proto.h"
 #include "lib/layout.h"
 #include <string.h>
 

arch/ibm/encoder.cc

@@ -1,10 +1,10 @@
-#include "globals.h"
-#include "decoders/decoders.h"
-#include "encoders/encoders.h"
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
 #include "ibm.h"
-#include "crc.h"
-#include "readerwriter.h"
-#include "image.h"
+#include "lib/crc.h"
+#include "lib/readerwriter.h"
+#include "lib/image.h"
 #include "arch/ibm/ibm.pb.h"
 #include "lib/encoders/encoders.pb.h"
 #include "fmt/format.h"
@@ -112,10 +112,11 @@ public:
         const Image& image) override
     {
         IbmEncoderProto::TrackdataProto trackdata;
-        getEncoderTrackData(trackdata, trackInfo->logicalTrack, trackInfo->logicalSide);
+        getEncoderTrackData(
+            trackdata, trackInfo->logicalTrack, trackInfo->logicalSide);
 
-        auto trackLayout =
-            Layout::getLayoutOfTrack(trackInfo->logicalTrack, trackInfo->logicalSide);
+        auto trackLayout = Layout::getLayoutOfTrack(
+            trackInfo->logicalTrack, trackInfo->logicalSide);
 
         auto writeBytes = [&](const Bytes& bytes)
         {
@@ -257,7 +258,7 @@ public:
         }
 
         if (_cursor >= _bits.size())
-            Error() << "track data overrun";
+            error("track data overrun");
         while (_cursor < _bits.size())
             writeFillerRawBytes(1, gapFill);
 

arch/ibm/ibm.h

@@ -31,9 +31,7 @@ class Decoder;
 class DecoderProto;
 class EncoderProto;
 
-extern std::unique_ptr<Decoder> createIbmDecoder(
-    const DecoderProto& config);
-extern std::unique_ptr<Encoder> createIbmEncoder(
-    const EncoderProto& config);
+extern std::unique_ptr<Decoder> createIbmDecoder(const DecoderProto& config);
+extern std::unique_ptr<Encoder> createIbmEncoder(const EncoderProto& config);
 
 #endif

arch/macintosh/decoder.cc

@@ -1,33 +1,36 @@
-#include "globals.h"
-#include "fluxmap.h"
-#include "decoders/fluxmapreader.h"
+#include "lib/globals.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "decoders/decoders.h"
-#include "sector.h"
+#include "lib/decoders/decoders.h"
+#include "lib/sector.h"
 #include "macintosh.h"
-#include "bytes.h"
+#include "lib/bytes.h"
 #include "fmt/format.h"
 #include <string.h>
 #include <algorithm>
 
 const FluxPattern SECTOR_RECORD_PATTERN(24, MAC_SECTOR_RECORD);
 const FluxPattern DATA_RECORD_PATTERN(24, MAC_DATA_RECORD);
-const FluxMatchers ANY_RECORD_PATTERN({ &SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN });
+const FluxMatchers ANY_RECORD_PATTERN(
+    {&SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN});
 
 static int decode_data_gcr(uint8_t gcr)
 {
     switch (gcr)
     {
-		#define GCR_ENTRY(gcr, data) \
-			case gcr: return data;
-		#include "data_gcr.h"
-		#undef GCR_ENTRY
+#define GCR_ENTRY(gcr, data) \
+    case gcr:                \
+        return data;
+#include "data_gcr.h"
+#undef GCR_ENTRY
     }
     return -1;
 }
 
-/* This is extremely inspired by the MESS implementation, written by Nathan Woods
- * and R. Belmont: https://github.com/mamedev/mame/blob/4263a71e64377db11392c458b580c5ae83556bc7/src/lib/formats/ap_dsk35.cpp
+/* This is extremely inspired by the MESS implementation, written by Nathan
+ * Woods and R. Belmont:
+ * https://github.com/mamedev/mame/blob/4263a71e64377db11392c458b580c5ae83556bc7/src/lib/formats/ap_dsk35.cpp
  */
 static Bytes decode_crazy_data(const Bytes& input, Sector::Status& status)
 {
@@ -41,7 +44,7 @@ static Bytes decode_crazy_data(const Bytes& input, Sector::Status& status)
     uint8_t b2[LOOKUP_LEN + 1];
     uint8_t b3[LOOKUP_LEN + 1];
 
-    for (int i=0; i<=LOOKUP_LEN; i++)
+    for (int i = 0; i <= LOOKUP_LEN; i++)
     {
         uint8_t w4 = br.read_8();
         uint8_t w1 = br.read_8();
@@ -125,67 +128,68 @@ uint8_t decode_side(uint8_t side)
 class MacintoshDecoder : public Decoder
 {
 public:
-	MacintoshDecoder(const DecoderProto& config):
-		Decoder(config)
-	{}
+    MacintoshDecoder(const DecoderProto& config): Decoder(config) {}
 
     nanoseconds_t advanceToNextRecord() override
-	{
-		return seekToPattern(ANY_RECORD_PATTERN);
-	}
+    {
+        return seekToPattern(ANY_RECORD_PATTERN);
+    }
 
     void decodeSectorRecord() override
-	{
-		if (readRaw24() != MAC_SECTOR_RECORD)
-			return;
+    {
+        if (readRaw24() != MAC_SECTOR_RECORD)
+            return;
 
-		/* Read header. */
+        /* Read header. */
 
-		auto header = toBytes(readRawBits(7*8)).slice(0, 7);
-					
-		uint8_t encodedTrack = decode_data_gcr(header[0]);
-		if (encodedTrack != (_sector->physicalTrack & 0x3f))
-			return;
-					
-		uint8_t encodedSector = decode_data_gcr(header[1]);
-		uint8_t encodedSide = decode_data_gcr(header[2]);
-		uint8_t formatByte = decode_data_gcr(header[3]);
-		uint8_t wantedsum = decode_data_gcr(header[4]);
+        auto header = toBytes(readRawBits(7 * 8)).slice(0, 7);
 
-		if (encodedSector > 11)
-			return;
+        uint8_t encodedTrack = decode_data_gcr(header[0]);
+        if (encodedTrack != (_sector->physicalTrack & 0x3f))
+            return;
 
-		_sector->logicalTrack = _sector->physicalTrack;
-		_sector->logicalSide = decode_side(encodedSide);
-		_sector->logicalSector = encodedSector;
-		uint8_t gotsum = (encodedTrack ^ encodedSector ^ encodedSide ^ formatByte) & 0x3f;
-		if (wantedsum == gotsum)
-			_sector->status = Sector::DATA_MISSING; /* unintuitive but correct */
-	}
+        uint8_t encodedSector = decode_data_gcr(header[1]);
+        uint8_t encodedSide = decode_data_gcr(header[2]);
+        uint8_t formatByte = decode_data_gcr(header[3]);
+        uint8_t wantedsum = decode_data_gcr(header[4]);
+
+        if (encodedSector > 11)
+            return;
+
+        _sector->logicalTrack = _sector->physicalTrack;
+        _sector->logicalSide = decode_side(encodedSide);
+        _sector->logicalSector = encodedSector;
+        uint8_t gotsum =
+            (encodedTrack ^ encodedSector ^ encodedSide ^ formatByte) & 0x3f;
+        if (wantedsum == gotsum)
+            _sector->status =
+                Sector::DATA_MISSING; /* unintuitive but correct */
+    }
 
     void decodeDataRecord() override
-	{
-		if (readRaw24() != MAC_DATA_RECORD)
-			return;
+    {
+        if (readRaw24() != MAC_DATA_RECORD)
+            return;
 
-		/* Read data. */
+        /* Read data. */
 
-		readRawBits(8); /* skip spare byte */
-		auto inputbuffer = toBytes(readRawBits(MAC_ENCODED_SECTOR_LENGTH*8))
-			.slice(0, MAC_ENCODED_SECTOR_LENGTH);
+        readRawBits(8); /* skip spare byte */
+        auto inputbuffer = toBytes(readRawBits(MAC_ENCODED_SECTOR_LENGTH * 8))
+                               .slice(0, MAC_ENCODED_SECTOR_LENGTH);
 
-		for (unsigned i=0; i<inputbuffer.size(); i++)
-			inputbuffer[i] = decode_data_gcr(inputbuffer[i]);
-			
-		_sector->status = Sector::BAD_CHECKSUM;
-		Bytes userData = decode_crazy_data(inputbuffer, _sector->status);
-		_sector->data.clear();
-		_sector->data.writer().append(userData.slice(12, 512)).append(userData.slice(0, 12));
-	}
+        for (unsigned i = 0; i < inputbuffer.size(); i++)
+            inputbuffer[i] = decode_data_gcr(inputbuffer[i]);
+
+        _sector->status = Sector::BAD_CHECKSUM;
+        Bytes userData = decode_crazy_data(inputbuffer, _sector->status);
+        _sector->data.clear();
+        _sector->data.writer()
+            .append(userData.slice(12, 512))
+            .append(userData.slice(0, 12));
+    }
 };
 
 std::unique_ptr<Decoder> createMacintoshDecoder(const DecoderProto& config)
 {
-	return std::unique_ptr<Decoder>(new MacintoshDecoder(config));
+    return std::unique_ptr<Decoder>(new MacintoshDecoder(config));
 }
-

arch/macintosh/encoder.cc

@@ -1,10 +1,10 @@
-#include "globals.h"
-#include "decoders/decoders.h"
-#include "encoders/encoders.h"
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
 #include "macintosh.h"
-#include "crc.h"
-#include "readerwriter.h"
-#include "image.h"
+#include "lib/crc.h"
+#include "lib/readerwriter.h"
+#include "lib/image.h"
 #include "fmt/format.h"
 #include "lib/encoders/encoders.pb.h"
 #include "lib/layout.h"
@@ -174,7 +174,7 @@ static void write_sector(std::vector<bool>& bits,
     const std::shared_ptr<const Sector>& sector)
 {
     if ((sector->data.size() != 512) && (sector->data.size() != 524))
-        Error() << "unsupported sector size --- you must pick 512 or 524";
+        error("unsupported sector size --- you must pick 512 or 524");
 
     write_bits(bits, cursor, 0xff, 1 * 8); /* pad byte */
     for (int i = 0; i < 7; i++)
@@ -239,13 +239,12 @@ public:
             write_sector(bits, cursor, sector);
 
         if (cursor >= bits.size())
-            Error() << fmt::format(
-                "track data overrun by {} bits", cursor - bits.size());
+            error("track data overrun by {} bits", cursor - bits.size());
         fillBitmapTo(bits, cursor, bits.size(), {true, false});
 
         std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
-        fluxmap->appendBits(bits,
-            calculatePhysicalClockPeriod(clockRateUs * 1e3, 200e6));
+        fluxmap->appendBits(
+            bits, calculatePhysicalClockPeriod(clockRateUs * 1e3, 200e6));
         return fluxmap;
     }
 
@@ -253,8 +252,7 @@ private:
     const MacintoshEncoderProto& _config;
 };
 
-std::unique_ptr<Encoder> createMacintoshEncoder(
-    const EncoderProto& config)
+std::unique_ptr<Encoder> createMacintoshEncoder(const EncoderProto& config)
 {
     return std::unique_ptr<Encoder>(new MacintoshEncoder(config));
 }

arch/macintosh/macintosh.h

@@ -1,12 +1,12 @@
 #ifndef MACINTOSH_H
 #define MACINTOSH_H
 
-#define MAC_SECTOR_RECORD   0xd5aa96 /* 1101 0101 1010 1010 1001 0110 */
-#define MAC_DATA_RECORD     0xd5aaad /* 1101 0101 1010 1010 1010 1101 */
+#define MAC_SECTOR_RECORD 0xd5aa96 /* 1101 0101 1010 1010 1001 0110 */
+#define MAC_DATA_RECORD 0xd5aaad   /* 1101 0101 1010 1010 1010 1101 */
 
-#define MAC_SECTOR_LENGTH   524 /* yes, really */
+#define MAC_SECTOR_LENGTH 524 /* yes, really */
 #define MAC_ENCODED_SECTOR_LENGTH 703
-#define MAC_FORMAT_BYTE     0x22
+#define MAC_FORMAT_BYTE 0x22
 
 #define MAC_TRACKS_PER_DISK 80
 
@@ -15,8 +15,9 @@ class Decoder;
 class DecoderProto;
 class EncoderProto;
 
-extern std::unique_ptr<Decoder> createMacintoshDecoder(const DecoderProto& config);
-extern std::unique_ptr<Encoder> createMacintoshEncoder(const EncoderProto& config);
+extern std::unique_ptr<Decoder> createMacintoshDecoder(
+    const DecoderProto& config);
+extern std::unique_ptr<Encoder> createMacintoshEncoder(
+    const EncoderProto& config);
 
 #endif
-

arch/micropolis/decoder.cc

@@ -1,10 +1,10 @@
-#include "globals.h"
-#include "fluxmap.h"
-#include "decoders/fluxmapreader.h"
-#include "decoders/decoders.h"
-#include "sector.h"
+#include "lib/globals.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
+#include "lib/decoders/decoders.h"
+#include "lib/sector.h"
 #include "micropolis.h"
-#include "bytes.h"
+#include "lib/bytes.h"
 #include "fmt/format.h"
 #include "lib/decoders/decoders.pb.h"
 
@@ -20,17 +20,20 @@ static const FluxPattern SECTOR_SYNC_PATTERN(64, 0xAAAAAAAAAAAA5555LL);
 static const FluxPattern SECTOR_ADVANCE_PATTERN(64, 0xAAAAAAAAAAAAAAAALL);
 
 /* Standard Micropolis checksum.  Adds all bytes, with carry. */
-uint8_t micropolisChecksum(const Bytes& bytes) {
-	ByteReader br(bytes);
-	uint16_t sum = 0;
-	while (!br.eof()) {
-		if (sum > 0xFF) {
-			sum -= 0x100 - 1;
-		}
-		sum += br.read_8();
-	}
-	/* The last carry is ignored */
-	return sum & 0xFF;
+uint8_t micropolisChecksum(const Bytes& bytes)
+{
+    ByteReader br(bytes);
+    uint16_t sum = 0;
+    while (!br.eof())
+    {
+        if (sum > 0xFF)
+        {
+            sum -= 0x100 - 1;
+        }
+        sum += br.read_8();
+    }
+    /* The last carry is ignored */
+    return sum & 0xFF;
 }
 
 /* Vector MZOS does not use the standard Micropolis checksum.
@@ -41,145 +44,251 @@ uint8_t micropolisChecksum(const Bytes& bytes) {
  * Unlike the Micropolis checksum, this does not cover the 12-byte
  * header (track, sector, 10 OS-specific bytes.)
  */
-uint8_t mzosChecksum(const Bytes& bytes) {
-	ByteReader br(bytes);
-	uint8_t checksum = 0;
-	uint8_t databyte;
+uint8_t mzosChecksum(const Bytes& bytes)
+{
+    ByteReader br(bytes);
+    uint8_t checksum = 0;
+    uint8_t databyte;
 
-	while (!br.eof()) {
-		databyte = br.read_8();
-	checksum ^= ((databyte << 1) | (databyte >> 7));
-	}
+    while (!br.eof())
+    {
+        databyte = br.read_8();
+        checksum ^= ((databyte << 1) | (databyte >> 7));
+    }
 
-	return checksum;
+    return checksum;
+}
+
+static uint8_t b(uint32_t field, uint8_t pos)
+{
+    return (field >> pos) & 1;
+}
+
+static uint8_t eccNextBit(uint32_t ecc, uint8_t data_bit)
+{
+    // This is 0x81932080 which is 0x0104C981 with reversed bits
+    return b(ecc, 7) ^ b(ecc, 13) ^ b(ecc, 16) ^ b(ecc, 17) ^ b(ecc, 20) ^
+           b(ecc, 23) ^ b(ecc, 24) ^ b(ecc, 31) ^ data_bit;
+}
+
+uint32_t vectorGraphicEcc(const Bytes& bytes)
+{
+    uint32_t e = 0;
+    Bytes payloadBytes = bytes.slice(0, bytes.size() - 4);
+    ByteReader payload(payloadBytes);
+    while (!payload.eof())
+    {
+        uint8_t byte = payload.read_8();
+        for (int i = 0; i < 8; i++)
+        {
+            e = (e << 1) | eccNextBit(e, byte >> 7);
+            byte <<= 1;
+        }
+    }
+    Bytes trailerBytes = bytes.slice(bytes.size() - 4);
+    ByteReader trailer(trailerBytes);
+    uint32_t res = e;
+    while (!trailer.eof())
+    {
+        uint8_t byte = trailer.read_8();
+        for (int i = 0; i < 8; i++)
+        {
+            res = (res << 1) | eccNextBit(e, byte >> 7);
+            e <<= 1;
+            byte <<= 1;
+        }
+    }
+    return res;
+}
+
+/* Fixes bytes when possible, returning true if changed. */
+static bool vectorGraphicEccFix(Bytes& bytes, uint32_t syndrome)
+{
+    uint32_t ecc = syndrome;
+    int pos = (MICROPOLIS_ENCODED_SECTOR_SIZE - 5) * 8 + 7;
+    bool aligned = false;
+    while ((ecc & 0xff000000) == 0)
+    {
+        pos += 8;
+        ecc <<= 8;
+    }
+    for (; pos >= 0; pos--)
+    {
+        bool bit = ecc & 1;
+        ecc >>= 1;
+        if (bit)
+            ecc ^= 0x808264c0;
+        if ((ecc & 0xff07ffff) == 0)
+            aligned = true;
+        if (aligned && pos % 8 == 0)
+            break;
+    }
+    if (pos < 0)
+        return false;
+    bytes[pos / 8] ^= ecc >> 16;
+    return true;
 }
 
 class MicropolisDecoder : public Decoder
 {
 public:
-	MicropolisDecoder(const DecoderProto& config):
-		Decoder(config),
-		_config(config.micropolis())
-	{
-		_checksumType = _config.checksum_type();
-	}
+    MicropolisDecoder(const DecoderProto& config):
+        Decoder(config),
+        _config(config.micropolis())
+    {
+        _checksumType = _config.checksum_type();
+    }
 
-	nanoseconds_t advanceToNextRecord() override
-	{
-		nanoseconds_t now = tell().ns();
+    nanoseconds_t advanceToNextRecord() override
+    {
+        nanoseconds_t now = tell().ns();
 
-		/* For all but the first sector, seek to the next sector pulse.
-		 * The first sector does not contain the sector pulse in the fluxmap.
-		 */
-		if (now != 0) {
-			seekToIndexMark();
-			now = tell().ns();
-		}
+        /* For all but the first sector, seek to the next sector pulse.
+         * The first sector does not contain the sector pulse in the fluxmap.
+         */
+        if (now != 0)
+        {
+            seekToIndexMark();
+            now = tell().ns();
+        }
 
-		/* Discard a possible partial sector at the end of the track.
-		 * This partial sector could be mistaken for a conflicted sector, if
-		 * whatever data read happens to match the checksum of 0, which is
-		 * rare, but has been observed on some disks.
-		 */
-		if (now > (getFluxmapDuration() - 12.5e6)) {
-			seekToIndexMark();
-			return 0;
-		}
+        /* Discard a possible partial sector at the end of the track.
+         * This partial sector could be mistaken for a conflicted sector, if
+         * whatever data read happens to match the checksum of 0, which is
+         * rare, but has been observed on some disks. There's 570uS of slack in
+         * each sector, after accounting for preamble, data, and postamble.
+         */
+        if (now > (getFluxmapDuration() - 12.0e6))
+        {
+            seekToIndexMark();
+            return 0;
+        }
 
-		nanoseconds_t clock = seekToPattern(SECTOR_SYNC_PATTERN);
+        nanoseconds_t clock = seekToPattern(SECTOR_SYNC_PATTERN);
 
-		auto syncDelta = tell().ns() - now;
-		/* Due to the weak nature of the Micropolis SYNC patern,
-		 * it's possible to detect a false SYNC during the gap
-		 * between the sector pulse and the write gate.  If the SYNC
-		 * is detected less than 100uS after the sector pulse, search
-		 * for another valid SYNC.
-		 *
-		 * Reference: Vector Micropolis Disk Controller Board Technical
-		 * Information Manual, pp. 1-16.
-		 */
-		if ((syncDelta > 0) && (syncDelta < 100e3)) {
-			seekToPattern(SECTOR_ADVANCE_PATTERN);
-			clock = seekToPattern(SECTOR_SYNC_PATTERN);
-		}
+        auto syncDelta = tell().ns() - now;
+        /* Due to the weak nature of the Micropolis SYNC patern,
+         * it's possible to detect a false SYNC during the gap
+         * between the sector pulse and the write gate.  If the SYNC
+         * is detected less than 100uS after the sector pulse, search
+         * for another valid SYNC.
+         *
+         * Reference: Vector Micropolis Disk Controller Board Technical
+         * Information Manual, pp. 1-16.
+         */
+        if ((syncDelta > 0) && (syncDelta < 100e3))
+        {
+            seekToPattern(SECTOR_ADVANCE_PATTERN);
+            clock = seekToPattern(SECTOR_SYNC_PATTERN);
+        }
 
-		_sector->headerStartTime = tell().ns();
+        _sector->headerStartTime = tell().ns();
 
-		/* seekToPattern() can skip past the index hole, if this happens
-		 * too close to the end of the Fluxmap, discard the sector.
-		 */
-		if (_sector->headerStartTime > (getFluxmapDuration() - 12.5e6)) {
-			return 0;
-		}
+        /* seekToPattern() can skip past the index hole, if this happens
+         * too close to the end of the Fluxmap, discard the sector. The
+         * preamble was expected to be 640uS long.
+         */
+        if (_sector->headerStartTime > (getFluxmapDuration() - 11.3e6))
+        {
+            return 0;
+        }
 
-		return clock;
-	}
+        return clock;
+    }
 
-	void decodeSectorRecord() override
-	{
-		readRawBits(48);
-		auto rawbits = readRawBits(MICROPOLIS_ENCODED_SECTOR_SIZE*16);
-		auto bytes = decodeFmMfm(rawbits).slice(0, MICROPOLIS_ENCODED_SECTOR_SIZE);
-		ByteReader br(bytes);
+    void decodeSectorRecord() override
+    {
+        readRawBits(48);
+        auto rawbits = readRawBits(MICROPOLIS_ENCODED_SECTOR_SIZE * 16);
+        auto bytes =
+            decodeFmMfm(rawbits).slice(0, MICROPOLIS_ENCODED_SECTOR_SIZE);
 
-		int syncByte = br.read_8();  /* sync */
-		if (syncByte != 0xFF)
-			return;
+        bool eccPresent = bytes[274] == 0xaa;
+        uint32_t ecc = 0;
+        if (_config.ecc_type() == MicropolisDecoderProto::VECTOR && eccPresent)
+        {
+            ecc = vectorGraphicEcc(bytes.slice(0, 274));
+            if (ecc != 0)
+            {
+                vectorGraphicEccFix(bytes, ecc);
+                ecc = vectorGraphicEcc(bytes.slice(0, 274));
+            }
+        }
 
-		_sector->logicalTrack = br.read_8();
-		_sector->logicalSide = _sector->physicalSide;
-		_sector->logicalSector = br.read_8();
-		if (_sector->logicalSector > 15)
-			return;
-		if (_sector->logicalTrack > 76)
-			return;
-		if (_sector->logicalTrack != _sector->physicalTrack)
-			return;
+        ByteReader br(bytes);
 
-		br.read(10);  /* OS data or padding */
-		auto data = br.read(MICROPOLIS_PAYLOAD_SIZE);
-		uint8_t wantChecksum = br.read_8();
+        int syncByte = br.read_8(); /* sync */
+        if (syncByte != 0xFF)
+            return;
 
-		/* If not specified, automatically determine the checksum type.
-		* Once the checksum type is determined, it will be used for the
-		* entire disk.
-		*/
-		if (_checksumType == MicropolisDecoderProto::AUTO) {
-			/* Calculate both standard Micropolis (MDOS, CP/M, OASIS) and MZOS checksums */
-			if (wantChecksum == micropolisChecksum(bytes.slice(1, 2+266))) {
-				_checksumType = MicropolisDecoderProto::MICROPOLIS;
-			} else if (wantChecksum == mzosChecksum(bytes.slice(MICROPOLIS_HEADER_SIZE, MICROPOLIS_PAYLOAD_SIZE))) {
-				_checksumType = MicropolisDecoderProto::MZOS;
-				std::cout << "Note: MZOS checksum detected." << std::endl;
-			}
-		}
+        _sector->logicalTrack = br.read_8();
+        _sector->logicalSide = _sector->physicalSide;
+        _sector->logicalSector = br.read_8();
+        if (_sector->logicalSector > 15)
+            return;
+        if (_sector->logicalTrack > 76)
+            return;
+        if (_sector->logicalTrack != _sector->physicalTrack)
+            return;
 
-		uint8_t gotChecksum;
+        br.read(10); /* OS data or padding */
+        auto data = br.read(MICROPOLIS_PAYLOAD_SIZE);
+        uint8_t wantChecksum = br.read_8();
 
-		if (_checksumType == MicropolisDecoderProto::MZOS) {
-			gotChecksum = mzosChecksum(bytes.slice(MICROPOLIS_HEADER_SIZE, MICROPOLIS_PAYLOAD_SIZE));
-		} else {
-			gotChecksum = micropolisChecksum(bytes.slice(1, 2+266));
-		}
+        /* If not specified, automatically determine the checksum type.
+         * Once the checksum type is determined, it will be used for the
+         * entire disk.
+         */
+        if (_checksumType == MicropolisDecoderProto::AUTO)
+        {
+            /* Calculate both standard Micropolis (MDOS, CP/M, OASIS) and MZOS
+             * checksums */
+            if (wantChecksum == micropolisChecksum(bytes.slice(1, 2 + 266)))
+            {
+                _checksumType = MicropolisDecoderProto::MICROPOLIS;
+            }
+            else if (wantChecksum ==
+                     mzosChecksum(bytes.slice(
+                         MICROPOLIS_HEADER_SIZE, MICROPOLIS_PAYLOAD_SIZE)))
+            {
+                _checksumType = MicropolisDecoderProto::MZOS;
+                std::cout << "Note: MZOS checksum detected." << std::endl;
+            }
+        }
 
-		br.read(5);  /* 4 byte ECC and ECC-present flag */
+        uint8_t gotChecksum;
 
-		if (_config.sector_output_size() == MICROPOLIS_PAYLOAD_SIZE)
-			_sector->data = data;
-		else if (_config.sector_output_size() == MICROPOLIS_ENCODED_SECTOR_SIZE)
-			_sector->data = bytes;
-		else
-			Error() << "Sector output size may only be 256 or 275";
-		_sector->status = (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
-	}
+        if (_checksumType == MicropolisDecoderProto::MZOS)
+        {
+            gotChecksum = mzosChecksum(
+                bytes.slice(MICROPOLIS_HEADER_SIZE, MICROPOLIS_PAYLOAD_SIZE));
+        }
+        else
+        {
+            gotChecksum = micropolisChecksum(bytes.slice(1, 2 + 266));
+        }
+
+        br.read(5); /* 4 byte ECC and ECC-present flag */
+
+        if (_config.sector_output_size() == MICROPOLIS_PAYLOAD_SIZE)
+            _sector->data = data;
+        else if (_config.sector_output_size() == MICROPOLIS_ENCODED_SECTOR_SIZE)
+            _sector->data = bytes;
+        else
+            error("Sector output size may only be 256 or 275");
+        if (wantChecksum == gotChecksum && (!eccPresent || ecc == 0))
+            _sector->status = Sector::OK;
+        else
+            _sector->status = Sector::BAD_CHECKSUM;
+    }
 
 private:
-	const MicropolisDecoderProto& _config;
-	MicropolisDecoderProto_ChecksumType _checksumType;	/* -1 = auto, 1 = Micropolis, 2=MZOS */
+    const MicropolisDecoderProto& _config;
+    MicropolisDecoderProto_ChecksumType
+        _checksumType; /* -1 = auto, 1 = Micropolis, 2=MZOS */
 };
 
 std::unique_ptr<Decoder> createMicropolisDecoder(const DecoderProto& config)
 {
-	return std::unique_ptr<Decoder>(new MicropolisDecoder(config));
+    return std::unique_ptr<Decoder>(new MicropolisDecoder(config));
 }
-

arch/micropolis/encoder.cc

@@ -1,18 +1,19 @@
-#include "globals.h"
+#include "lib/globals.h"
 #include "micropolis.h"
-#include "sector.h"
-#include "decoders/decoders.h"
-#include "encoders/encoders.h"
-#include "image.h"
+#include "lib/sector.h"
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
+#include "lib/image.h"
 #include "lib/encoders/encoders.pb.h"
 
 static void write_sector(std::vector<bool>& bits,
     unsigned& cursor,
-    const std::shared_ptr<const Sector>& sector)
+    const std::shared_ptr<const Sector>& sector,
+    MicropolisEncoderProto::EccType eccType)
 {
     if ((sector->data.size() != 256) &&
         (sector->data.size() != MICROPOLIS_ENCODED_SECTOR_SIZE))
-        Error() << "unsupported sector size --- you must pick 256 or 275";
+        error("unsupported sector size --- you must pick 256 or 275");
 
     int fullSectorSize = 40 + MICROPOLIS_ENCODED_SECTOR_SIZE + 40 + 35;
     auto fullSector = std::make_shared<std::vector<uint8_t>>();
@@ -24,8 +25,9 @@ static void write_sector(std::vector<bool>& bits,
     if (sector->data.size() == MICROPOLIS_ENCODED_SECTOR_SIZE)
     {
         if (sector->data[0] != 0xFF)
-            Error() << "275 byte sector doesn't start with sync byte 0xFF. "
-                       "Corrupted sector";
+            error(
+                "275 byte sector doesn't start with sync byte 0xFF. "
+                "Corrupted sector");
         uint8_t wantChecksum = sector->data[1 + 2 + 266];
         uint8_t gotChecksum =
             micropolisChecksum(sector->data.slice(1, 2 + 266));
@@ -44,8 +46,16 @@ static void write_sector(std::vector<bool>& bits,
             writer.write_8(0); /* Padding */
         writer += sector->data;
         writer.write_8(micropolisChecksum(sectorData.slice(1)));
-        for (int i = 0; i < 5; i++)
-            writer.write_8(0); /* 4 byte ECC and ECC not present flag */
+
+        uint8_t eccPresent = 0;
+        uint32_t ecc = 0;
+        if (eccType == MicropolisEncoderProto::VECTOR)
+        {
+            eccPresent = 0xaa;
+            ecc = vectorGraphicEcc(sectorData + Bytes(4));
+        }
+        writer.write_be32(ecc);
+        writer.write_8(eccPresent);
     }
     for (uint8_t b : sectorData)
         fullSector->push_back(b);
@@ -57,7 +67,7 @@ static void write_sector(std::vector<bool>& bits,
         fullSector->push_back(0);
 
     if (fullSector->size() != fullSectorSize)
-        Error() << "sector mismatched length";
+        error("sector mismatched length");
     bool lastBit = false;
     encodeMfm(bits, cursor, fullSector, lastBit);
     /* filler */
@@ -85,19 +95,34 @@ public:
             (_config.rotational_period_ms() * 1e3) / _config.clock_period_us();
 
         std::vector<bool> bits(bitsPerRevolution);
+        std::vector<unsigned> indexes;
+        unsigned prev_cursor = 0;
         unsigned cursor = 0;
 
         for (const auto& sectorData : sectors)
-            write_sector(bits, cursor, sectorData);
+        {
+            indexes.push_back(cursor);
+            prev_cursor = cursor;
+            write_sector(bits, cursor, sectorData, _config.ecc_type());
+        }
+        indexes.push_back(prev_cursor + (cursor - prev_cursor) / 2);
+        indexes.push_back(cursor);
 
         if (cursor != bits.size())
-            Error() << "track data mismatched length";
+            error("track data mismatched length");
 
         std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
-        fluxmap->appendBits(bits,
-            calculatePhysicalClockPeriod(
-                _config.clock_period_us() * 1e3,
-                _config.rotational_period_ms() * 1e6));
+        nanoseconds_t clockPeriod =
+            calculatePhysicalClockPeriod(_config.clock_period_us() * 1e3,
+                _config.rotational_period_ms() * 1e6);
+        auto pos = bits.begin();
+        for (int i = 1; i < indexes.size(); i++)
+        {
+            auto end = bits.begin() + indexes[i];
+            fluxmap->appendBits(std::vector<bool>(pos, end), clockPeriod);
+            fluxmap->appendIndex();
+            pos = end;
+        }
         return fluxmap;
     }
 
@@ -105,8 +130,7 @@ private:
     const MicropolisEncoderProto& _config;
 };
 
-std::unique_ptr<Encoder> createMicropolisEncoder(
-    const EncoderProto& config)
+std::unique_ptr<Encoder> createMicropolisEncoder(const EncoderProto& config)
 {
     return std::unique_ptr<Encoder>(new MicropolisEncoder(config));
 }

arch/micropolis/micropolis.h

@@ -1,18 +1,22 @@
 #ifndef MICROPOLIS_H
 #define MICROPOLIS_H
 
-#define MICROPOLIS_PAYLOAD_SIZE         (256)
-#define MICROPOLIS_HEADER_SIZE          (1+2+10)
-#define MICROPOLIS_ENCODED_SECTOR_SIZE  (MICROPOLIS_HEADER_SIZE + MICROPOLIS_PAYLOAD_SIZE + 6)
+#define MICROPOLIS_PAYLOAD_SIZE (256)
+#define MICROPOLIS_HEADER_SIZE (1 + 2 + 10)
+#define MICROPOLIS_ENCODED_SECTOR_SIZE \
+    (MICROPOLIS_HEADER_SIZE + MICROPOLIS_PAYLOAD_SIZE + 6)
 
 class Decoder;
 class Encoder;
 class EncoderProto;
 class DecoderProto;
 
-extern std::unique_ptr<Decoder> createMicropolisDecoder(const DecoderProto& config);
-extern std::unique_ptr<Encoder> createMicropolisEncoder(const EncoderProto& config);
+extern std::unique_ptr<Decoder> createMicropolisDecoder(
+    const DecoderProto& config);
+extern std::unique_ptr<Encoder> createMicropolisEncoder(
+    const EncoderProto& config);
 
 extern uint8_t micropolisChecksum(const Bytes& bytes);
+extern uint32_t vectorGraphicEcc(const Bytes& bytes);
 
 #endif

arch/micropolis/micropolis.proto

@@ -8,17 +8,30 @@ message MicropolisDecoderProto {
 		MICROPOLIS = 1;
 		MZOS = 2;
 	}
+	enum EccType {
+		NONE = 0;
+		VECTOR = 1;
+	}
 
 	optional int32 sector_output_size = 1 [default = 256,
 		(help) = "How much of the raw sector should be saved. Must be 256 or 275"];
 	optional ChecksumType checksum_type = 2 [default = AUTO,
 		(help) = "Checksum type to use: AUTO, MICROPOLIS, MZOS"];
+	optional EccType ecc_type = 3 [default = NONE,
+		(help) = "ECC type to use: NONE, VECTOR"];
 }
 
 message MicropolisEncoderProto {
+    enum EccType {
+        NONE = 0;
+        VECTOR = 1;
+    }
+
     optional double clock_period_us = 1
         [ default = 2.0, (help) = "clock rate on the real device" ];
     optional double rotational_period_ms = 2
-        [ default = 166.0, (help) = "rotational period on the real device" ];
+        [ default = 200.0, (help) = "rotational period on the real device" ];
+    optional EccType ecc_type = 3 [default = NONE,
+        (help) = "ECC type to use for IMG data: NONE, VECTOR"];
 }
 

arch/mx/decoder.cc

@@ -1,10 +1,10 @@
-#include "globals.h"
-#include "decoders/decoders.h"
-#include "mx/mx.h"
-#include "crc.h"
-#include "fluxmap.h"
-#include "decoders/fluxmapreader.h"
-#include "sector.h"
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
+#include "arch/mx/mx.h"
+#include "lib/crc.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
+#include "lib/sector.h"
 #include <string.h>
 
 const int SECTOR_SIZE = 256;
@@ -26,52 +26,51 @@ const FluxPattern ID_PATTERN(32, 0xaaaaffaf);
 class MxDecoder : public Decoder
 {
 public:
-	MxDecoder(const DecoderProto& config):
-		Decoder(config)
-	{}
+    MxDecoder(const DecoderProto& config): Decoder(config) {}
 
     void beginTrack() override
-	{
-		_clock = _sector->clock = seekToPattern(ID_PATTERN);
-		_currentSector = 0;
-	}
+    {
+        _clock = _sector->clock = seekToPattern(ID_PATTERN);
+        _currentSector = 0;
+    }
 
     nanoseconds_t advanceToNextRecord() override
-	{
-		if (_currentSector == 11)
-		{
-			/* That was the last sector on the disk. */
-			return 0;
-		}
-		else
-			return _clock;
-	}
+    {
+        if (_currentSector == 11)
+        {
+            /* That was the last sector on the disk. */
+            return 0;
+        }
+        else
+            return _clock;
+    }
 
     void decodeSectorRecord() override
-	{
-		/* Skip the ID pattern and track word, which is only present on the
-		 * first sector. We don't trust the track word because some driver
-		 * don't write it correctly. */
+    {
+        /* Skip the ID pattern and track word, which is only present on the
+         * first sector. We don't trust the track word because some driver
+         * don't write it correctly. */
 
-		if (_currentSector == 0)
-			readRawBits(64);
+        if (_currentSector == 0)
+            readRawBits(64);
 
-		auto bits = readRawBits((SECTOR_SIZE+2)*16);
-		auto bytes = decodeFmMfm(bits).slice(0, SECTOR_SIZE+2);
+        auto bits = readRawBits((SECTOR_SIZE + 2) * 16);
+        auto bytes = decodeFmMfm(bits).slice(0, SECTOR_SIZE + 2);
 
-		uint16_t gotChecksum = 0;
-		ByteReader br(bytes);
-		for (int i=0; i<(SECTOR_SIZE/2); i++)
-			gotChecksum += br.read_be16();
-		uint16_t wantChecksum = br.read_be16();
+        uint16_t gotChecksum = 0;
+        ByteReader br(bytes);
+        for (int i = 0; i < (SECTOR_SIZE / 2); i++)
+            gotChecksum += br.read_be16();
+        uint16_t wantChecksum = br.read_be16();
 
-		_sector->logicalTrack = _sector->physicalTrack;
-		_sector->logicalSide = _sector->physicalSide;
-		_sector->logicalSector = _currentSector;
-		_sector->data = bytes.slice(0, SECTOR_SIZE).swab();
-		_sector->status = (gotChecksum == wantChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
-		_currentSector++;
-	}
+        _sector->logicalTrack = _sector->physicalTrack;
+        _sector->logicalSide = _sector->physicalSide;
+        _sector->logicalSector = _currentSector;
+        _sector->data = bytes.slice(0, SECTOR_SIZE).swab();
+        _sector->status =
+            (gotChecksum == wantChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
+        _currentSector++;
+    }
 
 private:
     nanoseconds_t _clock;
@@ -80,7 +79,5 @@ private:
 
 std::unique_ptr<Decoder> createMxDecoder(const DecoderProto& config)
 {
-	return std::unique_ptr<Decoder>(new MxDecoder(config));
+    return std::unique_ptr<Decoder>(new MxDecoder(config));
 }
-
-

arch/mx/mx.h

@@ -1,7 +1,7 @@
 #ifndef MX_H
 #define MX_H
 
-#include "decoders/decoders.h"
+#include "lib/decoders/decoders.h"
 
 extern std::unique_ptr<Decoder> createMxDecoder(const DecoderProto& config);
 

arch/northstar/decoder.cc

@@ -11,18 +11,18 @@
  * sure that the hardSectorId is correct.
  */
 
-#include "globals.h"
-#include "fluxmap.h"
-#include "decoders/fluxmapreader.h"
-#include "decoders/decoders.h"
-#include "sector.h"
+#include "lib/globals.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
+#include "lib/decoders/decoders.h"
+#include "lib/sector.h"
 #include "northstar.h"
-#include "bytes.h"
+#include "lib/bytes.h"
 #include "lib/decoders/decoders.pb.h"
 #include "fmt/format.h"
 
 #define MFM_ID 0xaaaaaaaaaaaa5545LL
-#define FM_ID  0xaaaaaaaaaaaaffefLL
+#define FM_ID 0xaaaaaaaaaaaaffefLL
 /*
  * MFM sectors have 32 bytes of 00's followed by two sync characters,
  * specified in the North Star MDS manual as 0xFBFB.
@@ -44,133 +44,143 @@ static const FluxPattern MFM_PATTERN(64, MFM_ID);
  */
 static const FluxPattern FM_PATTERN(64, FM_ID);
 
-const FluxMatchers ANY_SECTOR_PATTERN(
-	{
-		&MFM_PATTERN,
-		&FM_PATTERN,
-	}
-);
+const FluxMatchers ANY_SECTOR_PATTERN({
+    &MFM_PATTERN,
+    &FM_PATTERN,
+});
 
 /* Checksum is initially 0.
  * For each data byte, XOR with the current checksum.
  * Rotate checksum left, carrying bit 7 to bit 0.
  */
-uint8_t northstarChecksum(const Bytes& bytes) {
-	ByteReader br(bytes);
-	uint8_t checksum = 0;
+uint8_t northstarChecksum(const Bytes& bytes)
+{
+    ByteReader br(bytes);
+    uint8_t checksum = 0;
 
-	while (!br.eof()) {
-		checksum ^= br.read_8();
-		checksum = ((checksum << 1) | ((checksum >> 7)));
-	}
+    while (!br.eof())
+    {
+        checksum ^= br.read_8();
+        checksum = ((checksum << 1) | ((checksum >> 7)));
+    }
 
-	return checksum;
+    return checksum;
 }
 
 class NorthstarDecoder : public Decoder
 {
 public:
-	NorthstarDecoder(const DecoderProto& config):
-		Decoder(config),
-		_config(config.northstar())
-	{}
+    NorthstarDecoder(const DecoderProto& config):
+        Decoder(config),
+        _config(config.northstar())
+    {
+    }
 
-	/* Search for FM or MFM sector record */
-	nanoseconds_t advanceToNextRecord() override
-	{
-		nanoseconds_t now = tell().ns();
+    /* Search for FM or MFM sector record */
+    nanoseconds_t advanceToNextRecord() override
+    {
+        nanoseconds_t now = tell().ns();
 
-		/* For all but the first sector, seek to the next sector pulse.
-		 * The first sector does not contain the sector pulse in the fluxmap.
-		 */
-		if (now != 0) {
-			seekToIndexMark();
-			now = tell().ns();
-		}
+        /* For all but the first sector, seek to the next sector pulse.
+         * The first sector does not contain the sector pulse in the fluxmap.
+         */
+        if (now != 0)
+        {
+            seekToIndexMark();
+            now = tell().ns();
+        }
 
-		/* Discard a possible partial sector at the end of the track.
-		 * This partial sector could be mistaken for a conflicted sector, if
-		 * whatever data read happens to match the checksum of 0, which is
-		 * rare, but has been observed on some disks.
-		 */
-		if (now > (getFluxmapDuration() - 21e6)) {
-			seekToIndexMark();
-			return 0;
-		}
+        /* Discard a possible partial sector at the end of the track.
+         * This partial sector could be mistaken for a conflicted sector, if
+         * whatever data read happens to match the checksum of 0, which is
+         * rare, but has been observed on some disks.
+         */
+        if (now > (getFluxmapDuration() - 21e6))
+        {
+            seekToIndexMark();
+            return 0;
+        }
 
-		int msSinceIndex = std::round(now / 1e6);
+        int msSinceIndex = std::round(now / 1e6);
 
-		/* Note that the seekToPattern ignores the sector pulses, so if
-		 * a sector is not found for some reason, the seek will advance
-		 * past one or more sector pulses.  For this reason, calculate
-		 * _hardSectorId after the sector header is found.
-		 */
-		nanoseconds_t clock = seekToPattern(ANY_SECTOR_PATTERN);
-		_sector->headerStartTime = tell().ns();
+        /* Note that the seekToPattern ignores the sector pulses, so if
+         * a sector is not found for some reason, the seek will advance
+         * past one or more sector pulses.  For this reason, calculate
+         * _hardSectorId after the sector header is found.
+         */
+        nanoseconds_t clock = seekToPattern(ANY_SECTOR_PATTERN);
+        _sector->headerStartTime = tell().ns();
 
-		/* Discard a possible partial sector. */
-		if (_sector->headerStartTime > (getFluxmapDuration() - 21e6)) {
-			return 0;
-		}
+        /* Discard a possible partial sector. */
+        if (_sector->headerStartTime > (getFluxmapDuration() - 21e6))
+        {
+            return 0;
+        }
 
-		int sectorFoundTimeRaw = std::round(_sector->headerStartTime / 1e6);
-		int sectorFoundTime;
+        int sectorFoundTimeRaw = std::round(_sector->headerStartTime / 1e6);
+        int sectorFoundTime;
 
-		/* Round time to the nearest 20ms */
-		if ((sectorFoundTimeRaw % 20) < 10) {
-			sectorFoundTime = (sectorFoundTimeRaw / 20) * 20;
-		}
-		else {
-			sectorFoundTime = ((sectorFoundTimeRaw + 20) / 20) * 20;
-		}
+        /* Round time to the nearest 20ms */
+        if ((sectorFoundTimeRaw % 20) < 10)
+        {
+            sectorFoundTime = (sectorFoundTimeRaw / 20) * 20;
+        }
+        else
+        {
+            sectorFoundTime = ((sectorFoundTimeRaw + 20) / 20) * 20;
+        }
 
-		/* Calculate the sector ID based on time since the index */
-		_hardSectorId = (sectorFoundTime / 20) % 10;
+        /* Calculate the sector ID based on time since the index */
+        _hardSectorId = (sectorFoundTime / 20) % 10;
 
-		return clock;
-	}
+        return clock;
+    }
 
-	void decodeSectorRecord() override
-	{
-		uint64_t id = toBytes(readRawBits(64)).reader().read_be64();
-		unsigned recordSize, payloadSize, headerSize;
+    void decodeSectorRecord() override
+    {
+        uint64_t id = toBytes(readRawBits(64)).reader().read_be64();
+        unsigned recordSize, payloadSize, headerSize;
 
-		if (id == MFM_ID) {
-			recordSize = NORTHSTAR_ENCODED_SECTOR_SIZE_DD;
-			payloadSize = NORTHSTAR_PAYLOAD_SIZE_DD;
-			headerSize = NORTHSTAR_HEADER_SIZE_DD;
-		}
-		else {
-			recordSize = NORTHSTAR_ENCODED_SECTOR_SIZE_SD;
-			payloadSize = NORTHSTAR_PAYLOAD_SIZE_SD;
-			headerSize = NORTHSTAR_HEADER_SIZE_SD;
-		}
+        if (id == MFM_ID)
+        {
+            recordSize = NORTHSTAR_ENCODED_SECTOR_SIZE_DD;
+            payloadSize = NORTHSTAR_PAYLOAD_SIZE_DD;
+            headerSize = NORTHSTAR_HEADER_SIZE_DD;
+        }
+        else
+        {
+            recordSize = NORTHSTAR_ENCODED_SECTOR_SIZE_SD;
+            payloadSize = NORTHSTAR_PAYLOAD_SIZE_SD;
+            headerSize = NORTHSTAR_HEADER_SIZE_SD;
+        }
 
-		auto rawbits = readRawBits(recordSize * 16);
-		auto bytes = decodeFmMfm(rawbits).slice(0, recordSize);
-		ByteReader br(bytes);
+        auto rawbits = readRawBits(recordSize * 16);
+        auto bytes = decodeFmMfm(rawbits).slice(0, recordSize);
+        ByteReader br(bytes);
 
-		_sector->logicalSide = _sector->physicalSide;
-		_sector->logicalSector = _hardSectorId;
-		_sector->logicalTrack = _sector->physicalTrack;
+        _sector->logicalSide = _sector->physicalSide;
+        _sector->logicalSector = _hardSectorId;
+        _sector->logicalTrack = _sector->physicalTrack;
 
-		if (headerSize == NORTHSTAR_HEADER_SIZE_DD) {
-			br.read_8();	/* MFM second Sync char, usually 0xFB */
-		}
+        if (headerSize == NORTHSTAR_HEADER_SIZE_DD)
+        {
+            br.read_8(); /* MFM second Sync char, usually 0xFB */
+        }
 
-		_sector->data = br.read(payloadSize);
-		uint8_t wantChecksum = br.read_8();
-		uint8_t gotChecksum = northstarChecksum(bytes.slice(headerSize - 1, payloadSize));
-		_sector->status = (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
-	}
+        _sector->data = br.read(payloadSize);
+        uint8_t wantChecksum = br.read_8();
+        uint8_t gotChecksum =
+            northstarChecksum(bytes.slice(headerSize - 1, payloadSize));
+        _sector->status =
+            (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
+    }
 
 private:
-	const NorthstarDecoderProto& _config;
-	uint8_t _hardSectorId;
+    const NorthstarDecoderProto& _config;
+    uint8_t _hardSectorId;
 };
 
 std::unique_ptr<Decoder> createNorthstarDecoder(const DecoderProto& config)
 {
-	return std::unique_ptr<Decoder>(new NorthstarDecoder(config));
+    return std::unique_ptr<Decoder>(new NorthstarDecoder(config));
 }
-

arch/northstar/encoder.cc

@@ -1,10 +1,10 @@
-#include "globals.h"
+#include "lib/globals.h"
 #include "northstar.h"
-#include "sector.h"
-#include "bytes.h"
-#include "decoders/decoders.h"
-#include "encoders/encoders.h"
-#include "image.h"
+#include "lib/sector.h"
+#include "lib/bytes.h"
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
+#include "lib/image.h"
 #include "lib/encoders/encoders.pb.h"
 
 #define GAP_FILL_SIZE_SD 30
@@ -49,7 +49,7 @@ static void write_sector(std::vector<bool>& bits,
             doubleDensity = true;
             break;
         default:
-            Error() << "unsupported sector size --- you must pick 256 or 512";
+            error("unsupported sector size --- you must pick 256 or 512");
             break;
     }
 
@@ -96,9 +96,10 @@ static void write_sector(std::vector<bool>& bits,
             fullSector->push_back(GAP2_FILL_BYTE);
 
         if (fullSector->size() != fullSectorSize)
-            Error() << "sector mismatched length (" << sector->data.size()
-                    << ") expected: " << fullSector->size() << " got "
-                    << fullSectorSize;
+            error("sector mismatched length ({}); expected {}, got {}",
+                sector->data.size(),
+                fullSector->size(),
+                fullSectorSize);
     }
     else
     {
@@ -148,7 +149,7 @@ public:
             write_sector(bits, cursor, sectorData);
 
         if (cursor > bits.size())
-            Error() << "track data overrun";
+            error("track data overrun");
 
         std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
         fluxmap->appendBits(bits,
@@ -161,8 +162,7 @@ private:
     const NorthstarEncoderProto& _config;
 };
 
-std::unique_ptr<Encoder> createNorthstarEncoder(
-    const EncoderProto& config)
+std::unique_ptr<Encoder> createNorthstarEncoder(const EncoderProto& config)
 {
     return std::unique_ptr<Encoder>(new NorthstarEncoder(config));
 }

arch/northstar/northstar.h

@@ -1,7 +1,8 @@
 #ifndef NORTHSTAR_H
 #define NORTHSTAR_H
 
-/* Northstar floppies are 10-hard sectored disks with a sector format as follows:
+/* Northstar floppies are 10-hard sectored disks with a sector format as
+ * follows:
  *
  * |----------------------------------|
  * | SYNC Byte  | Payload  | Checksum |
@@ -12,15 +13,19 @@
  *
  */
 
-#define NORTHSTAR_PREAMBLE_SIZE_SD		(16)
-#define NORTHSTAR_PREAMBLE_SIZE_DD		(32)
-#define NORTHSTAR_HEADER_SIZE_SD		(1)
-#define NORTHSTAR_HEADER_SIZE_DD		(2)
-#define NORTHSTAR_PAYLOAD_SIZE_SD		(256)
-#define NORTHSTAR_PAYLOAD_SIZE_DD		(512)
-#define NORTHSTAR_CHECKSUM_SIZE		(1)
-#define NORTHSTAR_ENCODED_SECTOR_SIZE_SD	(NORTHSTAR_HEADER_SIZE_SD + NORTHSTAR_PAYLOAD_SIZE_SD + NORTHSTAR_CHECKSUM_SIZE)
-#define NORTHSTAR_ENCODED_SECTOR_SIZE_DD	(NORTHSTAR_HEADER_SIZE_DD + NORTHSTAR_PAYLOAD_SIZE_DD + NORTHSTAR_CHECKSUM_SIZE)
+#define NORTHSTAR_PREAMBLE_SIZE_SD (16)
+#define NORTHSTAR_PREAMBLE_SIZE_DD (32)
+#define NORTHSTAR_HEADER_SIZE_SD (1)
+#define NORTHSTAR_HEADER_SIZE_DD (2)
+#define NORTHSTAR_PAYLOAD_SIZE_SD (256)
+#define NORTHSTAR_PAYLOAD_SIZE_DD (512)
+#define NORTHSTAR_CHECKSUM_SIZE (1)
+#define NORTHSTAR_ENCODED_SECTOR_SIZE_SD                    \
+    (NORTHSTAR_HEADER_SIZE_SD + NORTHSTAR_PAYLOAD_SIZE_SD + \
+        NORTHSTAR_CHECKSUM_SIZE)
+#define NORTHSTAR_ENCODED_SECTOR_SIZE_DD                    \
+    (NORTHSTAR_HEADER_SIZE_DD + NORTHSTAR_PAYLOAD_SIZE_DD + \
+        NORTHSTAR_CHECKSUM_SIZE)
 
 class Decoder;
 class Encoder;
@@ -29,7 +34,9 @@ class DecoderProto;
 
 extern uint8_t northstarChecksum(const Bytes& bytes);
 
-extern std::unique_ptr<Decoder> createNorthstarDecoder(const DecoderProto& config);
-extern std::unique_ptr<Encoder> createNorthstarEncoder(const EncoderProto& config);
+extern std::unique_ptr<Decoder> createNorthstarDecoder(
+    const DecoderProto& config);
+extern std::unique_ptr<Encoder> createNorthstarEncoder(
+    const EncoderProto& config);
 
 #endif /* NORTHSTAR */

arch/rolandd20/decoder.cc

@@ -0,0 +1,51 @@
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
+#include "lib/crc.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
+#include "lib/sector.h"
+#include "lib/bytes.h"
+#include "rolandd20.h"
+#include <string.h>
+
+/* Sector header record:
+ *
+ * BF FF FF FF FF FF FE AB
+ *
+ * This encodes to:
+ *
+ *    e    d    5    5    5    5    5    5
+ * 1110 1101 0101 0101 0101 0101 0101 0101
+ *    5    5    5    5    5    5    5    5
+ * 0101 0101 0101 0101 0101 0101 0101 0101
+ *    5    5    5    5    5    5    5    5
+ * 0101 0101 0101 0101 0101 0101 0101 0101
+ *    5    5    5    4    4    4    4    5
+ * 0101 0101 0101 0100 0100 0100 0100 0101
+ */
+
+static const FluxPattern SECTOR_PATTERN(64, 0xed55555555555555LL);
+
+class RolandD20Decoder : public Decoder
+{
+public:
+    RolandD20Decoder(const DecoderProto& config): Decoder(config) {}
+
+    nanoseconds_t advanceToNextRecord() override
+    {
+        return seekToPattern(SECTOR_PATTERN);
+    }
+
+    void decodeSectorRecord() override
+    {
+        auto rawbits = readRawBits(256);
+        const auto& bytes = decodeFmMfm(rawbits);
+        fmt::print("{} ", _sector->clock);
+        hexdump(std::cout, bytes);
+    }
+};
+
+std::unique_ptr<Decoder> createRolandD20Decoder(const DecoderProto& config)
+{
+    return std::unique_ptr<Decoder>(new RolandD20Decoder(config));
+}

arch/rolandd20/rolandd20.h

@@ -0,0 +1,4 @@
+#pragma once
+
+extern std::unique_ptr<Decoder> createRolandD20Decoder(
+    const DecoderProto& config);

arch/rolandd20/rolandd20.proto

@@ -0,0 +1,5 @@
+syntax = "proto2";
+
+message RolandD20DecoderProto {}
+
+

arch/smaky6/decoder.cc

@@ -1,12 +1,12 @@
-#include "globals.h"
-#include "fluxmap.h"
-#include "decoders/fluxmapreader.h"
+#include "lib/globals.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "decoders/decoders.h"
-#include "sector.h"
+#include "lib/decoders/decoders.h"
+#include "lib/sector.h"
 #include "smaky6.h"
-#include "bytes.h"
-#include "crc.h"
+#include "lib/bytes.h"
+#include "lib/crc.h"
 #include "fmt/format.h"
 #include "lib/decoders/decoders.pb.h"
 #include <string.h>

arch/smaky6/smaky6.h

@@ -7,4 +7,3 @@
 extern std::unique_ptr<Decoder> createSmaky6Decoder(const DecoderProto& config);
 
 #endif
-

arch/smaky6/smaky6.proto

@@ -1,6 +1,4 @@
 syntax = "proto2";
 
-import "lib/common.proto";
-
 message Smaky6DecoderProto {}
 

arch/tartu/decoder.cc

@@ -0,0 +1,84 @@
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
+#include "arch/tartu/tartu.h"
+#include "lib/crc.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
+#include "lib/sector.h"
+#include <string.h>
+
+constexpr uint64_t HEADER_BITS = 0xaaaaaaaa44895554LL;
+constexpr uint64_t DATA_BITS =   0xaaaaaaaa44895545LL;
+
+static const FluxPattern HEADER_PATTERN(64, HEADER_BITS);
+static const FluxPattern DATA_PATTERN(64, DATA_BITS);
+
+const FluxMatchers ANY_RECORD_PATTERN {
+    &HEADER_PATTERN,
+    &DATA_PATTERN
+};
+
+class TartuDecoder : public Decoder
+{
+public:
+    TartuDecoder(const DecoderProto& config):
+        Decoder(config),
+        _config(config.tartu())
+    {
+    }
+
+    void beginTrack() override
+    {
+    }
+
+    nanoseconds_t advanceToNextRecord() override
+    {
+        return seekToPattern(ANY_RECORD_PATTERN);
+    }
+
+    void decodeSectorRecord() override
+    {
+        if (readRaw64() != HEADER_BITS)
+            return;
+
+        auto bits = readRawBits(16 * 4);
+        auto bytes = decodeFmMfm(bits).slice(0, 4);
+        
+        ByteReader br(bytes);
+        uint8_t track = br.read_8();
+        _sector->logicalTrack = track >> 1;
+        _sector->logicalSide = track & 1;
+        br.skip(1); /* seems always to be 1 */
+        _sector->logicalSector = br.read_8();
+        uint8_t wantChecksum = br.read_8();
+        uint8_t gotChecksum = ~sumBytes(bytes.slice(0, 3));
+        
+        if (wantChecksum == gotChecksum)
+            _sector->status = Sector::DATA_MISSING;
+
+        _sector->status = Sector::DATA_MISSING;
+    }
+
+    void decodeDataRecord() override
+    {
+        if (readRaw64() != DATA_BITS)
+            return;
+    
+        const auto& bits = readRawBits(129 * 16);
+        const auto& bytes = decodeFmMfm(bits).slice(0, 129);
+        _sector->data = bytes.slice(0, 128);
+
+        uint8_t wantChecksum = bytes.reader().seek(128).read_8();
+        uint8_t gotChecksum = ~sumBytes(_sector->data);
+        _sector->status = (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
+    }
+
+private:
+    const TartuDecoderProto& _config;
+};
+
+std::unique_ptr<Decoder> createTartuDecoder(const DecoderProto& config)
+{
+    return std::unique_ptr<Decoder>(new TartuDecoder(config));
+}
+

arch/tartu/encoder.cc

@@ -0,0 +1,114 @@
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
+#include "arch/tartu/tartu.h"
+#include "lib/crc.h"
+#include "lib/fluxmap.h"
+#include "lib/sector.h"
+#include <string.h>
+
+class TartuEncoder : public Encoder
+{
+public:
+    TartuEncoder(const EncoderProto& config):
+        Encoder(config),
+        _config(config.tartu())
+    {
+    }
+
+    std::unique_ptr<Fluxmap> encode(std::shared_ptr<const TrackInfo>& trackInfo,
+        const std::vector<std::shared_ptr<const Sector>>& sectors,
+        const Image& image) override
+    {
+        _clockRateUs = _config.clock_period_us();
+        int bitsPerRevolution =
+            (_config.target_rotational_period_ms() * 1000.0) / _clockRateUs;
+
+        const auto& sector = *sectors.begin();
+        _bits.resize(bitsPerRevolution);
+        _cursor = 0;
+
+        writeFillerRawBitsUs(_config.gap1_us());
+        bool first = true;
+        for (const auto& sectorData : sectors)
+        {
+            if (!first)
+                writeFillerRawBitsUs(_config.gap4_us());
+            first = false;
+            writeSector(sectorData);
+        }
+
+        if (_cursor > _bits.size())
+            error("track data overrun");
+        writeFillerRawBitsUs(_config.target_rotational_period_ms() * 1000.0);
+
+        std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
+        fluxmap->appendBits(_bits,
+            calculatePhysicalClockPeriod(_clockRateUs * 1e3,
+                _config.target_rotational_period_ms() * 1e6));
+        return fluxmap;
+    }
+
+private:
+    void writeBytes(const Bytes& bytes)
+    {
+        encodeMfm(_bits, _cursor, bytes, _lastBit);
+    }
+
+    void writeRawBits(uint64_t data, int width)
+    {
+        _cursor += width;
+        _lastBit = data & 1;
+        for (int i = 0; i < width; i++)
+        {
+            unsigned pos = _cursor - i - 1;
+            if (pos < _bits.size())
+                _bits[pos] = data & 1;
+            data >>= 1;
+        }
+    }
+
+    void writeFillerRawBitsUs(double us)
+    {
+        unsigned count = (us / _clockRateUs) / 2;
+        for (int i = 0; i < count; i++)
+            writeRawBits(0b10, 2);
+    };
+
+    void writeSector(const std::shared_ptr<const Sector>& sectorData)
+    {
+        writeRawBits(_config.header_marker(), 64);
+        {
+            Bytes bytes;
+            ByteWriter bw(bytes);
+            bw.write_8(
+                (sectorData->logicalTrack << 1) | sectorData->logicalSide);
+            bw.write_8(1);
+            bw.write_8(sectorData->logicalSector);
+            bw.write_8(~sumBytes(bytes.slice(0, 3)));
+            writeBytes(bytes);
+        }
+
+        writeFillerRawBitsUs(_config.gap3_us());
+        writeRawBits(_config.data_marker(), 64);
+        {
+            Bytes bytes;
+            ByteWriter bw(bytes);
+            bw.append(sectorData->data);
+            bw.write_8(~sumBytes(bytes.slice(0, sectorData->data.size())));
+            writeBytes(bytes);
+        }
+    }
+
+private:
+    const TartuEncoderProto& _config;
+    double _clockRateUs;
+    std::vector<bool> _bits;
+    unsigned _cursor;
+    bool _lastBit;
+};
+
+std::unique_ptr<Encoder> createTartuEncoder(const EncoderProto& config)
+{
+    return std::unique_ptr<Encoder>(new TartuEncoder(config));
+}

arch/tartu/tartu.h

@@ -0,0 +1,8 @@
+#ifndef TARTU_H
+#define TARTU_H
+
+extern std::unique_ptr<Decoder> createTartuDecoder(const DecoderProto& config);
+extern std::unique_ptr<Encoder> createTartuEncoder(const EncoderProto& config);
+
+#endif
+

arch/tartu/tartu.proto

@@ -0,0 +1,27 @@
+syntax = "proto2";
+
+import "lib/common.proto";
+
+message TartuDecoderProto {}
+
+message TartuEncoderProto {
+    optional double clock_period_us = 1
+        [ default = 2.0, (help) = "clock rate on the real device (for MFM)" ];
+    optional double target_rotational_period_ms = 2
+        [ default=200, (help) = "rotational period of target disk" ];
+    optional double gap1_us = 3
+        [ default = 1200,
+          (help) = "size of gap 1 (the post-index gap)" ];
+    optional double gap3_us = 4
+        [ default = 150,
+          (help) = "size of gap 3 (the pre-data gap)" ];
+    optional double gap4_us = 5
+        [ default = 180,
+          (help) = "size of gap 4 (the post-data or format gap)" ];
+    optional uint64 header_marker = 6
+        [ default = 0xaaaaaaaa44895554,
+          (help) = "64-bit raw bit pattern of header record marker" ];
+    optional uint64 data_marker = 7
+        [ default = 0xaaaaaaaa44895545,
+          (help) = "64-bit raw bit pattern of data record marker" ];
+}

arch/tids990/decoder.cc

@@ -1,11 +1,11 @@
-#include "globals.h"
-#include "decoders/decoders.h"
-#include "encoders/encoders.h"
-#include "tids990/tids990.h"
-#include "crc.h"
-#include "fluxmap.h"
-#include "decoders/fluxmapreader.h"
-#include "sector.h"
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
+#include "arch/tids990/tids990.h"
+#include "lib/crc.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
+#include "lib/sector.h"
 #include <string.h>
 #include <fmt/format.h>
 
@@ -38,61 +38,63 @@ const FluxPattern SECTOR_RECORD_PATTERN(32, 0x11112244);
 const uint16_t DATA_ID = 0x550b;
 const FluxPattern DATA_RECORD_PATTERN(32, 0x11112245);
 
-const FluxMatchers ANY_RECORD_PATTERN({ &SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN });
+const FluxMatchers ANY_RECORD_PATTERN(
+    {&SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN});
 
 class Tids990Decoder : public Decoder
 {
 public:
-	Tids990Decoder(const DecoderProto& config):
-		Decoder(config)
-	{}
+    Tids990Decoder(const DecoderProto& config): Decoder(config) {}
 
     nanoseconds_t advanceToNextRecord() override
-	{
-		return seekToPattern(ANY_RECORD_PATTERN);
-	}
+    {
+        return seekToPattern(ANY_RECORD_PATTERN);
+    }
 
     void decodeSectorRecord() override
-	{
-		auto bits = readRawBits(TIDS990_SECTOR_RECORD_SIZE*16);
-		auto bytes = decodeFmMfm(bits).slice(0, TIDS990_SECTOR_RECORD_SIZE);
+    {
+        auto bits = readRawBits(TIDS990_SECTOR_RECORD_SIZE * 16);
+        auto bytes = decodeFmMfm(bits).slice(0, TIDS990_SECTOR_RECORD_SIZE);
 
-		ByteReader br(bytes);
-		if (br.read_be16() != SECTOR_ID)
-			return;
+        ByteReader br(bytes);
+        if (br.read_be16() != SECTOR_ID)
+            return;
 
-		uint16_t gotChecksum = crc16(CCITT_POLY, bytes.slice(1, TIDS990_SECTOR_RECORD_SIZE-3));
+        uint16_t gotChecksum =
+            crc16(CCITT_POLY, bytes.slice(1, TIDS990_SECTOR_RECORD_SIZE - 3));
 
-		_sector->logicalSide = br.read_8() >> 3;
-		_sector->logicalTrack = br.read_8();
-		br.read_8(); /* number of sectors per track */
-		_sector->logicalSector = br.read_8();
-		br.read_be16(); /* sector size */
-		uint16_t wantChecksum = br.read_be16();
+        _sector->logicalSide = br.read_8() >> 3;
+        _sector->logicalTrack = br.read_8();
+        br.read_8(); /* number of sectors per track */
+        _sector->logicalSector = br.read_8();
+        br.read_be16(); /* sector size */
+        uint16_t wantChecksum = br.read_be16();
 
-		if (wantChecksum == gotChecksum)
-			_sector->status = Sector::DATA_MISSING; /* correct but unintuitive */
-	}
+        if (wantChecksum == gotChecksum)
+            _sector->status =
+                Sector::DATA_MISSING; /* correct but unintuitive */
+    }
 
-	void decodeDataRecord() override
-	{
-		auto bits = readRawBits(TIDS990_DATA_RECORD_SIZE*16);
-		auto bytes = decodeFmMfm(bits).slice(0, TIDS990_DATA_RECORD_SIZE);
+    void decodeDataRecord() override
+    {
+        auto bits = readRawBits(TIDS990_DATA_RECORD_SIZE * 16);
+        auto bytes = decodeFmMfm(bits).slice(0, TIDS990_DATA_RECORD_SIZE);
 
-		ByteReader br(bytes);
-		if (br.read_be16() != DATA_ID)
-			return;
+        ByteReader br(bytes);
+        if (br.read_be16() != DATA_ID)
+            return;
 
-		uint16_t gotChecksum = crc16(CCITT_POLY, bytes.slice(1, TIDS990_DATA_RECORD_SIZE-3));
+        uint16_t gotChecksum =
+            crc16(CCITT_POLY, bytes.slice(1, TIDS990_DATA_RECORD_SIZE - 3));
 
-		_sector->data = br.read(TIDS990_PAYLOAD_SIZE);
-		uint16_t wantChecksum = br.read_be16();
-		_sector->status = (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
-	}
+        _sector->data = br.read(TIDS990_PAYLOAD_SIZE);
+        uint16_t wantChecksum = br.read_be16();
+        _sector->status =
+            (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
+    }
 };
 
 std::unique_ptr<Decoder> createTids990Decoder(const DecoderProto& config)
 {
-	return std::unique_ptr<Decoder>(new Tids990Decoder(config));
+    return std::unique_ptr<Decoder>(new Tids990Decoder(config));
 }
-

arch/tids990/encoder.cc

@@ -1,10 +1,10 @@
-#include "globals.h"
-#include "decoders/decoders.h"
-#include "encoders/encoders.h"
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
 #include "tids990.h"
-#include "crc.h"
-#include "readerwriter.h"
-#include "image.h"
+#include "lib/crc.h"
+#include "lib/readerwriter.h"
+#include "lib/image.h"
 #include "arch/tids990/tids990.pb.h"
 #include "lib/encoders/encoders.pb.h"
 #include <fmt/format.h>
@@ -127,14 +127,14 @@ public:
         }
 
         if (_cursor >= _bits.size())
-            Error() << "track data overrun";
+            error("track data overrun");
         while (_cursor < _bits.size())
             writeBytes(1, 0x55);
 
         auto fluxmap = std::make_unique<Fluxmap>();
         fluxmap->appendBits(_bits,
-            calculatePhysicalClockPeriod(clockRateUs * 1e3,
-                _config.rotational_period_ms() * 1e6));
+            calculatePhysicalClockPeriod(
+                clockRateUs * 1e3, _config.rotational_period_ms() * 1e6));
         return fluxmap;
     }
 
@@ -145,8 +145,7 @@ private:
     bool _lastBit;
 };
 
-std::unique_ptr<Encoder> createTids990Encoder(
-    const EncoderProto& config)
+std::unique_ptr<Encoder> createTids990Encoder(const EncoderProto& config)
 {
     return std::unique_ptr<Encoder>(new Tids990Encoder(config));
 }

arch/tids990/tids990.h

@@ -1,18 +1,18 @@
 #ifndef TIDS990_H
 #define TIDS990_H
 
-#define TIDS990_PAYLOAD_SIZE       288 /* bytes */
-#define TIDS990_SECTOR_RECORD_SIZE 10 /* bytes */
-#define TIDS990_DATA_RECORD_SIZE   (TIDS990_PAYLOAD_SIZE + 4) /* bytes */
+#define TIDS990_PAYLOAD_SIZE 288                            /* bytes */
+#define TIDS990_SECTOR_RECORD_SIZE 10                       /* bytes */
+#define TIDS990_DATA_RECORD_SIZE (TIDS990_PAYLOAD_SIZE + 4) /* bytes */
 
 class Encoder;
 class Decoder;
 class DecoderProto;
 class EncoderProto;
 
-extern std::unique_ptr<Decoder> createTids990Decoder(const DecoderProto& config);
-extern std::unique_ptr<Encoder> createTids990Encoder(const EncoderProto& config);
+extern std::unique_ptr<Decoder> createTids990Decoder(
+    const DecoderProto& config);
+extern std::unique_ptr<Encoder> createTids990Encoder(
+    const EncoderProto& config);
 
 #endif
-
-

arch/victor9k/decoder.cc

@@ -1,28 +1,30 @@
-#include "globals.h"
-#include "fluxmap.h"
-#include "decoders/fluxmapreader.h"
+#include "lib/globals.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "decoders/decoders.h"
-#include "sector.h"
+#include "lib/decoders/decoders.h"
+#include "lib/sector.h"
 #include "victor9k.h"
-#include "crc.h"
-#include "bytes.h"
+#include "lib/crc.h"
+#include "lib/bytes.h"
 #include "fmt/format.h"
 #include <string.h>
 #include <algorithm>
 
 const FluxPattern SECTOR_RECORD_PATTERN(32, VICTOR9K_SECTOR_RECORD);
 const FluxPattern DATA_RECORD_PATTERN(32, VICTOR9K_DATA_RECORD);
-const FluxMatchers ANY_RECORD_PATTERN({ &SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN });
+const FluxMatchers ANY_RECORD_PATTERN(
+    {&SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN});
 
 static int decode_data_gcr(uint8_t gcr)
 {
     switch (gcr)
     {
-		#define GCR_ENTRY(gcr, data) \
-			case gcr: return data;
-		#include "data_gcr.h"
-		#undef GCR_ENTRY
+#define GCR_ENTRY(gcr, data) \
+    case gcr:                \
+        return data;
+#include "data_gcr.h"
+#undef GCR_ENTRY
     }
     return -1;
 }
@@ -37,11 +39,11 @@ static Bytes decode(const std::vector<bool>& bits)
     while (ii != bits.end())
     {
         uint8_t inputfifo = 0;
-        for (size_t i=0; i<5; i++)
+        for (size_t i = 0; i < 5; i++)
         {
             if (ii == bits.end())
                 break;
-            inputfifo = (inputfifo<<1) | *ii++;
+            inputfifo = (inputfifo << 1) | *ii++;
         }
 
         uint8_t decoded = decode_data_gcr(inputfifo);
@@ -55,63 +57,62 @@ static Bytes decode(const std::vector<bool>& bits)
 class Victor9kDecoder : public Decoder
 {
 public:
-	Victor9kDecoder(const DecoderProto& config):
-		Decoder(config)
-	{}
+    Victor9kDecoder(const DecoderProto& config): Decoder(config) {}
 
     nanoseconds_t advanceToNextRecord() override
-	{
-		return seekToPattern(ANY_RECORD_PATTERN);
-	}
+    {
+        return seekToPattern(ANY_RECORD_PATTERN);
+    }
 
     void decodeSectorRecord() override
-	{
-		/* Check the ID. */
+    {
+        /* Check the ID. */
 
-		if (readRaw32() != VICTOR9K_SECTOR_RECORD)
-			return;
+        if (readRaw32() != VICTOR9K_SECTOR_RECORD)
+            return;
 
-		/* Read header. */
+        /* Read header. */
 
-		auto bytes = decode(readRawBits(3*10)).slice(0, 3);
+        auto bytes = decode(readRawBits(3 * 10)).slice(0, 3);
 
-		uint8_t rawTrack = bytes[0];
-		_sector->logicalSector = bytes[1];
-		uint8_t gotChecksum = bytes[2];
+        uint8_t rawTrack = bytes[0];
+        _sector->logicalSector = bytes[1];
+        uint8_t gotChecksum = bytes[2];
 
-		_sector->logicalTrack = rawTrack & 0x7f;
-		_sector->logicalSide = rawTrack >> 7;
-		uint8_t wantChecksum = bytes[0] + bytes[1];
-		if ((_sector->logicalSector > 20) || (_sector->logicalTrack > 85) || (_sector->logicalSide > 1))
-			return;
-					
-		if (wantChecksum == gotChecksum)
-			_sector->status = Sector::DATA_MISSING; /* unintuitive but correct */
-	}
+        _sector->logicalTrack = rawTrack & 0x7f;
+        _sector->logicalSide = rawTrack >> 7;
+        uint8_t wantChecksum = bytes[0] + bytes[1];
+        if ((_sector->logicalSector > 20) || (_sector->logicalTrack > 85) ||
+            (_sector->logicalSide > 1))
+            return;
+
+        if (wantChecksum == gotChecksum)
+            _sector->status =
+                Sector::DATA_MISSING; /* unintuitive but correct */
+    }
 
     void decodeDataRecord() override
-	{
-		/* Check the ID. */
+    {
+        /* Check the ID. */
 
-		if (readRaw32() != VICTOR9K_DATA_RECORD)
-			return;
+        if (readRaw32() != VICTOR9K_DATA_RECORD)
+            return;
 
-		/* Read data. */
+        /* Read data. */
 
-		auto bytes = decode(readRawBits((VICTOR9K_SECTOR_LENGTH+4)*10))
-			.slice(0, VICTOR9K_SECTOR_LENGTH+4);
-		ByteReader br(bytes);
+        auto bytes = decode(readRawBits((VICTOR9K_SECTOR_LENGTH + 4) * 10))
+                         .slice(0, VICTOR9K_SECTOR_LENGTH + 4);
+        ByteReader br(bytes);
 
-		_sector->data = br.read(VICTOR9K_SECTOR_LENGTH);
-		uint16_t gotChecksum = sumBytes(_sector->data);
-		uint16_t wantChecksum = br.read_le16();
-		_sector->status = (gotChecksum == wantChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
-	}
+        _sector->data = br.read(VICTOR9K_SECTOR_LENGTH);
+        uint16_t gotChecksum = sumBytes(_sector->data);
+        uint16_t wantChecksum = br.read_le16();
+        _sector->status =
+            (gotChecksum == wantChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
+    }
 };
 
 std::unique_ptr<Decoder> createVictor9kDecoder(const DecoderProto& config)
 {
-	return std::unique_ptr<Decoder>(new Victor9kDecoder(config));
+    return std::unique_ptr<Decoder>(new Victor9kDecoder(config));
 }
-
-

arch/victor9k/encoder.cc

@@ -1,17 +1,17 @@
-#include "globals.h"
-#include "decoders/decoders.h"
-#include "encoders/encoders.h"
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
 #include "victor9k.h"
-#include "crc.h"
-#include "sector.h"
-#include "readerwriter.h"
-#include "image.h"
+#include "lib/crc.h"
+#include "lib/sector.h"
+#include "lib/readerwriter.h"
+#include "lib/image.h"
 #include "fmt/format.h"
 #include "arch/victor9k/victor9k.pb.h"
 #include "lib/encoders/encoders.pb.h"
 #include "lib/layout.h"
 #include <ctype.h>
-#include "bytes.h"
+#include "lib/bytes.h"
 
 static bool lastBit;
 
@@ -169,14 +169,15 @@ public:
         const Image& image) override
     {
         Victor9kEncoderProto::TrackdataProto trackdata;
-        getTrackFormat(trackdata, trackInfo->logicalTrack, trackInfo->logicalSide);
+        getTrackFormat(
+            trackdata, trackInfo->logicalTrack, trackInfo->logicalSide);
 
         unsigned bitsPerRevolution = (trackdata.rotational_period_ms() * 1e3) /
                                      trackdata.clock_period_us();
         std::vector<bool> bits(bitsPerRevolution);
-        nanoseconds_t clockPeriod = calculatePhysicalClockPeriod(
-            trackdata.clock_period_us() * 1e3,
-            trackdata.rotational_period_ms() * 1e6);
+        nanoseconds_t clockPeriod =
+            calculatePhysicalClockPeriod(trackdata.clock_period_us() * 1e3,
+                trackdata.rotational_period_ms() * 1e6);
         unsigned cursor = 0;
 
         fillBitmapTo(bits,
@@ -189,8 +190,7 @@ public:
             write_sector(bits, cursor, trackdata, *sector);
 
         if (cursor >= bits.size())
-            Error() << fmt::format(
-                "track data overrun by {} bits", cursor - bits.size());
+            error("track data overrun by {} bits", cursor - bits.size());
         fillBitmapTo(bits, cursor, bits.size(), {true, false});
 
         std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
@@ -202,8 +202,7 @@ private:
     const Victor9kEncoderProto& _config;
 };
 
-std::unique_ptr<Encoder> createVictor9kEncoder(
-    const EncoderProto& config)
+std::unique_ptr<Encoder> createVictor9kEncoder(const EncoderProto& config)
 {
     return std::unique_ptr<Encoder>(new Victor9kEncoder(config));
 }

arch/victor9k/victor9k.h

@@ -13,12 +13,14 @@ class DecoderProto;
 
 /* ... 1101 0100 1001
  *       ^^ ^^^^ ^^^^ ten bit IO byte */
-#define VICTOR9K_DATA_RECORD   0xfffffd49
+#define VICTOR9K_DATA_RECORD 0xfffffd49
 #define VICTOR9K_DATA_ID 0x8
 
 #define VICTOR9K_SECTOR_LENGTH 512
 
-extern std::unique_ptr<Decoder> createVictor9kDecoder(const DecoderProto& config);
-extern std::unique_ptr<Encoder> createVictor9kEncoder(const EncoderProto& config);
+extern std::unique_ptr<Decoder> createVictor9kDecoder(
+    const DecoderProto& config);
+extern std::unique_ptr<Encoder> createVictor9kEncoder(
+    const EncoderProto& config);
 
 #endif

arch/zilogmcz/decoder.cc

@@ -1,12 +1,12 @@
-#include "globals.h"
-#include "fluxmap.h"
-#include "decoders/fluxmapreader.h"
+#include "lib/globals.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "decoders/decoders.h"
-#include "sector.h"
+#include "lib/decoders/decoders.h"
+#include "lib/sector.h"
 #include "zilogmcz.h"
-#include "bytes.h"
-#include "crc.h"
+#include "lib/bytes.h"
+#include "lib/crc.h"
 #include "fmt/format.h"
 #include <string.h>
 #include <algorithm>
@@ -16,42 +16,40 @@ static const FluxPattern SECTOR_START_PATTERN(16, 0xaaab);
 class ZilogMczDecoder : public Decoder
 {
 public:
-	ZilogMczDecoder(const DecoderProto& config):
-		Decoder(config)
-	{}
+    ZilogMczDecoder(const DecoderProto& config): Decoder(config) {}
 
     nanoseconds_t advanceToNextRecord() override
-	{
-		seekToIndexMark();
-		return seekToPattern(SECTOR_START_PATTERN);
-	}
+    {
+        seekToIndexMark();
+        return seekToPattern(SECTOR_START_PATTERN);
+    }
 
     void decodeSectorRecord() override
-	{
-		readRawBits(14);
+    {
+        readRawBits(14);
 
-		auto rawbits = readRawBits(140*16);
-		auto bytes = decodeFmMfm(rawbits).slice(0, 140);
-		ByteReader br(bytes);
+        auto rawbits = readRawBits(140 * 16);
+        auto bytes = decodeFmMfm(rawbits).slice(0, 140);
+        ByteReader br(bytes);
 
-		_sector->logicalSector = br.read_8() & 0x1f;
-		_sector->logicalSide = 0;
-		_sector->logicalTrack = br.read_8() & 0x7f;
-		if (_sector->logicalSector > 31)
-			return;
-		if (_sector->logicalTrack > 80)
-			return;
+        _sector->logicalSector = br.read_8() & 0x1f;
+        _sector->logicalSide = 0;
+        _sector->logicalTrack = br.read_8() & 0x7f;
+        if (_sector->logicalSector > 31)
+            return;
+        if (_sector->logicalTrack > 80)
+            return;
 
-		_sector->data = br.read(132);
-		uint16_t wantChecksum = br.read_be16();
-		uint16_t gotChecksum = crc16(MODBUS_POLY, 0x0000, bytes.slice(0, 134));
+        _sector->data = br.read(132);
+        uint16_t wantChecksum = br.read_be16();
+        uint16_t gotChecksum = crc16(MODBUS_POLY, 0x0000, bytes.slice(0, 134));
 
-		_sector->status = (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
-	}
+        _sector->status =
+            (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
+    }
 };
 
 std::unique_ptr<Decoder> createZilogMczDecoder(const DecoderProto& config)
 {
-	return std::unique_ptr<Decoder>(new ZilogMczDecoder(config));
+    return std::unique_ptr<Decoder>(new ZilogMczDecoder(config));
 }
-

arch/zilogmcz/zilogmcz.h

@@ -1,8 +1,7 @@
 #ifndef ZILOGMCZ_H
 #define ZILOGMCZ_H
 
-extern std::unique_ptr<Decoder> createZilogMczDecoder(const DecoderProto& config);
+extern std::unique_ptr<Decoder> createZilogMczDecoder(
+    const DecoderProto& config);
 
 #endif
-
-

build.lua

@@ -1,192 +0,0 @@
-vars.cflags = { "$(CFLAGS)" }
-vars.cxxflags = { "$(CXXFLAGS)" }
-vars.ldflags = { "-pthread" }
-
-include "build/protobuf.lua"
-include "build/dependency.lua"
-include "build/tests.lua"
-
-dependency {
-	name = "fmt_dep",
-	pkg_config = "fmt",
-}
-
-dependency {
-	name = "stb_dep",
-	pkg_config = "stb",
-	fallback = "dep/stb+stb"
-}
-
-dependency {
-	name = "protobuf_dep",
-	pkg_config = "protobuf"
-}
-
-dependency {
-	name = "zlib_dep",
-	pkg_config = "zlib"
-}
-
-proto_cc_library {
-	name = "config_lib",
-	srcs = {
-		"./lib/common.proto",
-		"./lib/config.proto",
-		"./lib/decoders/decoders.proto",
-		"./lib/drive.proto",
-		"./lib/encoders/encoders.proto",
-		"./lib/fl2.proto",
-		"./lib/fluxsink/fluxsink.proto",
-		"./lib/fluxsource/fluxsource.proto",
-		"./lib/imagereader/imagereader.proto",
-		"./lib/imagewriter/imagewriter.proto",
-		"./lib/mapper.proto",
-		"./lib/usb/usb.proto",
-		"./arch/aeslanier/aeslanier.proto",
-		"./arch/agat/agat.proto",
-		"./arch/amiga/amiga.proto",
-		"./arch/apple2/apple2.proto",
-		"./arch/brother/brother.proto",
-		"./arch/c64/c64.proto",
-		"./arch/f85/f85.proto",
-		"./arch/fb100/fb100.proto",
-		"./arch/ibm/ibm.proto",
-		"./arch/macintosh/macintosh.proto",
-		"./arch/micropolis/micropolis.proto",
-		"./arch/mx/mx.proto",
-		"./arch/northstar/northstar.proto",
-		"./arch/tids990/tids990.proto",
-		"./arch/victor9k/victor9k.proto",
-		"./arch/zilogmcz/zilogmcz.proto",
-	}
-}
-
-clibrary {
-	name = "protocol_lib",
-	hdrs = { "./protocol.h" }
-}
-
-clibrary {
-	name = "libfluxengine",
-	srcs = {
-		"./arch/aeslanier/decoder.cc",
-		"./arch/agat/agat.cc",
-		"./arch/agat/decoder.cc",
-		"./arch/amiga/amiga.cc",
-		"./arch/amiga/decoder.cc",
-		"./arch/amiga/encoder.cc",
-		"./arch/apple2/decoder.cc",
-		"./arch/apple2/encoder.cc",
-		"./arch/brother/decoder.cc",
-		"./arch/brother/encoder.cc",
-		"./arch/c64/c64.cc",
-		"./arch/c64/decoder.cc",
-		"./arch/c64/encoder.cc",
-		"./arch/f85/decoder.cc",
-		"./arch/fb100/decoder.cc",
-		"./arch/ibm/decoder.cc",
-		"./arch/ibm/encoder.cc",
-		"./arch/macintosh/decoder.cc",
-		"./arch/macintosh/encoder.cc",
-		"./arch/micropolis/decoder.cc",
-		"./arch/micropolis/encoder.cc",
-		"./arch/mx/decoder.cc",
-		"./arch/northstar/decoder.cc",
-		"./arch/northstar/encoder.cc",
-		"./arch/tids990/decoder.cc",
-		"./arch/tids990/encoder.cc",
-		"./arch/victor9k/decoder.cc",
-		"./arch/victor9k/encoder.cc",
-		"./arch/zilogmcz/decoder.cc",
-		"./lib/bitmap.cc",
-		"./lib/bytes.cc",
-		"./lib/crc.cc",
-		"./lib/csvreader.cc",
-		"./lib/decoders/decoders.cc",
-		"./lib/decoders/fluxdecoder.cc",
-		"./lib/decoders/fluxmapreader.cc",
-		"./lib/decoders/fmmfm.cc",
-		"./lib/encoders/encoders.cc",
-		"./lib/flags.cc",
-		"./lib/fluxmap.cc",
-		"./lib/fluxsink/aufluxsink.cc",
-		"./lib/fluxsink/fl2fluxsink.cc",
-		"./lib/fluxsink/fluxsink.cc",
-		"./lib/fluxsink/hardwarefluxsink.cc",
-		"./lib/fluxsink/scpfluxsink.cc",
-		"./lib/fluxsink/vcdfluxsink.cc",
-		"./lib/fluxsource/cwffluxsource.cc",
-		"./lib/fluxsource/erasefluxsource.cc",
-		"./lib/fluxsource/fl2fluxsource.cc",
-		"./lib/fluxsource/fluxsource.cc",
-		"./lib/fluxsource/hardwarefluxsource.cc",
-		"./lib/fluxsource/kryoflux.cc",
-		"./lib/fluxsource/kryofluxfluxsource.cc",
-		"./lib/fluxsource/scpfluxsource.cc",
-		"./lib/fluxsource/testpatternfluxsource.cc",
-		"./lib/globals.cc",
-		"./lib/hexdump.cc",
-		"./lib/image.cc",
-		"./lib/imagereader/d64imagereader.cc",
-		"./lib/imagereader/d88imagereader.cc",
-		"./lib/imagereader/dimimagereader.cc",
-		"./lib/imagereader/diskcopyimagereader.cc",
-		"./lib/imagereader/fdiimagereader.cc",
-		"./lib/imagereader/imagereader.cc",
-		"./lib/imagereader/imdimagereader.cc",
-		"./lib/imagereader/imgimagereader.cc",
-		"./lib/imagereader/jv3imagereader.cc",
-		"./lib/imagereader/nfdimagereader.cc",
-		"./lib/imagereader/nsiimagereader.cc",
-		"./lib/imagereader/td0imagereader.cc",
-		"./lib/imagewriter/d64imagewriter.cc",
-		"./lib/imagewriter/d88imagewriter.cc",
-		"./lib/imagewriter/diskcopyimagewriter.cc",
-		"./lib/imagewriter/imagewriter.cc",
-		"./lib/imagewriter/imgimagewriter.cc",
-		"./lib/imagewriter/ldbsimagewriter.cc",
-		"./lib/imagewriter/nsiimagewriter.cc",
-		"./lib/imagewriter/rawimagewriter.cc",
-		"./lib/imginputoutpututils.cc",
-		"./lib/ldbs.cc",
-		"./lib/logger.cc",
-		"./lib/mapper.cc",
-		"./lib/proto.cc",
-		"./lib/readerwriter.cc",
-		"./lib/sector.cc",
-		"./lib/usb/fluxengineusb.cc",
-		"./lib/usb/greaseweazle.cc",
-		"./lib/usb/greaseweazleusb.cc",
-		"./lib/usb/serial.cc",
-		"./lib/usb/usb.cc",
-		"./lib/usb/usbfinder.cc",
-		"./lib/utils.cc",
-		"protocol.h",
-	},
-	deps = {
-		"+config_lib",
-		"+protocol_lib",
-		"+fmt_dep",
-		"+protobuf_dep",
-		"+zlib_dep",
-		"dep/libusbp+libusbp",
-	},
-	dep_cflags = { "-Ilib", "-Iarch", "-I." },
-	vars = {
-		["+cflags"] = { "-Ilib", "-Iarch", "-I." }
-	}
-}
-
-installable {
-	name = "all",
-	map = {
-		["fluxengine"] = "src+fluxengine",
-		["fluxengine-gui"] = "src/gui+fluxengine",
-		["brother120tool"] = "tools+brother120tool",
-		["brother240tool"] = "tools+brother240tool",
-		["upgrade-flux-file"] = "tools+upgrade-flux-file",
-	}
-}
-
-include "tests/build.lua"
-

build.py

@@ -0,0 +1,325 @@
+from build.ab import export
+from build.c import clibrary, cxxlibrary
+from build.protobuf import proto, protocc
+from build.pkg import package, hostpackage
+from build.utils import test
+from glob import glob
+import config
+import re
+
+package(name="protobuf_lib", package="protobuf")
+package(name="z_lib", package="zlib")
+package(name="fmt_lib", package="fmt", fallback="dep/fmt")
+package(name="sqlite3_lib", package="sqlite3")
+
+hostpackage(name="protobuf_host_lib", package="protobuf")
+hostpackage(name="z_host_lib", package="zlib")
+hostpackage(name="fmt_host_lib", package="fmt")
+hostpackage(name="sqlite3_host_lib", package="sqlite3")
+
+clibrary(name="protocol", hdrs={"protocol.h": "./protocol.h"})
+
+proto(name="fl2_proto", srcs=["lib/fl2.proto"])
+protocc(name="fl2_proto_lib", srcs=["+fl2_proto"])
+
+cxxlibrary(
+    name="lib",
+    srcs=[
+        "./lib/bitmap.cc",
+        "./lib/bytes.cc",
+        "./lib/config.cc",
+        "./lib/crc.cc",
+        "./lib/csvreader.cc",
+        "./lib/decoders/decoders.cc",
+        "./lib/decoders/fluxdecoder.cc",
+        "./lib/decoders/fluxmapreader.cc",
+        "./lib/decoders/fmmfm.cc",
+        "./lib/encoders/encoders.cc",
+        "./lib/fl2.cc",
+        "./lib/flags.cc",
+        "./lib/fluxmap.cc",
+        "./lib/fluxsink/a2rfluxsink.cc",
+        "./lib/fluxsink/aufluxsink.cc",
+        "./lib/fluxsink/fl2fluxsink.cc",
+        "./lib/fluxsink/fluxsink.cc",
+        "./lib/fluxsink/hardwarefluxsink.cc",
+        "./lib/fluxsink/scpfluxsink.cc",
+        "./lib/fluxsink/vcdfluxsink.cc",
+        "./lib/fluxsource/a2rfluxsource.cc",
+        "./lib/fluxsource/catweasel.cc",
+        "./lib/fluxsource/cwffluxsource.cc",
+        "./lib/fluxsource/dmkfluxsource.cc",
+        "./lib/fluxsource/erasefluxsource.cc",
+        "./lib/fluxsource/fl2fluxsource.cc",
+        "./lib/fluxsource/fluxsource.cc",
+        "./lib/fluxsource/flx.cc",
+        "./lib/fluxsource/flxfluxsource.cc",
+        "./lib/fluxsource/hardwarefluxsource.cc",
+        "./lib/fluxsource/kryoflux.cc",
+        "./lib/fluxsource/kryofluxfluxsource.cc",
+        "./lib/fluxsource/memoryfluxsource.cc",
+        "./lib/fluxsource/scpfluxsource.cc",
+        "./lib/fluxsource/testpatternfluxsource.cc",
+        "./lib/globals.cc",
+        "./lib/hexdump.cc",
+        "./lib/image.cc",
+        "./lib/imagereader/d64imagereader.cc",
+        "./lib/imagereader/d88imagereader.cc",
+        "./lib/imagereader/dimimagereader.cc",
+        "./lib/imagereader/diskcopyimagereader.cc",
+        "./lib/imagereader/fdiimagereader.cc",
+        "./lib/imagereader/imagereader.cc",
+        "./lib/imagereader/imdimagereader.cc",
+        "./lib/imagereader/imgimagereader.cc",
+        "./lib/imagereader/jv3imagereader.cc",
+        "./lib/imagereader/nfdimagereader.cc",
+        "./lib/imagereader/nsiimagereader.cc",
+        "./lib/imagereader/td0imagereader.cc",
+        "./lib/imagewriter/d64imagewriter.cc",
+        "./lib/imagewriter/d88imagewriter.cc",
+        "./lib/imagewriter/diskcopyimagewriter.cc",
+        "./lib/imagewriter/imagewriter.cc",
+        "./lib/imagewriter/imdimagewriter.cc",
+        "./lib/imagewriter/imgimagewriter.cc",
+        "./lib/imagewriter/ldbsimagewriter.cc",
+        "./lib/imagewriter/nsiimagewriter.cc",
+        "./lib/imagewriter/rawimagewriter.cc",
+        "./lib/layout.cc",
+        "./lib/ldbs.cc",
+        "./lib/logger.cc",
+        "./lib/proto.cc",
+        "./lib/readerwriter.cc",
+        "./lib/sector.cc",
+        "./lib/usb/fluxengineusb.cc",
+        "./lib/usb/greaseweazle.cc",
+        "./lib/usb/greaseweazleusb.cc",
+        "./lib/usb/serial.cc",
+        "./lib/usb/usb.cc",
+        "./lib/usb/usbfinder.cc",
+        "./lib/utils.cc",
+        "./lib/vfs/acorndfs.cc",
+        "./lib/vfs/amigaffs.cc",
+        "./lib/vfs/appledos.cc",
+        "./lib/vfs/applesingle.cc",
+        "./lib/vfs/brother120fs.cc",
+        "./lib/vfs/cbmfs.cc",
+        "./lib/vfs/cpmfs.cc",
+        "./lib/vfs/fatfs.cc",
+        "./lib/vfs/fluxsectorinterface.cc",
+        "./lib/vfs/imagesectorinterface.cc",
+        "./lib/vfs/lif.cc",
+        "./lib/vfs/machfs.cc",
+        "./lib/vfs/microdos.cc",
+        "./lib/vfs/philefs.cc",
+        "./lib/vfs/prodos.cc",
+        "./lib/vfs/roland.cc",
+        "./lib/vfs/smaky6fs.cc",
+        "./lib/vfs/vfs.cc",
+        "./lib/vfs/zdos.cc",
+        "./arch/aeslanier/decoder.cc",
+        "./arch/agat/agat.cc",
+        "./arch/agat/decoder.cc",
+        "./arch/agat/encoder.cc",
+        "./arch/amiga/amiga.cc",
+        "./arch/amiga/decoder.cc",
+        "./arch/amiga/encoder.cc",
+        "./arch/apple2/decoder.cc",
+        "./arch/apple2/encoder.cc",
+        "./arch/brother/decoder.cc",
+        "./arch/brother/encoder.cc",
+        "./arch/c64/c64.cc",
+        "./arch/c64/decoder.cc",
+        "./arch/c64/encoder.cc",
+        "./arch/f85/decoder.cc",
+        "./arch/fb100/decoder.cc",
+        "./arch/ibm/decoder.cc",
+        "./arch/ibm/encoder.cc",
+        "./arch/macintosh/decoder.cc",
+        "./arch/macintosh/encoder.cc",
+        "./arch/micropolis/decoder.cc",
+        "./arch/micropolis/encoder.cc",
+        "./arch/mx/decoder.cc",
+        "./arch/northstar/decoder.cc",
+        "./arch/northstar/encoder.cc",
+        "./arch/rolandd20/decoder.cc",
+        "./arch/smaky6/decoder.cc",
+        "./arch/tartu/decoder.cc",
+        "./arch/tartu/encoder.cc",
+        "./arch/tids990/decoder.cc",
+        "./arch/tids990/encoder.cc",
+        "./arch/victor9k/decoder.cc",
+        "./arch/victor9k/encoder.cc",
+        "./arch/zilogmcz/decoder.cc",
+    ],
+    hdrs={
+        "arch/ibm/ibm.h": "./arch/ibm/ibm.h",
+        "arch/apple2/data_gcr.h": "./arch/apple2/data_gcr.h",
+        "arch/apple2/apple2.h": "./arch/apple2/apple2.h",
+        "arch/smaky6/smaky6.h": "./arch/smaky6/smaky6.h",
+        "arch/tids990/tids990.h": "./arch/tids990/tids990.h",
+        "arch/zilogmcz/zilogmcz.h": "./arch/zilogmcz/zilogmcz.h",
+        "arch/amiga/amiga.h": "./arch/amiga/amiga.h",
+        "arch/f85/data_gcr.h": "./arch/f85/data_gcr.h",
+        "arch/f85/f85.h": "./arch/f85/f85.h",
+        "arch/mx/mx.h": "./arch/mx/mx.h",
+        "arch/aeslanier/aeslanier.h": "./arch/aeslanier/aeslanier.h",
+        "arch/northstar/northstar.h": "./arch/northstar/northstar.h",
+        "arch/brother/data_gcr.h": "./arch/brother/data_gcr.h",
+        "arch/brother/brother.h": "./arch/brother/brother.h",
+        "arch/brother/header_gcr.h": "./arch/brother/header_gcr.h",
+        "arch/macintosh/data_gcr.h": "./arch/macintosh/data_gcr.h",
+        "arch/macintosh/macintosh.h": "./arch/macintosh/macintosh.h",
+        "arch/agat/agat.h": "./arch/agat/agat.h",
+        "arch/fb100/fb100.h": "./arch/fb100/fb100.h",
+        "arch/victor9k/data_gcr.h": "./arch/victor9k/data_gcr.h",
+        "arch/victor9k/victor9k.h": "./arch/victor9k/victor9k.h",
+        "arch/rolandd20/rolandd20.h": "./arch/rolandd20/rolandd20.h",
+        "arch/micropolis/micropolis.h": "./arch/micropolis/micropolis.h",
+        "arch/c64/data_gcr.h": "./arch/c64/data_gcr.h",
+        "arch/c64/c64.h": "./arch/c64/c64.h",
+        "arch/tartu/tartu.h": "./arch/tartu/tartu.h",
+        "lib/a2r.h": "./lib/a2r.h",
+        "lib/bitmap.h": "./lib/bitmap.h",
+        "lib/bytes.h": "./lib/bytes.h",
+        "lib/config.h": "./lib/config.h",
+        "lib/crc.h": "./lib/crc.h",
+        "lib/csvreader.h": "./lib/csvreader.h",
+        "lib/decoders/decoders.h": "./lib/decoders/decoders.h",
+        "lib/decoders/fluxdecoder.h": "./lib/decoders/fluxdecoder.h",
+        "lib/decoders/fluxmapreader.h": "./lib/decoders/fluxmapreader.h",
+        "lib/decoders/rawbits.h": "./lib/decoders/rawbits.h",
+        "lib/encoders/encoders.h": "./lib/encoders/encoders.h",
+        "lib/scp.h": "./lib/scp.h",
+        "lib/fl2.h": "./lib/fl2.h",
+        "lib/flags.h": "./lib/flags.h",
+        "lib/flux.h": "./lib/flux.h",
+        "lib/fluxmap.h": "./lib/fluxmap.h",
+        "lib/fluxsink/fluxsink.h": "./lib/fluxsink/fluxsink.h",
+        "lib/fluxsource/catweasel.h": "lib/fluxsource/catweasel.h",
+        "lib/fluxsource/fluxsource.h": "lib/fluxsource/fluxsource.h",
+        "lib/fluxsource/flx.h": "lib/fluxsource/flx.h",
+        "lib/fluxsource/kryoflux.h": "lib/fluxsource/kryoflux.h",
+        "lib/globals.h": "./lib/globals.h",
+        "lib/image.h": "./lib/image.h",
+        "lib/imagereader/imagereader.h": "./lib/imagereader/imagereader.h",
+        "lib/imagewriter/imagewriter.h": "./lib/imagewriter/imagewriter.h",
+        "lib/layout.h": "./lib/layout.h",
+        "lib/ldbs.h": "./lib/ldbs.h",
+        "lib/logger.h": "./lib/logger.h",
+        "lib/proto.h": "./lib/proto.h",
+        "lib/readerwriter.h": "./lib/readerwriter.h",
+        "lib/sector.h": "./lib/sector.h",
+        "lib/usb/greaseweazle.h": "./lib/usb/greaseweazle.h",
+        "lib/usb/usb.h": "./lib/usb/usb.h",
+        "lib/usb/usbfinder.h": "./lib/usb/usbfinder.h",
+        "lib/utils.h": "./lib/utils.h",
+        "lib/vfs/applesingle.h": "./lib/vfs/applesingle.h",
+        "lib/vfs/sectorinterface.h": "./lib/vfs/sectorinterface.h",
+        "lib/vfs/vfs.h": "./lib/vfs/vfs.h",
+    },
+    deps=[
+        "+fl2_proto_lib",
+        "+fmt_lib",
+        "+protocol",
+        "dep/adflib",
+        "dep/agg",
+        "dep/fatfs",
+        "dep/hfsutils",
+        "dep/libusbp",
+        "dep/stb",
+        "lib+config_proto_lib",
+    ],
+)
+
+corpustests = []
+if not glob("../fluxengine-testdata/data"):
+    print("fluxengine-testdata not found; skipping corpus tests")
+else:
+    corpus = [
+        ("acorndfs", "", "--200"),
+        ("agat", "", ""),
+        ("amiga", "", ""),
+        ("apple2", "", "--140 40track_drive"),
+        ("atarist", "", "--360"),
+        ("atarist", "", "--370"),
+        ("atarist", "", "--400"),
+        ("atarist", "", "--410"),
+        ("atarist", "", "--720"),
+        ("atarist", "", "--740"),
+        ("atarist", "", "--800"),
+        ("atarist", "", "--820"),
+        ("bk", "", ""),
+        ("brother", "", "--120 40track_drive"),
+        ("brother", "", "--240"),
+        (
+            "commodore",
+            "scripts/commodore1541_test.textpb",
+            "--171 40track_drive",
+        ),
+        (
+            "commodore",
+            "scripts/commodore1541_test.textpb",
+            "--192 40track_drive",
+        ),
+        ("commodore", "", "--800"),
+        ("commodore", "", "--1620"),
+        ("hplif", "", "--264"),
+        ("hplif", "", "--608"),
+        ("hplif", "", "--616"),
+        ("hplif", "", "--770"),
+        ("ibm", "", "--1200"),
+        ("ibm", "", "--1232"),
+        ("ibm", "", "--1440"),
+        ("ibm", "", "--1680"),
+        ("ibm", "", "--180 40track_drive"),
+        ("ibm", "", "--160 40track_drive"),
+        ("ibm", "", "--320 40track_drive"),
+        ("ibm", "", "--360 40track_drive"),
+        ("ibm", "", "--720_96"),
+        ("ibm", "", "--720_135"),
+        ("mac", "scripts/mac400_test.textpb", "--400"),
+        ("mac", "scripts/mac800_test.textpb", "--800"),
+        ("n88basic", "", ""),
+        ("rx50", "", ""),
+        ("tartu", "", "--390 40track_drive"),
+        ("tartu", "", "--780"),
+        ("tids990", "", ""),
+        ("victor9k", "", "--612"),
+        ("victor9k", "", "--1224"),
+    ]
+
+    for c in corpus:
+        name = re.sub(r"[^a-zA-Z0-9]", "_", "".join(c), 0)
+        corpustests += [
+            test(
+                name=f"corpustest_{name}_{format}",
+                ins=["src+fluxengine"],
+                deps=["scripts/encodedecodetest.sh"],
+                commands=[
+                    "{deps[0]} "
+                    + c[0]
+                    + " "
+                    + format
+                    + " {ins[0]} '"
+                    + c[1]
+                    + "' '"
+                    + c[2]
+                    + "' $(dir {outs[0]}) > /dev/null"
+                ],
+                label="CORPUSTEST",
+            )
+            for format in ["scp", "flux"]
+        ]
+
+export(
+    name="all",
+    items={
+        "fluxengine$(EXT)": "src+fluxengine",
+        "fluxengine-gui$(EXT)": "src/gui",
+        "brother120tool$(EXT)": "tools+brother120tool",
+        "brother240tool$(EXT)": "tools+brother240tool",
+        "upgrade-flux-file$(EXT)": "tools+upgrade-flux-file",
+    }
+    | ({"FluxEngine.pkg": "src/gui+fluxengine_pkg"} if config.osx else {}),
+    deps=["tests", "src/formats+docs", "scripts+mkdocindex"] + corpustests,
+)

build/_objectify.py

@@ -0,0 +1,19 @@
+import sys
+from functools import partial
+
+if len(sys.argv) != 3:
+    sys.exit("Usage: %s <file> <symbol>" % sys.argv[0])
+filename = sys.argv[1]
+symbol = sys.argv[2]
+
+print("const uint8_t " + symbol + "[] = {")
+n = 0
+with open(filename, "rb") as in_file:
+    for c in iter(partial(in_file.read, 1), b""):
+        print("0x%02X," % ord(c), end="")
+        n += 1
+        if n % 16 == 0:
+            print()
+print("};")
+
+print("const size_t " + symbol + "_len = sizeof(" + symbol + ");")

build/_progress.py

@@ -0,0 +1,5 @@
+import sys
+
+(_, current, max) = sys.argv
+percent = int(100 * float(current) / float(max))
+print(f"[{percent:>3}%]")

build/ab.mk

@@ -0,0 +1,60 @@
+ifeq ($(findstring 4.,$(MAKE_VERSION)),)
+$(error You need GNU Make 4.x for this (if you're on OSX, use gmake).)
+endif
+
+OBJ ?= .obj
+PYTHON ?= python3
+CC ?= gcc
+CXX ?= g++
+AR ?= ar
+CFLAGS ?= -g -Og
+LDFLAGS ?= -g
+PKG_CONFIG ?= pkg-config
+ECHO ?= echo
+TARGETS ?= +all
+
+ifdef VERBOSE
+	hide =
+else
+	ifdef V
+		hide =
+	else
+		hide = @
+	endif
+endif
+
+ifeq ($(OS), Windows_NT)
+	EXT ?= .exe
+endif
+EXT ?=
+
+ifeq ($(PROGRESSINFO),)
+rulecount := $(shell $(MAKE) --no-print-directory -q $(OBJ)/build.mk PROGRESSINFO=1 && $(MAKE) -n $(MAKECMDGOALS) PROGRESSINFO=XXXPROGRESSINFOXXX | grep XXXPROGRESSINFOXXX | wc -l)
+ruleindex := 1
+PROGRESSINFO = "$(shell $(PYTHON) build/_progress.py $(ruleindex) $(rulecount))$(eval ruleindex := $(shell expr $(ruleindex) + 1))"
+endif
+
+include $(OBJ)/build.mk
+
+MAKEFLAGS += -r -j$(shell nproc)
+.DELETE_ON_ERROR:
+
+.PHONY: update-ab
+update-ab:
+	@echo "Press RETURN to update ab from the repository, or CTRL+C to cancel." \
+		&& read a \
+		&& (curl -L https://github.com/davidgiven/ab/releases/download/dev/distribution.tar.xz | tar xvJf -) \
+		&& echo "Done."
+
+.PHONY: clean
+clean::
+	@echo CLEAN
+	$(hide) rm -rf $(OBJ)
+
+export PYTHONHASHSEED = 1
+build-files = $(shell find . -name 'build.py') $(wildcard build/*.py) $(wildcard config.py)
+$(OBJ)/build.mk: Makefile $(build-files) build/ab.mk
+	@echo "AB"
+	@mkdir -p $(OBJ)
+	$(hide) $(PYTHON) -X pycache_prefix=$(OBJ)/__pycache__ build/ab.py -o $@ build.py \
+		|| rm -f $@

build/ab.py

@@ -0,0 +1,547 @@
+from os.path import *
+from pathlib import Path
+from typing import Iterable
+import argparse
+import builtins
+from copy import copy
+import functools
+import importlib
+import importlib.abc
+import importlib.util
+from importlib.machinery import (
+    SourceFileLoader,
+    PathFinder,
+    ModuleSpec,
+)
+import inspect
+import string
+import sys
+import hashlib
+
+verbose = False
+quiet = False
+cwdStack = [""]
+targets = {}
+unmaterialisedTargets = {}  # dict, not set, to get consistent ordering
+materialisingStack = []
+defaultGlobals = {}
+
+sys.path += ["."]
+old_import = builtins.__import__
+
+
+class PathFinderImpl(PathFinder):
+    def find_spec(self, fullname, path, target=None):
+        if not path:
+            path = ["."]
+        if len(path) != 1:
+            return None
+
+        try:
+            path = relpath(path[0])
+        except ValueError:
+            return None
+
+        realpath = fullname.replace(".", "/")
+        buildpath = realpath + ".py"
+        if isfile(buildpath):
+            spec = importlib.util.spec_from_file_location(
+                name=fullname,
+                location=buildpath,
+                loader=BuildFileLoaderImpl(fullname=fullname, path=buildpath),
+                submodule_search_locations=[],
+            )
+            return spec
+        if isdir(realpath):
+            return ModuleSpec(fullname, None, origin=realpath, is_package=True)
+        return None
+
+
+class BuildFileLoaderImpl(SourceFileLoader):
+    def exec_module(self, module):
+        sourcepath = relpath(module.__file__)
+
+        if not quiet:
+            print("loading", sourcepath)
+        cwdStack.append(dirname(sourcepath))
+        super(SourceFileLoader, self).exec_module(module)
+        cwdStack.pop()
+
+
+sys.meta_path.insert(0, PathFinderImpl())
+
+
+class ABException(BaseException):
+    pass
+
+
+def error(message):
+    raise ABException(message)
+
+
+def Rule(func):
+    sig = inspect.signature(func)
+
+    @functools.wraps(func)
+    def wrapper(*, name=None, replaces=None, **kwargs):
+        cwd = None
+        if "cwd" in kwargs:
+            cwd = kwargs["cwd"]
+            del kwargs["cwd"]
+
+        if not cwd:
+            if replaces:
+                cwd = replaces.cwd
+            else:
+                cwd = cwdStack[-1]
+
+        if name:
+            if name[0] != "+":
+                name = "+" + name
+            t = Target(cwd, join(cwd, name))
+
+            assert (
+                t.name not in targets
+            ), f"target {t.name} has already been defined"
+            targets[t.name] = t
+        elif replaces:
+            t = replaces
+        else:
+            raise ABException("you must supply either 'name' or 'replaces'")
+
+        t.cwd = cwd
+        t.types = func.__annotations__
+        t.callback = func
+        t.traits.add(func.__name__)
+        if "args" in kwargs:
+            t.args |= kwargs["args"]
+            del kwargs["args"]
+        if "traits" in kwargs:
+            t.traits |= kwargs["traits"]
+            del kwargs["traits"]
+
+        t.binding = sig.bind(name=name, self=t, **kwargs)
+        t.binding.apply_defaults()
+
+        unmaterialisedTargets[t] = None
+        if replaces:
+            t.materialise(replacing=True)
+        return t
+
+    defaultGlobals[func.__name__] = wrapper
+    return wrapper
+
+
+def _isiterable(xs):
+    return isinstance(xs, Iterable) and not isinstance(
+        xs, (str, bytes, bytearray)
+    )
+
+
+class Target:
+    def __init__(self, cwd, name):
+        if verbose:
+            print("rule('%s', cwd='%s'" % (name, cwd))
+        self.name = name
+        self.localname = self.name.rsplit("+")[-1]
+        self.traits = set()
+        self.dir = join("$(OBJ)", name)
+        self.ins = []
+        self.outs = []
+        self.materialised = False
+        self.args = {}
+
+    def __eq__(self, other):
+        return self.name is other.name
+
+    def __lt__(self, other):
+        return self.name < other.name
+
+    def __hash__(self):
+        return id(self)
+
+    def __repr__(self):
+        return f"Target('{self.name}')"
+
+    def templateexpand(selfi, s):
+        class Formatter(string.Formatter):
+            def get_field(self, name, a1, a2):
+                return (
+                    eval(name, selfi.callback.__globals__, selfi.args),
+                    False,
+                )
+
+            def format_field(self, value, format_spec):
+                if not value:
+                    return ""
+                if type(value) == str:
+                    return value
+                if _isiterable(value):
+                    value = list(value)
+                if type(value) != list:
+                    value = [value]
+                return " ".join(
+                    [selfi.templateexpand(f) for f in filenamesof(value)]
+                )
+
+        return Formatter().format(s)
+
+    def materialise(self, replacing=False):
+        if self not in unmaterialisedTargets:
+            return
+
+        if not replacing and self in materialisingStack:
+            print("Found dependency cycle:")
+            for i in materialisingStack:
+                print(f"  {i.name}")
+            print(f"  {self.name}")
+            sys.exit(1)
+        materialisingStack.append(self)
+
+        # Perform type conversion to the declared rule parameter types.
+
+        try:
+            for k, v in self.binding.arguments.items():
+                if k != "kwargs":
+                    t = self.types.get(k, None)
+                    if t:
+                        v = t.convert(v, self)
+                    self.args[k] = copy(v)
+                else:
+                    for kk, vv in v.items():
+                        t = self.types.get(kk, None)
+                        if t:
+                            vv = t.convert(v, self)
+                        self.args[kk] = copy(vv)
+            self.args["name"] = self.name
+            self.args["dir"] = self.dir
+            self.args["self"] = self
+
+            # Actually call the callback.
+
+            cwdStack.append(self.cwd)
+            if "kwargs" in self.binding.arguments.keys():
+                # If the caller wants kwargs, return all arguments except the standard ones.
+                cbargs = {
+                    k: v for k, v in self.args.items() if k not in {"dir"}
+                }
+            else:
+                # Otherwise, just call the callback with the ones it asks for.
+                cbargs = {}
+                for k in self.binding.arguments.keys():
+                    if k != "kwargs":
+                        try:
+                            cbargs[k] = self.args[k]
+                        except KeyError:
+                            error(
+                                f"invocation of {self} failed because {k} isn't an argument"
+                            )
+            self.callback(**cbargs)
+            cwdStack.pop()
+        except BaseException as e:
+            print(f"Error materialising {self}: {self.callback}")
+            print(f"Arguments: {self.args}")
+            raise e
+
+        if self.outs is None:
+            raise ABException(f"{self.name} didn't set self.outs")
+
+        if self in unmaterialisedTargets:
+            del unmaterialisedTargets[self]
+        materialisingStack.pop()
+        self.materialised = True
+
+    def convert(value, target):
+        if not value:
+            return None
+        return target.targetof(value)
+
+    def targetof(self, value):
+        if isinstance(value, str) and (value[0] == "="):
+            value = join(self.dir, value[1:])
+
+        return targetof(value, self.cwd)
+
+
+def _filetarget(value, cwd):
+    if value in targets:
+        return targets[value]
+
+    t = Target(cwd, value)
+    t.outs = [value]
+    targets[value] = t
+    return t
+
+
+def targetof(value, cwd=None):
+    if not cwd:
+        cwd = cwdStack[-1]
+    if isinstance(value, Path):
+        value = value.as_posix()
+    if isinstance(value, Target):
+        t = value
+    else:
+        assert (
+            value[0] != "="
+        ), "can only use = for targets associated with another target"
+
+        if value.startswith("."):
+            # Check for local rule.
+            if value.startswith(".+"):
+                value = normpath(join(cwd, value[1:]))
+            # Check for local path.
+            elif value.startswith("./"):
+                value = normpath(join(cwd, value))
+        # Explicit directories are always raw files.
+        elif value.endswith("/"):
+            return _filetarget(value, cwd)
+        # Anything starting with a variable expansion is always a raw file.
+        elif value.startswith("$"):
+            return _filetarget(value, cwd)
+
+        # If this is not a rule lookup...
+        if "+" not in value:
+            # ...and if the value is pointing at a directory without a trailing /,
+            # it's a shorthand rule lookup.
+            if isdir(value):
+                value = value + "+" + basename(value)
+            # Otherwise it's an absolute file.
+            else:
+                return _filetarget(value, cwd)
+
+        # At this point we have the fully qualified name of a rule.
+
+        (path, target) = value.rsplit("+", 1)
+        value = join(path, "+" + target)
+        if value not in targets:
+            # Load the new build file.
+
+            path = join(path, "build.py")
+            try:
+                loadbuildfile(path)
+            except ModuleNotFoundError:
+                error(
+                    f"no such build file '{path}' while trying to resolve '{value}'"
+                )
+            assert (
+                value in targets
+            ), f"build file at '{path}' doesn't contain '+{target}' when trying to resolve '{value}'"
+
+        t = targets[value]
+
+    t.materialise()
+    return t
+
+
+class Targets:
+    def convert(value, target):
+        if not value:
+            return []
+        assert _isiterable(value), "cannot convert non-list to Targets"
+        return [target.targetof(x) for x in flatten(value)]
+
+
+class TargetsMap:
+    def convert(value, target):
+        if not value:
+            return {}
+        output = {k: target.targetof(v) for k, v in value.items()}
+        for k, v in output.items():
+            assert (
+                len(filenamesof([v])) == 1
+            ), f"targets of a TargetsMap used as an argument of {target} with key '{k}' must contain precisely one output file, but was {filenamesof([v])}"
+        return output
+
+
+def loadbuildfile(filename):
+    filename = filename.replace("/", ".").removesuffix(".py")
+    builtins.__import__(filename)
+
+
+def flatten(items):
+    def generate(xs):
+        for x in xs:
+            if _isiterable(x):
+                yield from generate(x)
+            else:
+                yield x
+
+    return list(generate(items))
+
+
+def targetnamesof(items):
+    assert _isiterable(items), "argument of filenamesof is not a collection"
+
+    return [t.name for t in items]
+
+
+def filenamesof(items):
+    assert _isiterable(items), "argument of filenamesof is not a collection"
+
+    def generate(xs):
+        for x in xs:
+            if isinstance(x, Target):
+                yield from generate(x.outs)
+            else:
+                yield x
+
+    return list(generate(items))
+
+
+def filenameof(x):
+    xs = filenamesof(x.outs)
+    assert (
+        len(xs) == 1
+    ), f"tried to use filenameof() on {x} which does not have exactly one output: {x.outs}"
+    return xs[0]
+
+
+def emit(*args, into=None):
+    s = " ".join(args) + "\n"
+    if into is not None:
+        into += [s]
+    else:
+        outputFp.write(s)
+
+
+def emit_rule(name, ins, outs, cmds=[], label=None):
+    fins = filenamesof(ins)
+    fouts = filenamesof(outs)
+    nonobjs = [f for f in fouts if not f.startswith("$(OBJ)")]
+
+    emit("")
+
+    lines = []
+    if nonobjs:
+        emit("clean::", into=lines)
+        emit("\t$(hide) rm -f", *nonobjs, into=lines)
+
+    emit(".PHONY:", name, into=lines)
+    if outs:
+        emit(name, ":", *fouts, into=lines)
+        emit(*fouts, "&:" if len(fouts) > 1 else ":", *fins, "\x01", into=lines)
+
+        if label:
+            emit("\t$(hide)", "$(ECHO) $(PROGRESSINFO) ", label, into=lines)
+        for c in cmds:
+            emit("\t$(hide)", c, into=lines)
+    else:
+        assert len(cmds) == 0, "rules with no outputs cannot have commands"
+        emit(name, ":", *fins, into=lines)
+
+    cmd = "".join(lines)
+    hash = hashlib.sha1(bytes(cmd, "utf-8")).hexdigest()
+
+    outputFp.write(cmd.replace("\x01", f"$(OBJ)/.hashes/{hash}"))
+
+    if outs:
+        emit(f"$(OBJ)/.hashes/{hash}:")
+        emit(
+            f"\t$(hide) mkdir -p $(OBJ)/.hashes && touch $(OBJ)/.hashes/{hash}"
+        )
+    emit("")
+
+
+@Rule
+def simplerule(
+    self,
+    name,
+    ins: Targets = [],
+    outs: Targets = [],
+    deps: Targets = [],
+    commands=[],
+    label="RULE",
+):
+    self.ins = ins
+    self.outs = outs
+    self.deps = deps
+
+    dirs = []
+    cs = []
+    for out in filenamesof(outs):
+        dir = dirname(out)
+        if dir and dir not in dirs:
+            dirs += [dir]
+
+        cs = [("mkdir -p %s" % dir) for dir in dirs]
+
+    for c in commands:
+        cs += [self.templateexpand(c)]
+
+    emit_rule(
+        name=self.name,
+        ins=ins + deps,
+        outs=outs,
+        label=self.templateexpand("{label} {name}"),
+        cmds=cs,
+    )
+
+
+@Rule
+def export(self, name=None, items: TargetsMap = {}, deps: Targets = []):
+    ins = []
+    outs = []
+    for dest, src in items.items():
+        dest = self.targetof(dest)
+        outs += [dest]
+
+        destf = filenameof(dest)
+
+        srcs = filenamesof([src])
+        assert (
+            len(srcs) == 1
+        ), "a dependency of an exported file must have exactly one output file"
+
+        subrule = simplerule(
+            name=f"{self.localname}/{destf}",
+            cwd=self.cwd,
+            ins=[srcs[0]],
+            outs=[destf],
+            commands=["cp %s %s" % (srcs[0], destf)],
+            label="CP",
+        )
+        subrule.materialise()
+
+    simplerule(
+        replaces=self,
+        ins=outs + deps,
+        outs=["=sentinel"],
+        commands=["touch {outs[0]}"],
+        label="EXPORT",
+    )
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-v", "--verbose", action="store_true")
+    parser.add_argument("-q", "--quiet", action="store_true")
+    parser.add_argument("-o", "--output")
+    parser.add_argument("files", nargs="+")
+    args = parser.parse_args()
+
+    global verbose
+    verbose = args.verbose
+
+    global quiet
+    quiet = args.quiet
+
+    global outputFp
+    outputFp = open(args.output, "wt")
+
+    for k in ["Rule"]:
+        defaultGlobals[k] = globals()[k]
+
+    global __name__
+    sys.modules["build.ab"] = sys.modules[__name__]
+    __name__ = "build.ab"
+
+    for f in args.files:
+        loadbuildfile(f)
+
+    while unmaterialisedTargets:
+        t = next(iter(unmaterialisedTargets))
+        t.materialise()
+    emit("AB_LOADED = 1\n")
+
+
+main()

build/build.lua

@@ -1,251 +0,0 @@
-local OBJDIR = "$(OBJDIR)"
-
-local function objdir(e)
-	return concatpath(OBJDIR, e.cwd, e.name)
-end
-
-definerule("normalrule",
-	{
-		ins = { type="targets" },
-		deps = { type="targets", default={} },
-		outs = { type="targets", default={} },
-		outleaves = { type="strings" },
-		label = { type="string", optional=true },
-		objdir = { type="string", optional=true },
-		commands = { type="strings" },
-	},
-	function (e)
-		local dir = e.objdir or objdir(e)
-		local realouts = {}
-		for _, v in pairs(e.outleaves) do
-			realouts[#realouts+1] = concatpath(dir, v)
-		end
-
-		local vars = inherit(e.vars, {
-			dir = dir
-		})
-
-		local result = simplerule {
-			name = e.name,
-			ins = e.ins,
-			deps = e.deps,
-			outs = concat(realouts, filenamesof(e.outs)),
-			label = e.label,
-			commands = e.commands,
-			vars = vars,
-		}
-		result.dir = dir
-		return result
-	end
-)
-
-local function is_clike(f)
-	return f:find("%.c$") or f:find("%.cc$") or f:find("%.cpp$")
-end
-
-definerule("cfile",
-	{
-		srcs = { type="targets" },
-		deps = { type="targets", default={} }
-	},
-	function (e)
-		local cflags = e.vars.cflags
-		local cxxflags = e.vars.cxxflags
-		for _, target in ipairs(targetsof(e.deps)) do
-			if target.is.clibrary then
-				cflags = concat(cflags, target.dep_cflags)
-				cxxflags = concat(cxxflags, target.dep_cxxflags)
-			end
-		end
-
-		local src = filter(filenamesof(e.srcs), is_clike)
-		local cmd
-		local cxx = false
-		if src[1]:find("%.c$") then
-			cmd = "$(CC) -c -o %{outs[1]} %{ins[1]} %{hdrpaths} %{cflags}"
-		else
-			cmd = "$(CXX) -c -o %{outs[1]} %{ins[1]} %{hdrpaths} %{cflags} %{cxxflags}"
-			cxx = true
-		end
-
-		local outleaf = basename(e.name)..".o"
-		local rule = normalrule {
-			name = e.name,
-			cwd = e.cwd,
-			ins = e.srcs,
-			deps = e.deps,
-			outleaves = {outleaf},
-			label = e.label,
-			commands = cmd,
-			vars = {
-				hdrpaths = {},
-				cflags = cflags,
-				cxxflags = cxxflags,
-			}
-		}
-
-		rule.is.cxxfile = cxx
-		return rule
-	end
-)
-
-local function do_cfiles(e)
-	local outs = {}
-	local srcs = filenamesof(e.srcs)
-	for _, f in ipairs(sorted(filter(srcs, is_clike))) do
-		local ofile
-		if f:find(OBJDIR, 1, true) == 1 then
-			ofile = e.name.."/"..f:sub(#OBJDIR+1)..".o"
-		else
-			ofile = e.name.."/"..f..".o"
-		end
-		outs[#outs+1] = cfile {
-			name = ofile,
-			srcs = { f },
-			deps = e.deps
-		}
-	end
-	return outs
-end
-
-definerule("clibrary",
-	{
-		srcs = { type="targets", default={} },
-		deps = { type="targets", default={} },
-		hdrs = { type="targets", default={} },
-		dep_cflags = { type="strings", default={} },
-		dep_cxxflags = { type="strings", default={} },
-		dep_ldflags = { type="strings", default={} },
-		dep_libs = { type="strings", default={} },
-	},
-	function (e)
-		local ins = do_cfiles(e)
-		local cxx = false
-		for _, f in ipairs(ins) do
-			if f.is.cxxfile then
-				cxx = true
-				break
-			end
-		end
-
-		local mkdirs = {}
-		local copies = {}
-		local outs = {}
-		local function copy_file(src, dest)
-			mkdirs[#mkdirs+1] = "mkdir -p %{dir}/"..dirname(dest)
-			copies[#copies+1] = "cp "..src.." %{dir}/"..dest
-			outs[#outs+1] = objdir(e).."/"..dest
-		end
-
-		local deps = {}
-		for k, v in pairs(e.hdrs) do
-			deps[#deps+1] = v
-			if type(k) == "number" then
-				v = filenamesof(v)
-				for _, v in ipairs(v) do
-					if not startswith(e.cwd, v) then
-						error(string.format("filename '%s' is not local to '%s' --- "..
-							"you'll have to specify the output filename manually", v, e.cwd))
-					end
-					copy_file(v, v:gsub("^"..e.cwd, ""))
-				end
-			else
-				v = filenamesof(v)
-				if #v ~= 1 then
-					error("each mapped hdrs item can only cope with a single file")
-				end
-				copy_file(v[1], k)
-			end
-		end
-
-		ins = sorted(filenamesof(ins))
-		local has_ar = (#ins ~= 0)
-		local lib = normalrule {
-			name = e.name,
-			cwd = e.cwd,
-			ins = sorted(filenamesof(ins)),
-			deps = deps,
-			outs = outs,
-			outleaves = { e.name..".a" },
-			label = e.label,
-			commands = {
-				sorted(mkdirs),
-				sorted(copies),
-				has_ar and "rm -f %{outs[1]} && $(AR) cqs %{outs[1]} %{ins}" or {},
-			}
-		}
-		
-		lib.dep_cflags = concat(e.dep_cflags, "-I"..lib.dir)
-		lib.dep_cxxflags = e.dep_cxxflags
-		lib.dep_ldflags = e.dep_ldflags
-		lib.dep_libs = concat(e.dep_libs, has_ar and matching(filenamesof(lib), "%.a$") or {})
-		lib.dep_cxx = cxx
-
-		for _, d in pairs(targetsof(e.deps)) do
-			lib.dep_cflags = concat(lib.dep_cflags, d.dep_cflags)
-			lib.dep_cxxflags = concat(lib.dep_cxxflags, d.dep_cxxflags)
-			lib.dep_ldflags = concat(lib.dep_ldflags, d.dep_ldflags)
-			lib.dep_libs = concat(lib.dep_libs, d.dep_libs)
-			lib.dep_cxx = lib.dep_cxx or d.dep_cxx
-		end
-
-		return lib
-	end
-)
-
-definerule("cprogram",
-	{
-		srcs = { type="targets", default={} },
-		deps = { type="targets", default={} },
-	},
-	function (e)
-		local deps = e.deps
-		local ins = {}
-		local cxx = false
-
-		if (#e.srcs > 0) then
-			local objs = do_cfiles(e)
-			for _, obj in pairs(objs) do
-				if obj.is.cxxfile then
-					cxx = true
-				end
-				ins[#ins+1] = obj
-			end
-		end
-
-		local libs = {}
-		local cflags = {}
-		local cxxflags = {}
-		local ldflags = {}
-		for _, lib in pairs(e.deps) do
-			cflags = concat(cflags, lib.dep_cflags)
-			cxxflags = concat(cxxflags, lib.dep_cxxflags)
-			ldflags = concat(ldflags, lib.dep_ldflags)
-			libs = concat(libs, lib.dep_libs)
-			cxx = cxx or lib.dep_cxx
-		end
-
-		local command
-		if cxx then
-			command = "$(CXX) $(LDFLAGS) %{ldflags} -o %{outs[1]} %{ins} %{libs} %{libs}"
-		else
-			command = "$(CC) $(LDFLAGS) %{ldflags} -o %{outs[1]} %{ins} %{libs} %{libs}"
-		end
-
-		return normalrule {
-			name = e.name,
-			cwd = e.cwd,
-			deps = deps,
-			ins = ins,
-			outleaves = { e.name },
-			commands = { command },
-			vars = {
-				cflags = cflags,
-				cxxflags = cxxflags,
-				ldflags = ldflags,
-				libs = libs,
-			}
-		}
-	end
-)
-

build/c.py

@@ -0,0 +1,383 @@
+from build.ab import (
+    Rule,
+    Targets,
+    TargetsMap,
+    filenameof,
+    filenamesof,
+    flatten,
+    simplerule,
+)
+from build.utils import (
+    filenamesmatchingof,
+    stripext,
+    targetswithtraitsof,
+    collectattrs,
+)
+from os.path import *
+
+
+class Toolchain:
+    label = ""
+    cfile = ["$(CC) -c -o {outs[0]} {ins[0]} $(CFLAGS) {cflags}"]
+    cxxfile = ["$(CXX) -c -o {outs[0]} {ins[0]} $(CFLAGS) {cflags}"]
+    clibrary = ["$(AR) cqs {outs[0]} {ins}"]
+    cxxlibrary = ["$(AR) cqs {outs[0]} {ins}"]
+    cprogram = ["$(CC) -o {outs[0]} {ins} {ldflags} $(LDFLAGS)"]
+    cxxprogram = ["$(CXX) -o {outs[0]} {ins} {ldflags} $(LDFLAGS)"]
+
+
+class HostToolchain:
+    label = "HOST "
+    cfile = ["$(HOSTCC) -c -o {outs[0]} {ins[0]} $(HOSTCFLAGS) {cflags}"]
+    cxxfile = ["$(HOSTCXX) -c -o {outs[0]} {ins[0]} $(HOSTCFLAGS) {cflags}"]
+    clibrary = ["$(HOSTAR) cqs {outs[0]} {ins}"]
+    cxxlibrary = ["$(HOSTAR) cqs {outs[0]} {ins}"]
+    cprogram = ["$(HOSTCC) -o {outs[0]} {ins} {ldflags} $(HOSTLDFLAGS)"]
+    cxxprogram = ["$(HOSTCXX) -o {outs[0]} {ins} {ldflags} $(HOSTLDFLAGS)"]
+
+
+def cfileimpl(self, name, srcs, deps, suffix, commands, label, kind, cflags):
+    outleaf = "=" + stripext(basename(filenameof(srcs[0]))) + suffix
+
+    cflags = collectattrs(targets=deps, name="caller_cflags", initial=cflags)
+
+    t = simplerule(
+        replaces=self,
+        ins=srcs,
+        deps=deps,
+        outs=[outleaf],
+        label=label,
+        commands=commands,
+        args={"cflags": cflags},
+    )
+
+
+@Rule
+def cfile(
+    self,
+    name,
+    srcs: Targets = None,
+    deps: Targets = None,
+    cflags=[],
+    suffix=".o",
+    toolchain=Toolchain,
+    commands=None,
+    label=None,
+):
+    if not label:
+        label = toolchain.label + "CC"
+    if not commands:
+        commands = toolchain.cfile
+    cfileimpl(self, name, srcs, deps, suffix, commands, label, "cfile", cflags)
+
+
+@Rule
+def cxxfile(
+    self,
+    name,
+    srcs: Targets = None,
+    deps: Targets = None,
+    cflags=[],
+    suffix=".o",
+    toolchain=Toolchain,
+    commands=None,
+    label=None,
+):
+    if not label:
+        label = toolchain.label + "CXX"
+    if not commands:
+        commands = toolchain.cxxfile
+    cfileimpl(
+        self, name, srcs, deps, suffix, commands, label, "cxxfile", cflags
+    )
+
+
+def findsources(name, srcs, deps, cflags, toolchain, filerule, cwd):
+    headers = filenamesmatchingof(srcs, "*.h")
+    cflags = cflags + ["-I" + dirname(h) for h in headers]
+    deps = deps + headers
+
+    objs = []
+    for s in flatten(srcs):
+        objs += [
+            filerule(
+                name=join(name, f.removeprefix("$(OBJ)/")),
+                srcs=[f],
+                deps=deps,
+                cflags=cflags,
+                toolchain=toolchain,
+                cwd=cwd,
+            )
+            for f in filenamesof([s])
+            if f.endswith(".c")
+            or f.endswith(".cc")
+            or f.endswith(".cpp")
+            or f.endswith(".S")
+            or f.endswith(".s")
+        ]
+        if any(f.endswith(".o") for f in filenamesof([s])):
+            objs += [s]
+
+    return objs
+
+
+@Rule
+def cheaders(
+    self,
+    name,
+    hdrs: TargetsMap = None,
+    caller_cflags=[],
+    deps: Targets = None,
+):
+    cs = []
+    ins = list(hdrs.values())
+    outs = []
+    i = 0
+    for dest, src in hdrs.items():
+        s = filenamesof([src])
+        assert (
+            len(s) == 1
+        ), "the target of a header must return exactly one file"
+
+        cs += ["cp {ins[" + str(i) + "]} {outs[" + str(i) + "]}"]
+        outs += ["=" + dest]
+        i = i + 1
+
+    r = simplerule(
+        replaces=self,
+        ins=ins,
+        outs=outs,
+        commands=cs,
+        deps=deps,
+        label="CHEADERS",
+        args={"caller_cflags": caller_cflags + ["-I" + self.dir]},
+    )
+
+
+def libraryimpl(
+    self,
+    name,
+    srcs,
+    deps,
+    hdrs,
+    caller_cflags,
+    caller_ldflags,
+    cflags,
+    ldflags,
+    toolchain,
+    commands,
+    label,
+    kind,
+):
+    hr = None
+    if hdrs and not srcs:
+        cheaders(
+            replaces=self,
+            hdrs=hdrs,
+            deps=targetswithtraitsof(deps, "cheaders"),
+            caller_cflags=caller_cflags,
+        )
+        return
+    if hdrs:
+        hr = cheaders(
+            name=self.localname + "_hdrs",
+            hdrs=hdrs,
+            deps=targetswithtraitsof(deps, "cheaders"),
+            caller_cflags=caller_cflags,
+        )
+        hr.materialise()
+        deps = deps + [hr]
+
+    objs = findsources(
+        self.localname,
+        srcs,
+        targetswithtraitsof(deps, "cheaders"),
+        cflags,
+        toolchain,
+        kind,
+        self.cwd,
+    )
+
+    simplerule(
+        replaces=self,
+        ins=objs,
+        outs=[f"={self.localname}.a"],
+        label=label,
+        commands=commands,
+        args={
+            "caller_cflags": collectattrs(
+                targets=deps + ([hr] if hr else []), name="caller_cflags"
+            ),
+            "caller_ldflags": collectattrs(
+                targets=deps, name="caller_ldflags", initial=caller_ldflags
+            ),
+        },
+        traits={"cheaders"},
+    )
+    self.outs = self.outs + (hr.outs if hr else [])
+
+
+@Rule
+def clibrary(
+    self,
+    name,
+    srcs: Targets = None,
+    deps: Targets = None,
+    hdrs: TargetsMap = None,
+    caller_cflags=[],
+    caller_ldflags=[],
+    cflags=[],
+    ldflags=[],
+    toolchain=Toolchain,
+    commands=None,
+    label=None,
+    cfilerule=cfile,
+):
+    if not label:
+        label = toolchain.label + "LIB"
+    if not commands:
+        commands = toolchain.clibrary
+    libraryimpl(
+        self,
+        name,
+        srcs,
+        deps,
+        hdrs,
+        caller_cflags,
+        caller_ldflags,
+        cflags,
+        ldflags,
+        toolchain,
+        commands,
+        label,
+        cfilerule,
+    )
+
+
+@Rule
+def cxxlibrary(
+    self,
+    name,
+    srcs: Targets = None,
+    deps: Targets = None,
+    hdrs: TargetsMap = None,
+    caller_cflags=[],
+    caller_ldflags=[],
+    cflags=[],
+    ldflags=[],
+    toolchain=Toolchain,
+    commands=None,
+    label=None,
+):
+    if not label:
+        label = toolchain.label + "LIB"
+    if not commands:
+        commands = toolchain.clibrary
+    libraryimpl(
+        self,
+        name,
+        srcs,
+        deps,
+        hdrs,
+        caller_cflags,
+        caller_ldflags,
+        cflags,
+        ldflags,
+        toolchain,
+        commands,
+        label,
+        cxxfile,
+    )
+
+
+def programimpl(
+    self,
+    name,
+    srcs,
+    deps,
+    cflags,
+    ldflags,
+    toolchain,
+    commands,
+    label,
+    filerule,
+    kind,
+):
+    ars = filenamesmatchingof(deps, "*.a")
+
+    cfiles = findsources(
+        self.localname, srcs, deps, cflags, toolchain, filerule, self.cwd
+    )
+    simplerule(
+        replaces=self,
+        ins=cfiles + ars + ars,
+        outs=[f"={self.localname}$(EXT)"],
+        deps=deps,
+        label=toolchain.label + label,
+        commands=commands,
+        args={
+            "ldflags": collectattrs(
+                targets=deps, name="caller_ldflags", initial=ldflags
+            )
+        },
+    )
+
+
+@Rule
+def cprogram(
+    self,
+    name,
+    srcs: Targets = None,
+    deps: Targets = None,
+    cflags=[],
+    ldflags=[],
+    toolchain=Toolchain,
+    commands=None,
+    label="CLINK",
+    cfilerule=cfile,
+    cfilekind="cprogram",
+):
+    if not commands:
+        commands = toolchain.cprogram
+    programimpl(
+        self,
+        name,
+        srcs,
+        deps,
+        cflags,
+        ldflags,
+        toolchain,
+        commands,
+        label,
+        cfilerule,
+        cfilekind,
+    )
+
+
+@Rule
+def cxxprogram(
+    self,
+    name,
+    srcs: Targets = None,
+    deps: Targets = None,
+    cflags=[],
+    ldflags=[],
+    toolchain=Toolchain,
+    commands=None,
+    label="CXXLINK",
+):
+    if not commands:
+        commands = toolchain.cxxprogram
+    programimpl(
+        self,
+        name,
+        srcs,
+        deps,
+        cflags,
+        ldflags,
+        toolchain,
+        commands,
+        label,
+        cxxfile,
+        "cxxprogram",
+    )

build/pkg.py

@@ -0,0 +1,59 @@
+from build.ab import Rule, emit, Target, filenamesof
+from types import SimpleNamespace
+import os
+import subprocess
+
+emit(
+    """
+PKG_CONFIG ?= pkg-config
+PACKAGES := $(shell $(PKG_CONFIG) --list-all | cut -d' ' -f1 | sort)
+
+HOST_PKG_CONFIG ?= pkg-config
+HOST_PACKAGES := $(shell $(HOST_PKG_CONFIG) --list-all | cut -d' ' -f1 | sort)
+"""
+)
+
+
+def _package(self, name, package, fallback, prefix=""):
+    emit(f"ifeq ($(filter {package}, $({prefix}PACKAGES)),)")
+    if fallback:
+        emit(f"{prefix}PACKAGE_DEPS_{package} := ", *filenamesof([fallback]))
+        emit(
+            f"{prefix}PACKAGE_CFLAGS_{package} :=",
+            *fallback.args.get("caller_cflags", []),
+        )
+        emit(
+            f"{prefix}PACKAGE_LDFLAGS_{package} := ",
+            *fallback.args.get("caller_ldflags", []),
+            f"$(filter %.a, $({prefix}PACKAGE_DEPS_{package}))",
+        )
+    else:
+        emit(f"$(error Required package '{package}' not installed.)")
+    emit("else")
+    emit(
+        f"{prefix}PACKAGE_CFLAGS_{package} := $(shell $({prefix}PKG_CONFIG) --cflags {package})"
+    )
+    emit(
+        f"{prefix}PACKAGE_LDFLAGS_{package} := $(shell $({prefix}PKG_CONFIG) --libs {package})"
+    )
+    emit(f"{prefix}PACKAGE_DEPS_{package} :=")
+    emit("endif")
+    emit(f"{self.name}:")
+
+    self.args["caller_cflags"] = [f"$({prefix}PACKAGE_CFLAGS_{package})"]
+    self.args["caller_ldflags"] = [f"$({prefix}PACKAGE_LDFLAGS_{package})"]
+    self.traits.add("clibrary")
+    self.traits.add("cheaders")
+
+    self.ins = []
+    self.outs = [f"$({prefix}PACKAGE_DEPS_{package})"]
+
+
+@Rule
+def package(self, name, package=None, fallback: Target = None):
+    _package(self, name, package, fallback)
+
+
+@Rule
+def hostpackage(self, name, package=None, fallback: Target = None):
+    _package(self, name, package, fallback, "HOST_")

build/protobuf.py

@@ -0,0 +1,99 @@
+from build.ab import Rule, Targets, emit, simplerule, filenamesof
+from build.utils import filenamesmatchingof, collectattrs
+from types import SimpleNamespace
+from os.path import join
+import build.pkg  # to get the protobuf package check
+
+emit(
+    """
+PROTOC ?= protoc
+ifeq ($(filter protobuf, $(PACKAGES)),)
+$(error Required package 'protobuf' not installed.)"
+endif
+"""
+)
+
+
+@Rule
+def proto(self, name, srcs: Targets = [], deps: Targets = []):
+    simplerule(
+        replaces=self,
+        ins=srcs,
+        outs=[f"={name}.descriptor"],
+        deps=deps,
+        commands=[
+            "$(PROTOC) --include_source_info --descriptor_set_out={outs[0]} {ins}"
+        ],
+        label="PROTO",
+        args={"protosrcs": filenamesof(srcs)},
+    )
+
+
+@Rule
+def protocc(self, name, srcs: Targets = [], deps: Targets = []):
+    outs = []
+    protos = []
+
+    allsrcs = collectattrs(targets=srcs, name="protosrcs")
+    assert allsrcs, "no sources provided"
+    for f in filenamesmatchingof(allsrcs, "*.proto"):
+        cc = f.replace(".proto", ".pb.cc")
+        h = f.replace(".proto", ".pb.h")
+        protos += [f]
+        srcs += [f]
+        outs += ["=" + cc, "=" + h]
+
+    r = simplerule(
+        name=f"{self.localname}_srcs",
+        cwd=self.cwd,
+        ins=protos,
+        outs=outs,
+        deps=deps,
+        commands=["$(PROTOC) --cpp_out={dir} {ins}"],
+        label="PROTOCC",
+    )
+
+    headers = {f[1:]: join(r.dir, f[1:]) for f in outs if f.endswith(".pb.h")}
+
+    from build.c import cxxlibrary
+
+    cxxlibrary(
+        replaces=self,
+        srcs=[r],
+        deps=deps,
+        hdrs=headers,
+    )
+
+
+@Rule
+def protojava(self, name, srcs: Targets = [], deps: Targets = []):
+    outs = []
+
+    allsrcs = collectattrs(targets=srcs, name="protosrcs")
+    assert allsrcs, "no sources provided"
+    protos = []
+    for f in filenamesmatchingof(allsrcs, "*.proto"):
+        protos += [f]
+        srcs += [f]
+
+    r = simplerule(
+        name=f"{self.localname}_srcs",
+        cwd=self.cwd,
+        ins=protos,
+        outs=[f"={self.localname}.srcjar"],
+        deps=deps,
+        commands=[
+            "mkdir -p {dir}/srcs",
+            "$(PROTOC) --java_out={dir}/srcs {ins}",
+            "$(JAR) cf {outs[0]} -C {dir}/srcs .",
+        ],
+        traits={"srcjar"},
+        label="PROTOJAVA",
+    )
+
+    from build.java import javalibrary
+
+    javalibrary(
+        replaces=self,
+        deps=[r] + deps,
+    )

build/tests.lua

@@ -1,18 +0,0 @@
-definerule("test",
-	{
-		srcs = { type="targets", default={} },
-	},
-	function (e)
-		if vars.TESTS == "yes" then
-			normalrule {
-				name = e.name,
-				ins = e.srcs,
-				outleaves = { "log.txt" },
-				commands = {
-					"%{ins} > %{outs}",
-				}
-			}
-		end
-	end
-)
-

build/utils.py

@@ -0,0 +1,93 @@
+from build.ab import (
+    Rule,
+    Target,
+    Targets,
+    filenameof,
+    filenamesof,
+    cwdStack,
+    error,
+    simplerule,
+)
+from os.path import relpath, splitext, join, basename, isfile
+from glob import iglob
+import fnmatch
+import itertools
+
+
+def filenamesmatchingof(xs, pattern):
+    return fnmatch.filter(filenamesof(xs), pattern)
+
+
+def stripext(path):
+    return splitext(path)[0]
+
+
+def targetswithtraitsof(xs, trait):
+    return [t for t in xs if trait in t.traits]
+
+
+def collectattrs(*, targets, name, initial=[]):
+    s = set(initial)
+    for a in [t.args.get(name, []) for t in targets]:
+        s.update(a)
+    return sorted(list(s))
+
+
+def itemsof(pattern, root=None, cwd=None):
+    if not cwd:
+        cwd = cwdStack[-1]
+    if not root:
+        root = "."
+
+    pattern = join(cwd, pattern)
+    root = join(cwd, root)
+
+    result = {}
+    for f in iglob(pattern, recursive=True):
+        try:
+            if isfile(f):
+                result[relpath(f, root)] = f
+        except ValueError:
+            error(f"file '{f}' is not in root '{root}'")
+    return result
+
+
+@Rule
+def objectify(self, name, src: Target, symbol):
+    simplerule(
+        replaces=self,
+        ins=["build/_objectify.py", src],
+        outs=[f"={basename(filenameof(src))}.h"],
+        commands=["$(PYTHON) {ins[0]} {ins[1]} " + symbol + " > {outs}"],
+        label="OBJECTIFY",
+    )
+
+
+@Rule
+def test(
+    self,
+    name,
+    command: Target = None,
+    commands=None,
+    ins: Targets = None,
+    deps: Targets = None,
+    label="TEST",
+):
+    if command:
+        simplerule(
+            replaces=self,
+            ins=[command],
+            outs=["=sentinel"],
+            commands=["{ins[0]}", "touch {outs}"],
+            deps=deps,
+            label=label,
+        )
+    else:
+        simplerule(
+            replaces=self,
+            ins=ins,
+            outs=["=sentinel"],
+            commands=commands + ["touch {outs}"],
+            deps=deps,
+            label=label,
+        )

build/zip.py

@@ -0,0 +1,37 @@
+from build.ab import (
+    Rule,
+    simplerule,
+    TargetsMap,
+    filenameof,
+    emit,
+)
+
+emit(
+    """
+ZIP ?= zip
+ZIPNOTE ?= zipnote
+"""
+)
+
+
+@Rule
+def zip(
+    self, name, flags="", items: TargetsMap = {}, extension="zip", label="ZIP"
+):
+    cs = ["rm -f {outs[0]}"]
+
+    ins = []
+    for k, v in items.items():
+        cs += [
+            "cat %s | $(ZIP) -q %s {outs[0]} -" % (filenameof(v), flags),
+            "printf '@ -\\n@=%s\\n' | $(ZIPNOTE) -w {outs[0]}" % k,
+        ]
+        ins += [v]
+
+    simplerule(
+        replaces=self,
+        ins=ins,
+        outs=[f"={self.localname}." + extension],
+        commands=cs,
+        label=label,
+    )

config.py

@@ -0,0 +1,11 @@
+import platform
+import os
+
+if os.getenv("BUILDTYPE") == "windows":
+    windows = True
+    osx = False
+    unix = False
+else:
+    windows = False
+    osx = platform.system() == "Darwin"
+    unix = True

dep/adflib/build.mk

@@ -1,22 +0,0 @@
-ADFLIB_SRCS = \
-	dep/adflib/src/adf_bitm.c \
-	dep/adflib/src/adf_cache.c \
-	dep/adflib/src/adf_dir.c \
-	dep/adflib/src/adf_disk.c \
-	dep/adflib/src/adf_dump.c \
-	dep/adflib/src/adf_env.c \
-	dep/adflib/src/adf_file.c \
-	dep/adflib/src/adf_hd.c \
-	dep/adflib/src/adf_link.c \
-	dep/adflib/src/adf_raw.c \
-	dep/adflib/src/adf_salv.c \
-	dep/adflib/src/adf_util.c \
-
-ADFLIB_OBJS = $(patsubst %.c, $(OBJDIR)/%.o, $(ADFLIB_SRCS))
-$(ADFLIB_OBJS): CFLAGS += -Idep/adflib/src -Idep/adflib
-ADFLIB_LIB = $(OBJDIR)/libadflib.a
-$(ADFLIB_LIB): $(ADFLIB_OBJS)
-ADFLIB_CFLAGS = -Idep/adflib/src
-ADFLIB_LDFLAGS = $(ADFLIB_LIB)
-OBJS += $(ADFLIB_OBJS)
-

dep/adflib/build.py

@@ -0,0 +1,47 @@
+from build.c import clibrary
+
+clibrary(
+    name="adflib",
+    srcs=[
+        "./src/adf_bitm.c",
+        "./src/adf_bitm.h",
+        "./src/adf_cache.c",
+        "./src/adf_cache.h",
+        "./src/adf_dir.c",
+        "./src/adf_dir.h",
+        "./src/adf_disk.c",
+        "./src/adf_disk.h",
+        "./src/adf_dump.c",
+        "./src/adf_dump.h",
+        "./src/adf_env.c",
+        "./src/adf_env.h",
+        "./src/adf_file.c",
+        "./src/adf_file.h",
+        "./src/adf_hd.c",
+        "./src/adf_hd.h",
+        "./src/adf_link.c",
+        "./src/adf_link.h",
+        "./src/adf_raw.c",
+        "./src/adf_raw.h",
+        "./src/adf_salv.c",
+        "./src/adf_salv.h",
+        "./src/adf_str.h",
+        "./src/adf_util.c",
+        "./src/adf_util.h",
+        "./src/defendian.h",
+        "./src/hd_blk.h",
+        "./src/prefix.h",
+        "./adf_nativ.h",
+        "./config.h",
+        "./src/adflib.h",
+    ],
+    cflags=["-Idep/adflib", "-Idep/adflib/src"],
+    hdrs={
+        "adf_blk.h": "./src/adf_blk.h",
+        "adf_defs.h": "./src/adf_defs.h",
+        "adf_err.h": "./src/adf_err.h",
+        "adf_nativ.h": "./adf_nativ.h",
+        "adf_str.h": "./src/adf_str.h",
+        "adflib.h": "./src/adflib.h",
+    },
+)

dep/agg/build.mk

@@ -1,38 +0,0 @@
-AGG_SRCS = \
-	dep/agg/src/agg_arrowhead.cpp \
-	dep/agg/src/agg_line_aa_basics.cpp \
-	dep/agg/src/agg_vcgen_bspline.cpp \
-	dep/agg/src/agg_vpgen_segmentator.cpp \
-	dep/agg/src/agg_color_rgba.cpp \
-	dep/agg/src/agg_sqrt_tables.cpp \
-	dep/agg/src/agg_bspline.cpp \
-	dep/agg/src/agg_curves.cpp \
-	dep/agg/src/agg_rounded_rect.cpp \
-	dep/agg/src/agg_vcgen_markers_term.cpp \
-	dep/agg/src/agg_vcgen_dash.cpp \
-	dep/agg/src/agg2d.cpp \
-	dep/agg/src/agg_trans_affine.cpp \
-	dep/agg/src/agg_gsv_text.cpp \
-	dep/agg/src/agg_vcgen_smooth_poly1.cpp \
-	dep/agg/src/agg_trans_single_path.cpp \
-	dep/agg/src/agg_vpgen_clip_polygon.cpp \
-	dep/agg/src/agg_embedded_raster_fonts.cpp \
-	dep/agg/src/agg_trans_double_path.cpp \
-	dep/agg/src/agg_vcgen_stroke.cpp \
-	dep/agg/src/agg_arc.cpp \
-	dep/agg/src/agg_image_filters.cpp \
-	dep/agg/src/agg_trans_warp_magnifier.cpp \
-	dep/agg/src/agg_vpgen_clip_polyline.cpp \
-	dep/agg/src/agg_bezier_arc.cpp \
-	dep/agg/src/agg_line_profile_aa.cpp \
-	dep/agg/src/agg_vcgen_contour.cpp \
-	
-AGG_OBJS = $(patsubst %.cpp, $(OBJDIR)/%.o, $(AGG_SRCS))
-AGG_LIB = $(OBJDIR)/libagg.a
-$(AGG_LIB): $(AGG_OBJS)
-AGG_LDFLAGS = $(AGG_LIB)
-AGG_CFLAGS = -Idep/agg/include
-OBJS += $(AGG_OBJS)
-
-$(AGG_OBJS): CFLAGS += $(AGG_CFLAGS)
-

dep/agg/build.py

@@ -0,0 +1,164 @@
+from build.c import cxxlibrary
+
+cxxlibrary(
+    name="agg",
+    srcs=[
+        "./src/agg_arrowhead.cpp",
+        "./src/agg_line_aa_basics.cpp",
+        "./src/agg_vcgen_bspline.cpp",
+        "./src/agg_vpgen_segmentator.cpp",
+        "./src/agg_color_rgba.cpp",
+        "./src/agg_sqrt_tables.cpp",
+        "./src/agg_bspline.cpp",
+        "./src/agg_curves.cpp",
+        "./src/agg_rounded_rect.cpp",
+        "./src/agg_vcgen_markers_term.cpp",
+        "./src/agg_vcgen_dash.cpp",
+        "./src/agg2d.cpp",
+        "./src/agg_trans_affine.cpp",
+        "./src/agg_gsv_text.cpp",
+        "./src/agg_vcgen_smooth_poly1.cpp",
+        "./src/agg_trans_single_path.cpp",
+        "./src/agg_vpgen_clip_polygon.cpp",
+        "./src/agg_embedded_raster_fonts.cpp",
+        "./src/agg_trans_double_path.cpp",
+        "./src/agg_vcgen_stroke.cpp",
+        "./src/agg_arc.cpp",
+        "./src/agg_image_filters.cpp",
+        "./src/agg_trans_warp_magnifier.cpp",
+        "./src/agg_vpgen_clip_polyline.cpp",
+        "./src/agg_bezier_arc.cpp",
+        "./src/agg_line_profile_aa.cpp",
+        "./src/agg_vcgen_contour.cpp",
+    ],
+    hdrs={
+        "agg2d.h": "./include/agg2d.h",
+        "agg_alpha_mask_u8.h": "./include/agg_alpha_mask_u8.h",
+        "agg_arc.h": "./include/agg_arc.h",
+        "agg_array.h": "./include/agg_array.h",
+        "agg_arrowhead.h": "./include/agg_arrowhead.h",
+        "agg_basics.h": "./include/agg_basics.h",
+        "agg_bezier_arc.h": "./include/agg_bezier_arc.h",
+        "agg_bitset_iterator.h": "./include/agg_bitset_iterator.h",
+        "agg_blur.h": "./include/agg_blur.h",
+        "agg_bounding_rect.h": "./include/agg_bounding_rect.h",
+        "agg_bspline.h": "./include/agg_bspline.h",
+        "agg_clip_liang_barsky.h": "./include/agg_clip_liang_barsky.h",
+        "agg_color_gray.h": "./include/agg_color_gray.h",
+        "agg_color_rgba.h": "./include/agg_color_rgba.h",
+        "agg_config.h": "./include/agg_config.h",
+        "agg_conv_adaptor_vcgen.h": "./include/agg_conv_adaptor_vcgen.h",
+        "agg_conv_adaptor_vpgen.h": "./include/agg_conv_adaptor_vpgen.h",
+        "agg_conv_bspline.h": "./include/agg_conv_bspline.h",
+        "agg_conv_clip_polygon.h": "./include/agg_conv_clip_polygon.h",
+        "agg_conv_clip_polyline.h": "./include/agg_conv_clip_polyline.h",
+        "agg_conv_close_polygon.h": "./include/agg_conv_close_polygon.h",
+        "agg_conv_concat.h": "./include/agg_conv_concat.h",
+        "agg_conv_contour.h": "./include/agg_conv_contour.h",
+        "agg_conv_curve.h": "./include/agg_conv_curve.h",
+        "agg_conv_dash.h": "./include/agg_conv_dash.h",
+        "agg_conv_gpc.h": "./include/agg_conv_gpc.h",
+        "agg_conv_marker_adaptor.h": "./include/agg_conv_marker_adaptor.h",
+        "agg_conv_marker.h": "./include/agg_conv_marker.h",
+        "agg_conv_segmentator.h": "./include/agg_conv_segmentator.h",
+        "agg_conv_shorten_path.h": "./include/agg_conv_shorten_path.h",
+        "agg_conv_smooth_poly1.h": "./include/agg_conv_smooth_poly1.h",
+        "agg_conv_stroke.h": "./include/agg_conv_stroke.h",
+        "agg_conv_transform.h": "./include/agg_conv_transform.h",
+        "agg_conv_unclose_polygon.h": "./include/agg_conv_unclose_polygon.h",
+        "agg_curves.h": "./include/agg_curves.h",
+        "agg_dda_line.h": "./include/agg_dda_line.h",
+        "agg_ellipse_bresenham.h": "./include/agg_ellipse_bresenham.h",
+        "agg_ellipse.h": "./include/agg_ellipse.h",
+        "agg_embedded_raster_fonts.h": "./include/agg_embedded_raster_fonts.h",
+        "agg_font_cache_manager2.h": "./include/agg_font_cache_manager2.h",
+        "agg_font_cache_manager.h": "./include/agg_font_cache_manager.h",
+        "agg_gamma_functions.h": "./include/agg_gamma_functions.h",
+        "agg_gamma_lut.h": "./include/agg_gamma_lut.h",
+        "agg_glyph_raster_bin.h": "./include/agg_glyph_raster_bin.h",
+        "agg_gradient_lut.h": "./include/agg_gradient_lut.h",
+        "agg_gsv_text.h": "./include/agg_gsv_text.h",
+        "agg_image_accessors.h": "./include/agg_image_accessors.h",
+        "agg_image_filters.h": "./include/agg_image_filters.h",
+        "agg_line_aa_basics.h": "./include/agg_line_aa_basics.h",
+        "agg_math.h": "./include/agg_math.h",
+        "agg_math_stroke.h": "./include/agg_math_stroke.h",
+        "agg_path_length.h": "./include/agg_path_length.h",
+        "agg_path_storage.h": "./include/agg_path_storage.h",
+        "agg_path_storage_integer.h": "./include/agg_path_storage_integer.h",
+        "agg_pattern_filters_rgba.h": "./include/agg_pattern_filters_rgba.h",
+        "agg_pixfmt_amask_adaptor.h": "./include/agg_pixfmt_amask_adaptor.h",
+        "agg_pixfmt_base.h": "./include/agg_pixfmt_base.h",
+        "agg_pixfmt_gray.h": "./include/agg_pixfmt_gray.h",
+        "agg_pixfmt_rgba.h": "./include/agg_pixfmt_rgba.h",
+        "agg_pixfmt_rgb.h": "./include/agg_pixfmt_rgb.h",
+        "agg_pixfmt_rgb_packed.h": "./include/agg_pixfmt_rgb_packed.h",
+        "agg_pixfmt_transposer.h": "./include/agg_pixfmt_transposer.h",
+        "agg_rasterizer_cells_aa.h": "./include/agg_rasterizer_cells_aa.h",
+        "agg_rasterizer_compound_aa.h": "./include/agg_rasterizer_compound_aa.h",
+        "agg_rasterizer_outline_aa.h": "./include/agg_rasterizer_outline_aa.h",
+        "agg_rasterizer_outline.h": "./include/agg_rasterizer_outline.h",
+        "agg_rasterizer_scanline_aa.h": "./include/agg_rasterizer_scanline_aa.h",
+        "agg_rasterizer_scanline_aa_nogamma.h": "./include/agg_rasterizer_scanline_aa_nogamma.h",
+        "agg_rasterizer_sl_clip.h": "./include/agg_rasterizer_sl_clip.h",
+        "agg_renderer_base.h": "./include/agg_renderer_base.h",
+        "agg_renderer_markers.h": "./include/agg_renderer_markers.h",
+        "agg_renderer_mclip.h": "./include/agg_renderer_mclip.h",
+        "agg_renderer_outline_aa.h": "./include/agg_renderer_outline_aa.h",
+        "agg_renderer_outline_image.h": "./include/agg_renderer_outline_image.h",
+        "agg_renderer_primitives.h": "./include/agg_renderer_primitives.h",
+        "agg_renderer_raster_text.h": "./include/agg_renderer_raster_text.h",
+        "agg_renderer_scanline.h": "./include/agg_renderer_scanline.h",
+        "agg_rendering_buffer_dynarow.h": "./include/agg_rendering_buffer_dynarow.h",
+        "agg_rendering_buffer.h": "./include/agg_rendering_buffer.h",
+        "agg_rounded_rect.h": "./include/agg_rounded_rect.h",
+        "agg_scanline_bin.h": "./include/agg_scanline_bin.h",
+        "agg_scanline_boolean_algebra.h": "./include/agg_scanline_boolean_algebra.h",
+        "agg_scanline_p.h": "./include/agg_scanline_p.h",
+        "agg_scanline_storage_aa.h": "./include/agg_scanline_storage_aa.h",
+        "agg_scanline_storage_bin.h": "./include/agg_scanline_storage_bin.h",
+        "agg_scanline_u.h": "./include/agg_scanline_u.h",
+        "agg_shorten_path.h": "./include/agg_shorten_path.h",
+        "agg_simul_eq.h": "./include/agg_simul_eq.h",
+        "agg_span_allocator.h": "./include/agg_span_allocator.h",
+        "agg_span_converter.h": "./include/agg_span_converter.h",
+        "agg_span_gouraud_gray.h": "./include/agg_span_gouraud_gray.h",
+        "agg_span_gouraud.h": "./include/agg_span_gouraud.h",
+        "agg_span_gouraud_rgba.h": "./include/agg_span_gouraud_rgba.h",
+        "agg_span_gradient_alpha.h": "./include/agg_span_gradient_alpha.h",
+        "agg_span_gradient_contour.h": "./include/agg_span_gradient_contour.h",
+        "agg_span_gradient.h": "./include/agg_span_gradient.h",
+        "agg_span_gradient_image.h": "./include/agg_span_gradient_image.h",
+        "agg_span_image_filter_gray.h": "./include/agg_span_image_filter_gray.h",
+        "agg_span_image_filter.h": "./include/agg_span_image_filter.h",
+        "agg_span_image_filter_rgba.h": "./include/agg_span_image_filter_rgba.h",
+        "agg_span_image_filter_rgb.h": "./include/agg_span_image_filter_rgb.h",
+        "agg_span_interpolator_adaptor.h": "./include/agg_span_interpolator_adaptor.h",
+        "agg_span_interpolator_linear.h": "./include/agg_span_interpolator_linear.h",
+        "agg_span_interpolator_persp.h": "./include/agg_span_interpolator_persp.h",
+        "agg_span_interpolator_trans.h": "./include/agg_span_interpolator_trans.h",
+        "agg_span_pattern_gray.h": "./include/agg_span_pattern_gray.h",
+        "agg_span_pattern_rgba.h": "./include/agg_span_pattern_rgba.h",
+        "agg_span_pattern_rgb.h": "./include/agg_span_pattern_rgb.h",
+        "agg_span_solid.h": "./include/agg_span_solid.h",
+        "agg_span_subdiv_adaptor.h": "./include/agg_span_subdiv_adaptor.h",
+        "agg_trans_affine.h": "./include/agg_trans_affine.h",
+        "agg_trans_bilinear.h": "./include/agg_trans_bilinear.h",
+        "agg_trans_double_path.h": "./include/agg_trans_double_path.h",
+        "agg_trans_perspective.h": "./include/agg_trans_perspective.h",
+        "agg_trans_single_path.h": "./include/agg_trans_single_path.h",
+        "agg_trans_viewport.h": "./include/agg_trans_viewport.h",
+        "agg_trans_warp_magnifier.h": "./include/agg_trans_warp_magnifier.h",
+        "agg_vcgen_bspline.h": "./include/agg_vcgen_bspline.h",
+        "agg_vcgen_contour.h": "./include/agg_vcgen_contour.h",
+        "agg_vcgen_dash.h": "./include/agg_vcgen_dash.h",
+        "agg_vcgen_markers_term.h": "./include/agg_vcgen_markers_term.h",
+        "agg_vcgen_smooth_poly1.h": "./include/agg_vcgen_smooth_poly1.h",
+        "agg_vcgen_stroke.h": "./include/agg_vcgen_stroke.h",
+        "agg_vcgen_vertex_sequence.h": "./include/agg_vcgen_vertex_sequence.h",
+        "agg_vertex_sequence.h": "./include/agg_vertex_sequence.h",
+        "agg_vpgen_clip_polygon.h": "./include/agg_vpgen_clip_polygon.h",
+        "agg_vpgen_clip_polyline.h": "./include/agg_vpgen_clip_polyline.h",
+        "agg_vpgen_segmentator.h": "./include/agg_vpgen_segmentator.h",
+    },
+)

dep/emu/build.mk

@@ -1,21 +0,0 @@
-ifeq ($(OS), Windows_NT)
-
-EMU_SRCS = \
-	dep/emu/fnmatch.c
-
-EMU_OBJS = $(patsubst %.c, $(OBJDIR)/%.o, $(EMU_SRCS))
-$(EMU_OBJS): CFLAGS += -Idep/emu
-EMU_LIB = $(OBJDIR)/libemu.a
-$(EMU_LIB): $(EMU_OBJS)
-EMU_CFLAGS = -Idep/emu
-EMU_LDFLAGS = $(EMU_LIB)
-OBJS += $(EMU_OBJS)
-
-else
-
-EMU_LIB =
-EMU_CFLAGS =
-EMU_LDFLAGS =
-
-endif
-

dep/emu/build.py

@@ -0,0 +1,3 @@
+from build.c import clibrary
+
+clibrary(name="emu", srcs=["./fnmatch.c"], hdrs={"fnmatch.h": "./fnmatch.h"})

dep/fatfs/build.mk

@@ -1,13 +0,0 @@
-FATFS_SRCS = \
-	dep/fatfs/source/ff.c \
-	dep/fatfs/source/ffsystem.c \
-	dep/fatfs/source/ffunicode.c \
-	
-FATFS_OBJS = $(patsubst %.c, $(OBJDIR)/%.o, $(FATFS_SRCS))
-$(FATFS_OBJS): CFLAGS += -Idep/fatfs/source
-FATFS_LIB = $(OBJDIR)/libfatfs.a
-$(FATFS_LIB): $(FATFS_OBJS)
-FATFS_CFLAGS = -Idep/fatfs/source
-FATFS_LDFLAGS = $(FATFS_LIB)
-OBJS += $(FATFS_OBJS)
-

dep/fatfs/build.py

@@ -0,0 +1,18 @@
+from build.c import clibrary
+
+clibrary(
+    name="fatfs",
+    srcs=[
+        "./source/ff.c",
+        "./source/ffsystem.c",
+        "./source/ffunicode.c",
+        "./source/ff.h",
+        "./source/ffconf.h",
+        "./source/diskio.h",
+    ],
+    hdrs={
+        "ff.h": "./source/ff.h",
+        "ffconf.h": "./source/ffconf.h",
+        "diskio.h": "./source/diskio.h",
+    },
+)

dep/fmt/.clang-format

@@ -0,0 +1,8 @@
+# Run manually to reformat a file:
+# clang-format -i --style=file <file>
+Language: Cpp
+BasedOnStyle: Google
+IndentPPDirectives: AfterHash
+IndentCaseLabels: false
+AlwaysBreakTemplateDeclarations: false
+DerivePointerAlignment: false

dep/fmt/CMakeLists.txt

@@ -0,0 +1,453 @@
+cmake_minimum_required(VERSION 3.8...3.26)
+
+# Fallback for using newer policies on CMake <3.12.
+if (${CMAKE_VERSION} VERSION_LESS 3.12)
+  cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
+endif ()
+
+# Determine if fmt is built as a subproject (using add_subdirectory)
+# or if it is the master project.
+if (NOT DEFINED FMT_MASTER_PROJECT)
+  set(FMT_MASTER_PROJECT OFF)
+  if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+    set(FMT_MASTER_PROJECT ON)
+    message(STATUS "CMake version: ${CMAKE_VERSION}")
+  endif ()
+endif ()
+
+# Joins arguments and places the results in ${result_var}.
+function(join result_var)
+  set(result "")
+  foreach (arg ${ARGN})
+    set(result "${result}${arg}")
+  endforeach ()
+  set(${result_var} "${result}" PARENT_SCOPE)
+endfunction()
+
+# DEPRECATED! Should be merged into add_module_library.
+function(enable_module target)
+  if (MSVC)
+    set(BMI ${CMAKE_CURRENT_BINARY_DIR}/${target}.ifc)
+    target_compile_options(${target}
+      PRIVATE /interface /ifcOutput ${BMI}
+      INTERFACE /reference fmt=${BMI})
+    set_target_properties(${target} PROPERTIES ADDITIONAL_CLEAN_FILES ${BMI})
+    set_source_files_properties(${BMI} PROPERTIES GENERATED ON)
+  endif ()
+endfunction()
+
+# Adds a library compiled with C++20 module support.
+# `enabled` is a CMake variables that specifies if modules are enabled.
+# If modules are disabled `add_module_library` falls back to creating a
+# non-modular library.
+#
+# Usage:
+#   add_module_library(<name> [sources...] FALLBACK [sources...] [IF enabled])
+function(add_module_library name)
+  cmake_parse_arguments(AML "" "IF" "FALLBACK" ${ARGN})
+  set(sources ${AML_UNPARSED_ARGUMENTS})
+
+  add_library(${name})
+  set_target_properties(${name} PROPERTIES LINKER_LANGUAGE CXX)
+
+  if (NOT ${${AML_IF}})
+    # Create a non-modular library.
+    target_sources(${name} PRIVATE ${AML_FALLBACK})
+    return()
+  endif ()
+
+  # Modules require C++20.
+  target_compile_features(${name} PUBLIC cxx_std_20)
+  if (CMAKE_COMPILER_IS_GNUCXX)
+    target_compile_options(${name} PUBLIC -fmodules-ts)
+  endif ()
+
+  # `std` is affected by CMake options and may be higher than C++20.
+  get_target_property(std ${name} CXX_STANDARD)
+
+  if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    set(pcms)
+    foreach (src ${sources})
+      get_filename_component(pcm ${src} NAME_WE)
+      set(pcm ${pcm}.pcm)
+
+      # Propagate -fmodule-file=*.pcm to targets that link with this library.
+      target_compile_options(
+        ${name} PUBLIC -fmodule-file=${CMAKE_CURRENT_BINARY_DIR}/${pcm})
+
+      # Use an absolute path to prevent target_link_libraries prepending -l
+      # to it.
+      set(pcms ${pcms} ${CMAKE_CURRENT_BINARY_DIR}/${pcm})
+      add_custom_command(
+        OUTPUT ${pcm}
+        COMMAND ${CMAKE_CXX_COMPILER}
+                -std=c++${std} -x c++-module --precompile -c
+                -o ${pcm} ${CMAKE_CURRENT_SOURCE_DIR}/${src}
+                "-I$<JOIN:$<TARGET_PROPERTY:${name},INCLUDE_DIRECTORIES>,;-I>"
+        # Required by the -I generator expression above.
+        COMMAND_EXPAND_LISTS
+        DEPENDS ${src})
+    endforeach ()
+
+    # Add .pcm files as sources to make sure they are built before the library.
+    set(sources)
+    foreach (pcm ${pcms})
+      get_filename_component(pcm_we ${pcm} NAME_WE)
+      set(obj ${pcm_we}.o)
+      # Use an absolute path to prevent target_link_libraries prepending -l.
+      set(sources ${sources} ${pcm} ${CMAKE_CURRENT_BINARY_DIR}/${obj})
+      add_custom_command(
+        OUTPUT ${obj}
+        COMMAND ${CMAKE_CXX_COMPILER} $<TARGET_PROPERTY:${name},COMPILE_OPTIONS>
+                -c -o ${obj} ${pcm}
+        DEPENDS ${pcm})
+    endforeach ()
+  endif ()
+  target_sources(${name} PRIVATE ${sources})
+endfunction()
+
+include(CMakeParseArguments)
+
+# Sets a cache variable with a docstring joined from multiple arguments:
+#   set(<variable> <value>... CACHE <type> <docstring>...)
+# This allows splitting a long docstring for readability.
+function(set_verbose)
+  # cmake_parse_arguments is broken in CMake 3.4 (cannot parse CACHE) so use
+  # list instead.
+  list(GET ARGN 0 var)
+  list(REMOVE_AT ARGN 0)
+  list(GET ARGN 0 val)
+  list(REMOVE_AT ARGN 0)
+  list(REMOVE_AT ARGN 0)
+  list(GET ARGN 0 type)
+  list(REMOVE_AT ARGN 0)
+  join(doc ${ARGN})
+  set(${var} ${val} CACHE ${type} ${doc})
+endfunction()
+
+# Set the default CMAKE_BUILD_TYPE to Release.
+# This should be done before the project command since the latter can set
+# CMAKE_BUILD_TYPE itself (it does so for nmake).
+if (FMT_MASTER_PROJECT AND NOT CMAKE_BUILD_TYPE)
+  set_verbose(CMAKE_BUILD_TYPE Release CACHE STRING
+              "Choose the type of build, options are: None(CMAKE_CXX_FLAGS or "
+              "CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel.")
+endif ()
+
+project(FMT CXX)
+include(GNUInstallDirs)
+set_verbose(FMT_INC_DIR ${CMAKE_INSTALL_INCLUDEDIR} CACHE STRING
+            "Installation directory for include files, a relative path that "
+            "will be joined with ${CMAKE_INSTALL_PREFIX} or an absolute path.")
+
+option(FMT_PEDANTIC "Enable extra warnings and expensive tests." OFF)
+option(FMT_WERROR "Halt the compilation with an error on compiler warnings."
+       OFF)
+
+# Options that control generation of various targets.
+option(FMT_DOC "Generate the doc target." ${FMT_MASTER_PROJECT})
+option(FMT_INSTALL "Generate the install target." ON)
+option(FMT_TEST "Generate the test target." ${FMT_MASTER_PROJECT})
+option(FMT_FUZZ "Generate the fuzz target." OFF)
+option(FMT_CUDA_TEST "Generate the cuda-test target." OFF)
+option(FMT_OS "Include core requiring OS (Windows/Posix) " ON)
+option(FMT_MODULE "Build a module instead of a traditional library." OFF)
+option(FMT_SYSTEM_HEADERS "Expose headers with marking them as system." OFF)
+
+if (FMT_TEST AND FMT_MODULE)
+  # The tests require {fmt} to be compiled as traditional library
+  message(STATUS "Testing is incompatible with build mode 'module'.")
+endif ()
+set(FMT_SYSTEM_HEADERS_ATTRIBUTE "")
+if (FMT_SYSTEM_HEADERS)
+  set(FMT_SYSTEM_HEADERS_ATTRIBUTE SYSTEM)
+endif ()
+if (CMAKE_SYSTEM_NAME STREQUAL "MSDOS")
+  set(FMT_TEST OFF)
+  message(STATUS "MSDOS is incompatible with gtest")
+endif ()
+
+# Get version from core.h
+file(READ include/fmt/core.h core_h)
+if (NOT core_h MATCHES "FMT_VERSION ([0-9]+)([0-9][0-9])([0-9][0-9])")
+  message(FATAL_ERROR "Cannot get FMT_VERSION from core.h.")
+endif ()
+# Use math to skip leading zeros if any.
+math(EXPR CPACK_PACKAGE_VERSION_MAJOR ${CMAKE_MATCH_1})
+math(EXPR CPACK_PACKAGE_VERSION_MINOR ${CMAKE_MATCH_2})
+math(EXPR CPACK_PACKAGE_VERSION_PATCH ${CMAKE_MATCH_3})
+join(FMT_VERSION ${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.
+                 ${CPACK_PACKAGE_VERSION_PATCH})
+message(STATUS "Version: ${FMT_VERSION}")
+
+message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
+
+if (NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY)
+  set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/bin)
+endif ()
+
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH}
+  "${CMAKE_CURRENT_SOURCE_DIR}/support/cmake")
+
+include(CheckCXXCompilerFlag)
+include(JoinPaths)
+
+if (FMT_MASTER_PROJECT AND NOT DEFINED CMAKE_CXX_VISIBILITY_PRESET)
+  set_verbose(CMAKE_CXX_VISIBILITY_PRESET hidden CACHE STRING
+              "Preset for the export of private symbols")
+  set_property(CACHE CMAKE_CXX_VISIBILITY_PRESET PROPERTY STRINGS
+               hidden default)
+endif ()
+
+if (FMT_MASTER_PROJECT AND NOT DEFINED CMAKE_VISIBILITY_INLINES_HIDDEN)
+  set_verbose(CMAKE_VISIBILITY_INLINES_HIDDEN ON CACHE BOOL
+              "Whether to add a compile flag to hide symbols of inline functions")
+endif ()
+
+if (CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+  set(PEDANTIC_COMPILE_FLAGS -pedantic-errors -Wall -Wextra -pedantic
+      -Wold-style-cast -Wundef
+      -Wredundant-decls -Wwrite-strings -Wpointer-arith
+      -Wcast-qual -Wformat=2 -Wmissing-include-dirs
+      -Wcast-align
+      -Wctor-dtor-privacy -Wdisabled-optimization
+      -Winvalid-pch -Woverloaded-virtual
+      -Wconversion -Wundef
+      -Wno-ctor-dtor-privacy -Wno-format-nonliteral)
+  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.6)
+      set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS}
+         -Wno-dangling-else -Wno-unused-local-typedefs)
+  endif ()
+  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0)
+      set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wdouble-promotion
+          -Wtrampolines -Wzero-as-null-pointer-constant -Wuseless-cast
+          -Wvector-operation-performance -Wsized-deallocation -Wshadow)
+  endif ()
+  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 6.0)
+      set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wshift-overflow=2
+          -Wnull-dereference -Wduplicated-cond)
+  endif ()
+  set(WERROR_FLAG -Werror)
+endif ()
+
+if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+  set(PEDANTIC_COMPILE_FLAGS -Wall -Wextra -pedantic -Wconversion -Wundef
+      -Wdeprecated -Wweak-vtables -Wshadow
+      -Wno-gnu-zero-variadic-macro-arguments)
+  check_cxx_compiler_flag(-Wzero-as-null-pointer-constant HAS_NULLPTR_WARNING)
+  if (HAS_NULLPTR_WARNING)
+    set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS}
+        -Wzero-as-null-pointer-constant)
+  endif ()
+  set(WERROR_FLAG -Werror)
+endif ()
+
+if (MSVC)
+  set(PEDANTIC_COMPILE_FLAGS /W3)
+  set(WERROR_FLAG /WX)
+endif ()
+
+if (FMT_MASTER_PROJECT AND CMAKE_GENERATOR MATCHES "Visual Studio")
+  # If Microsoft SDK is installed create script run-msbuild.bat that
+  # calls SetEnv.cmd to set up build environment and runs msbuild.
+  # It is useful when building Visual Studio projects with the SDK
+  # toolchain rather than Visual Studio.
+  include(FindSetEnv)
+  if (WINSDK_SETENV)
+    set(MSBUILD_SETUP "call \"${WINSDK_SETENV}\"")
+  endif ()
+  # Set FrameworkPathOverride to get rid of MSB3644 warnings.
+  join(netfxpath
+       "C:\\Program Files\\Reference Assemblies\\Microsoft\\Framework\\"
+       ".NETFramework\\v4.0")
+  file(WRITE run-msbuild.bat "
+    ${MSBUILD_SETUP}
+    ${CMAKE_MAKE_PROGRAM} -p:FrameworkPathOverride=\"${netfxpath}\" %*")
+endif ()
+
+function(add_headers VAR)
+  set(headers ${${VAR}})
+  foreach (header ${ARGN})
+    set(headers ${headers} include/fmt/${header})
+  endforeach()
+  set(${VAR} ${headers} PARENT_SCOPE)
+endfunction()
+
+# Define the fmt library, its includes and the needed defines.
+add_headers(FMT_HEADERS args.h chrono.h color.h compile.h core.h format.h
+                        format-inl.h os.h ostream.h printf.h ranges.h std.h
+                        xchar.h)
+set(FMT_SOURCES src/format.cc)
+if (FMT_OS)
+  set(FMT_SOURCES ${FMT_SOURCES} src/os.cc)
+endif ()
+
+add_module_library(fmt src/fmt.cc FALLBACK
+                   ${FMT_SOURCES} ${FMT_HEADERS} README.md ChangeLog.md
+                   IF FMT_MODULE)
+add_library(fmt::fmt ALIAS fmt)
+if (FMT_MODULE)
+  enable_module(fmt)
+endif ()
+
+if (FMT_WERROR)
+  target_compile_options(fmt PRIVATE ${WERROR_FLAG})
+endif ()
+if (FMT_PEDANTIC)
+  target_compile_options(fmt PRIVATE ${PEDANTIC_COMPILE_FLAGS})
+endif ()
+
+if (cxx_std_11 IN_LIST CMAKE_CXX_COMPILE_FEATURES)
+  target_compile_features(fmt PUBLIC cxx_std_11)
+else ()
+  message(WARNING "Feature cxx_std_11 is unknown for the CXX compiler")
+endif ()
+
+target_include_directories(fmt ${FMT_SYSTEM_HEADERS_ATTRIBUTE} PUBLIC
+  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
+  $<INSTALL_INTERFACE:${FMT_INC_DIR}>)
+
+set(FMT_DEBUG_POSTFIX d CACHE STRING "Debug library postfix.")
+
+set_target_properties(fmt PROPERTIES
+  VERSION ${FMT_VERSION} SOVERSION ${CPACK_PACKAGE_VERSION_MAJOR}
+  PUBLIC_HEADER "${FMT_HEADERS}"
+  DEBUG_POSTFIX "${FMT_DEBUG_POSTFIX}"
+
+  # Workaround for Visual Studio 2017:
+  # Ensure the .pdb is created with the same name and in the same directory
+  # as the .lib. Newer VS versions already do this by default, but there is no
+  # harm in setting it for those too. Ignored by other generators.
+  COMPILE_PDB_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}"
+  COMPILE_PDB_NAME "fmt"
+  COMPILE_PDB_NAME_DEBUG "fmt${FMT_DEBUG_POSTFIX}")
+
+# Set FMT_LIB_NAME for pkg-config fmt.pc. We cannot use the OUTPUT_NAME target
+# property because it's not set by default.
+set(FMT_LIB_NAME fmt)
+if (CMAKE_BUILD_TYPE STREQUAL "Debug")
+  set(FMT_LIB_NAME ${FMT_LIB_NAME}${FMT_DEBUG_POSTFIX})
+endif ()
+
+if (BUILD_SHARED_LIBS)
+  target_compile_definitions(fmt PRIVATE FMT_LIB_EXPORT INTERFACE FMT_SHARED)
+endif ()
+if (FMT_SAFE_DURATION_CAST)
+  target_compile_definitions(fmt PUBLIC FMT_SAFE_DURATION_CAST)
+endif ()
+
+add_library(fmt-header-only INTERFACE)
+add_library(fmt::fmt-header-only ALIAS fmt-header-only)
+
+target_compile_definitions(fmt-header-only INTERFACE FMT_HEADER_ONLY=1)
+target_compile_features(fmt-header-only INTERFACE cxx_std_11)
+
+target_include_directories(fmt-header-only
+  ${FMT_SYSTEM_HEADERS_ATTRIBUTE} INTERFACE
+  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
+  $<INSTALL_INTERFACE:${FMT_INC_DIR}>)
+
+# Install targets.
+if (FMT_INSTALL)
+  include(CMakePackageConfigHelpers)
+  set_verbose(FMT_CMAKE_DIR ${CMAKE_INSTALL_LIBDIR}/cmake/fmt CACHE STRING
+              "Installation directory for cmake files, a relative path that "
+              "will be joined with ${CMAKE_INSTALL_PREFIX} or an absolute "
+              "path.")
+  set(version_config ${PROJECT_BINARY_DIR}/fmt-config-version.cmake)
+  set(project_config ${PROJECT_BINARY_DIR}/fmt-config.cmake)
+  set(pkgconfig ${PROJECT_BINARY_DIR}/fmt.pc)
+  set(targets_export_name fmt-targets)
+
+  set_verbose(FMT_LIB_DIR ${CMAKE_INSTALL_LIBDIR} CACHE STRING
+              "Installation directory for libraries, a relative path that "
+              "will be joined to ${CMAKE_INSTALL_PREFIX} or an absolute path.")
+
+  set_verbose(FMT_PKGCONFIG_DIR ${CMAKE_INSTALL_LIBDIR}/pkgconfig CACHE STRING
+              "Installation directory for pkgconfig (.pc) files, a relative "
+              "path that will be joined with ${CMAKE_INSTALL_PREFIX} or an "
+              "absolute path.")
+
+  # Generate the version, config and target files into the build directory.
+  write_basic_package_version_file(
+    ${version_config}
+    VERSION ${FMT_VERSION}
+    COMPATIBILITY AnyNewerVersion)
+
+  join_paths(libdir_for_pc_file "\${exec_prefix}" "${FMT_LIB_DIR}")
+  join_paths(includedir_for_pc_file "\${prefix}" "${FMT_INC_DIR}")
+
+  configure_file(
+    "${PROJECT_SOURCE_DIR}/support/cmake/fmt.pc.in"
+    "${pkgconfig}"
+    @ONLY)
+  configure_package_config_file(
+    ${PROJECT_SOURCE_DIR}/support/cmake/fmt-config.cmake.in
+    ${project_config}
+    INSTALL_DESTINATION ${FMT_CMAKE_DIR})
+
+  set(INSTALL_TARGETS fmt fmt-header-only)
+
+  # Install the library and headers.
+  install(TARGETS ${INSTALL_TARGETS} EXPORT ${targets_export_name}
+          LIBRARY DESTINATION ${FMT_LIB_DIR}
+          ARCHIVE DESTINATION ${FMT_LIB_DIR}
+          PUBLIC_HEADER DESTINATION "${FMT_INC_DIR}/fmt"
+          RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+
+  # Use a namespace because CMake provides better diagnostics for namespaced
+  # imported targets.
+  export(TARGETS ${INSTALL_TARGETS} NAMESPACE fmt::
+         FILE ${PROJECT_BINARY_DIR}/${targets_export_name}.cmake)
+
+  # Install version, config and target files.
+  install(
+    FILES ${project_config} ${version_config}
+    DESTINATION ${FMT_CMAKE_DIR})
+  install(EXPORT ${targets_export_name} DESTINATION ${FMT_CMAKE_DIR}
+          NAMESPACE fmt::)
+
+  install(FILES "${pkgconfig}" DESTINATION "${FMT_PKGCONFIG_DIR}")
+endif ()
+
+if (FMT_DOC)
+  add_subdirectory(doc)
+endif ()
+
+if (FMT_TEST)
+  enable_testing()
+  add_subdirectory(test)
+endif ()
+
+# Control fuzzing independent of the unit tests.
+if (FMT_FUZZ)
+  add_subdirectory(test/fuzzing)
+
+  # The FMT_FUZZ macro is used to prevent resource exhaustion in fuzzing
+  # mode and make fuzzing practically possible. It is similar to
+  # FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION but uses a different name to
+  # avoid interfering with fuzzing of projects that use {fmt}.
+  # See also https://llvm.org/docs/LibFuzzer.html#fuzzer-friendly-build-mode.
+  target_compile_definitions(fmt PUBLIC FMT_FUZZ)
+endif ()
+
+set(gitignore ${PROJECT_SOURCE_DIR}/.gitignore)
+if (FMT_MASTER_PROJECT AND EXISTS ${gitignore})
+  # Get the list of ignored files from .gitignore.
+  file (STRINGS ${gitignore} lines)
+  list(REMOVE_ITEM lines /doc/html)
+  foreach (line ${lines})
+    string(REPLACE "." "[.]" line "${line}")
+    string(REPLACE "*" ".*" line "${line}")
+    set(ignored_files ${ignored_files} "${line}$" "${line}/")
+  endforeach ()
+  set(ignored_files ${ignored_files}
+    /.git /breathe /format-benchmark sphinx/ .buildinfo .doctrees)
+
+  set(CPACK_SOURCE_GENERATOR ZIP)
+  set(CPACK_SOURCE_IGNORE_FILES ${ignored_files})
+  set(CPACK_SOURCE_PACKAGE_FILE_NAME fmt-${FMT_VERSION})
+  set(CPACK_PACKAGE_NAME fmt)
+  set(CPACK_RESOURCE_FILE_README ${PROJECT_SOURCE_DIR}/README.md)
+  include(CPack)
+endif ()

dep/fmt/CONTRIBUTING.md

@@ -0,0 +1,20 @@
+Contributing to {fmt}
+=====================
+
+By submitting a pull request or a patch, you represent that you have the right
+to license your contribution to the {fmt} project owners and the community,
+agree that your contributions are licensed under the {fmt} license, and agree
+to future changes to the licensing.
+
+All C++ code must adhere to [Google C++ Style Guide](
+https://google.github.io/styleguide/cppguide.html) with the following
+exceptions:
+
+* Exceptions are permitted
+* snake_case should be used instead of UpperCamelCase for function and type
+  names
+
+All documentation must adhere to the [Google Developer Documentation Style
+Guide](https://developers.google.com/style).
+
+Thanks for contributing!

dep/fmt/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2012 - present, Victor Zverovich and {fmt} contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+--- Optional exception to the license ---
+
+As an exception, if, as a result of your compiling your source code, portions
+of this Software are embedded into a machine-executable object form of such
+source code, you may redistribute such embedded portions in such object form
+without including the above copyright and permission notices.

dep/fmt/README.md

@@ -0,0 +1,490 @@
+<img src="https://user-images.githubusercontent.com/576385/156254208-f5b743a9-88cf-439d-b0c0-923d53e8d551.png" alt="{fmt}" width="25%"/>
+
+[![image](https://github.com/fmtlib/fmt/workflows/linux/badge.svg)](https://github.com/fmtlib/fmt/actions?query=workflow%3Alinux)
+[![image](https://github.com/fmtlib/fmt/workflows/macos/badge.svg)](https://github.com/fmtlib/fmt/actions?query=workflow%3Amacos)
+[![image](https://github.com/fmtlib/fmt/workflows/windows/badge.svg)](https://github.com/fmtlib/fmt/actions?query=workflow%3Awindows)
+[![fmt is continuously fuzzed at oss-fuzz](https://oss-fuzz-build-logs.storage.googleapis.com/badges/fmt.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?\%0Acolspec=ID%20Type%20Component%20Status%20Proj%20Reported%20Owner%20\%0ASummary&q=proj%3Dfmt&can=1)
+[![Ask questions at StackOverflow with the tag fmt](https://img.shields.io/badge/stackoverflow-fmt-blue.svg)](https://stackoverflow.com/questions/tagged/fmt)
+[![image](https://api.securityscorecards.dev/projects/github.com/fmtlib/fmt/badge)](https://securityscorecards.dev/viewer/?uri=github.com/fmtlib/fmt)
+
+**{fmt}** is an open-source formatting library providing a fast and safe
+alternative to C stdio and C++ iostreams.
+
+If you like this project, please consider donating to one of the funds
+that help victims of the war in Ukraine: <https://www.stopputin.net/>.
+
+[Documentation](https://fmt.dev)
+
+[Cheat Sheets](https://hackingcpp.com/cpp/libs/fmt.html)
+
+Q&A: ask questions on [StackOverflow with the tag
+fmt](https://stackoverflow.com/questions/tagged/fmt).
+
+Try {fmt} in [Compiler Explorer](https://godbolt.org/z/Eq5763).
+
+# Features
+
+- Simple [format API](https://fmt.dev/latest/api.html) with positional
+  arguments for localization
+- Implementation of [C++20
+  std::format](https://en.cppreference.com/w/cpp/utility/format) and
+  [C++23 std::print](https://en.cppreference.com/w/cpp/io/print)
+- [Format string syntax](https://fmt.dev/latest/syntax.html) similar
+  to Python\'s
+  [format](https://docs.python.org/3/library/stdtypes.html#str.format)
+- Fast IEEE 754 floating-point formatter with correct rounding,
+  shortness and round-trip guarantees using the
+  [Dragonbox](https://github.com/jk-jeon/dragonbox) algorithm
+- Portable Unicode support
+- Safe [printf
+  implementation](https://fmt.dev/latest/api.html#printf-formatting)
+  including the POSIX extension for positional arguments
+- Extensibility: [support for user-defined
+  types](https://fmt.dev/latest/api.html#formatting-user-defined-types)
+- High performance: faster than common standard library
+  implementations of `(s)printf`, iostreams, `to_string` and
+  `to_chars`, see [Speed tests](#speed-tests) and [Converting a
+  hundred million integers to strings per
+  second](http://www.zverovich.net/2020/06/13/fast-int-to-string-revisited.html)
+- Small code size both in terms of source code with the minimum
+  configuration consisting of just three files, `core.h`, `format.h`
+  and `format-inl.h`, and compiled code; see [Compile time and code
+  bloat](#compile-time-and-code-bloat)
+- Reliability: the library has an extensive set of
+  [tests](https://github.com/fmtlib/fmt/tree/master/test) and is
+  [continuously fuzzed](https://bugs.chromium.org/p/oss-fuzz/issues/list?colspec=ID%20Type%20Component%20Status%20Proj%20Reported%20Owner%20Summary&q=proj%3Dfmt&can=1)
+- Safety: the library is fully type-safe, errors in format strings can
+  be reported at compile time, automatic memory management prevents
+  buffer overflow errors
+- Ease of use: small self-contained code base, no external
+  dependencies, permissive MIT
+  [license](https://github.com/fmtlib/fmt/blob/master/LICENSE.rst)
+- [Portability](https://fmt.dev/latest/index.html#portability) with
+  consistent output across platforms and support for older compilers
+- Clean warning-free codebase even on high warning levels such as
+  `-Wall -Wextra -pedantic`
+- Locale independence by default
+- Optional header-only configuration enabled with the
+  `FMT_HEADER_ONLY` macro
+
+See the [documentation](https://fmt.dev) for more details.
+
+# Examples
+
+**Print to stdout** ([run](https://godbolt.org/z/Tevcjh))
+
+``` c++
+#include <fmt/core.h>
+
+int main() {
+  fmt::print("Hello, world!\n");
+}
+```
+
+**Format a string** ([run](https://godbolt.org/z/oK8h33))
+
+``` c++
+std::string s = fmt::format("The answer is {}.", 42);
+// s == "The answer is 42."
+```
+
+**Format a string using positional arguments**
+([run](https://godbolt.org/z/Yn7Txe))
+
+``` c++
+std::string s = fmt::format("I'd rather be {1} than {0}.", "right", "happy");
+// s == "I'd rather be happy than right."
+```
+
+**Print dates and times** ([run](https://godbolt.org/z/c31ExdY3W))
+
+``` c++
+#include <fmt/chrono.h>
+
+int main() {
+  auto now = std::chrono::system_clock::now();
+  fmt::print("Date and time: {}\n", now);
+  fmt::print("Time: {:%H:%M}\n", now);
+}
+```
+
+Output:
+
+    Date and time: 2023-12-26 19:10:31.557195597
+    Time: 19:10
+
+**Print a container** ([run](https://godbolt.org/z/MxM1YqjE7))
+
+``` c++
+#include <vector>
+#include <fmt/ranges.h>
+
+int main() {
+  std::vector<int> v = {1, 2, 3};
+  fmt::print("{}\n", v);
+}
+```
+
+Output:
+
+    [1, 2, 3]
+
+**Check a format string at compile time**
+
+``` c++
+std::string s = fmt::format("{:d}", "I am not a number");
+```
+
+This gives a compile-time error in C++20 because `d` is an invalid
+format specifier for a string.
+
+**Write a file from a single thread**
+
+``` c++
+#include <fmt/os.h>
+
+int main() {
+  auto out = fmt::output_file("guide.txt");
+  out.print("Don't {}", "Panic");
+}
+```
+
+This can be [5 to 9 times faster than
+fprintf](http://www.zverovich.net/2020/08/04/optimal-file-buffer-size.html).
+
+**Print with colors and text styles**
+
+``` c++
+#include <fmt/color.h>
+
+int main() {
+  fmt::print(fg(fmt::color::crimson) | fmt::emphasis::bold,
+             "Hello, {}!\n", "world");
+  fmt::print(fg(fmt::color::floral_white) | bg(fmt::color::slate_gray) |
+             fmt::emphasis::underline, "Olá, {}!\n", "Mundo");
+  fmt::print(fg(fmt::color::steel_blue) | fmt::emphasis::italic,
+             "你好{}！\n", "世界");
+}
+```
+
+Output on a modern terminal with Unicode support:
+
+![image](https://github.com/fmtlib/fmt/assets/%0A576385/2a93c904-d6fa-4aa6-b453-2618e1c327d7)
+
+# Benchmarks
+
+## Speed tests
+
+| Library           | Method        | Run Time, s |
+|-------------------|---------------|-------------|
+| libc              | printf        |   0.91      |
+| libc++            | std::ostream  |   2.49      |
+| {fmt} 9.1         | fmt::print    |   0.74      |
+| Boost Format 1.80 | boost::format |   6.26      |
+| Folly Format      | folly::format |   1.87      |
+
+{fmt} is the fastest of the benchmarked methods, \~20% faster than
+`printf`.
+
+The above results were generated by building `tinyformat_test.cpp` on
+macOS 12.6.1 with `clang++ -O3 -DNDEBUG -DSPEED_TEST -DHAVE_FORMAT`, and
+taking the best of three runs. In the test, the format string
+`"%0.10f:%04d:%+g:%s:%p:%c:%%\n"` or equivalent is filled 2,000,000
+times with output sent to `/dev/null`; for further details refer to the
+[source](https://github.com/fmtlib/format-benchmark/blob/master/src/tinyformat-test.cc).
+
+{fmt} is up to 20-30x faster than `std::ostringstream` and `sprintf` on
+IEEE754 `float` and `double` formatting
+([dtoa-benchmark](https://github.com/fmtlib/dtoa-benchmark)) and faster
+than [double-conversion](https://github.com/google/double-conversion)
+and [ryu](https://github.com/ulfjack/ryu):
+
+[![image](https://user-images.githubusercontent.com/576385/95684665-11719600-0ba8-11eb-8e5b-972ff4e49428.png)](https://fmt.dev/unknown_mac64_clang12.0.html)
+
+## Compile time and code bloat
+
+The script
+[bloat-test.py](https://github.com/fmtlib/format-benchmark/blob/master/bloat-test.py)
+from [format-benchmark](https://github.com/fmtlib/format-benchmark)
+tests compile time and code bloat for nontrivial projects. It generates
+100 translation units and uses `printf()` or its alternative five times
+in each to simulate a medium-sized project. The resulting executable
+size and compile time (Apple LLVM version 8.1.0 (clang-802.0.42), macOS
+Sierra, best of three) is shown in the following tables.
+
+**Optimized build (-O3)**
+
+| Method        | Compile Time, s | Executable size, KiB | Stripped size, KiB |
+|---------------|-----------------|----------------------|--------------------|
+| printf        |   2.6           |   29                 |   26               |
+| printf+string |   16.4          |   29                 |   26               |
+| iostreams     |   31.1          |   59                 |   55               |
+| {fmt}         |   19.0          |   37                 |   34               |
+| Boost Format  |   91.9          |   226                |   203              |
+| Folly Format  |   115.7         |   101                |   88               |
+
+As you can see, {fmt} has 60% less overhead in terms of resulting binary
+code size compared to iostreams and comes pretty close to `printf`.
+Boost Format and Folly Format have the largest overheads.
+
+`printf+string` is the same as `printf` but with an extra `<string>`
+include to measure the overhead of the latter.
+
+**Non-optimized build**
+
+| Method        | Compile Time, s | Executable size, KiB | Stripped size, KiB |
+|---------------|-----------------|----------------------|--------------------|
+| printf        |   2.2           |   33                 |   30               |
+| printf+string |   16.0          |   33                 |   30               |
+| iostreams     |   28.3          |   56                 |   52               |
+| {fmt}         |   18.2          |   59                 |   50               |
+| Boost Format  |   54.1          |   365                |   303              |
+| Folly Format  |   79.9          |   445                |   430              |
+
+`libc`, `lib(std)c++`, and `libfmt` are all linked as shared libraries
+to compare formatting function overhead only. Boost Format is a
+header-only library so it doesn\'t provide any linkage options.
+
+## Running the tests
+
+Please refer to [Building the
+library](https://fmt.dev/latest/usage.html#building-the-library) for
+instructions on how to build the library and run the unit tests.
+
+Benchmarks reside in a separate repository,
+[format-benchmarks](https://github.com/fmtlib/format-benchmark), so to
+run the benchmarks you first need to clone this repository and generate
+Makefiles with CMake:
+
+    $ git clone --recursive https://github.com/fmtlib/format-benchmark.git
+    $ cd format-benchmark
+    $ cmake .
+
+Then you can run the speed test:
+
+    $ make speed-test
+
+or the bloat test:
+
+    $ make bloat-test
+
+# Migrating code
+
+[clang-tidy](https://clang.llvm.org/extra/clang-tidy/) v17 (not yet
+released) provides the
+[modernize-use-std-print](https://clang.llvm.org/extra/clang-tidy/checks/modernize/use-std-print.html)
+check that is capable of converting occurrences of `printf` and
+`fprintf` to `fmt::print` if configured to do so. (By default it
+converts to `std::print`.)
+
+# Notable projects using this library
+
+- [0 A.D.](https://play0ad.com/): a free, open-source, cross-platform
+  real-time strategy game
+- [AMPL/MP](https://github.com/ampl/mp): an open-source library for
+  mathematical programming
+- [Apple's FoundationDB](https://github.com/apple/foundationdb): an open-source,
+  distributed, transactional key-value store
+- [Aseprite](https://github.com/aseprite/aseprite): animated sprite
+  editor & pixel art tool
+- [AvioBook](https://www.aviobook.aero/en): a comprehensive aircraft
+  operations suite
+- [Blizzard Battle.net](https://battle.net/): an online gaming
+  platform
+- [Celestia](https://celestia.space/): real-time 3D visualization of
+  space
+- [Ceph](https://ceph.com/): a scalable distributed storage system
+- [ccache](https://ccache.dev/): a compiler cache
+- [ClickHouse](https://github.com/ClickHouse/ClickHouse): an
+  analytical database management system
+- [Contour](https://github.com/contour-terminal/contour/): a modern
+  terminal emulator
+- [CUAUV](https://cuauv.org/): Cornell University\'s autonomous
+  underwater vehicle
+- [Drake](https://drake.mit.edu/): a planning, control, and analysis
+  toolbox for nonlinear dynamical systems (MIT)
+- [Envoy](https://lyft.github.io/envoy/): C++ L7 proxy and
+  communication bus (Lyft)
+- [FiveM](https://fivem.net/): a modification framework for GTA V
+- [fmtlog](https://github.com/MengRao/fmtlog): a performant
+  fmtlib-style logging library with latency in nanoseconds
+- [Folly](https://github.com/facebook/folly): Facebook open-source
+  library
+- [GemRB](https://gemrb.org/): a portable open-source implementation
+  of Bioware's Infinity Engine
+- [Grand Mountain
+  Adventure](https://store.steampowered.com/app/1247360/Grand_Mountain_Adventure/):
+  a beautiful open-world ski & snowboarding game
+- [HarpyWar/pvpgn](https://github.com/pvpgn/pvpgn-server): Player vs
+  Player Gaming Network with tweaks
+- [KBEngine](https://github.com/kbengine/kbengine): an open-source
+  MMOG server engine
+- [Keypirinha](https://keypirinha.com/): a semantic launcher for
+  Windows
+- [Kodi](https://kodi.tv/) (formerly xbmc): home theater software
+- [Knuth](https://kth.cash/): high-performance Bitcoin full-node
+- [libunicode](https://github.com/contour-terminal/libunicode/): a
+  modern C++17 Unicode library
+- [MariaDB](https://mariadb.org/): relational database management
+  system
+- [Microsoft Verona](https://github.com/microsoft/verona): research
+  programming language for concurrent ownership
+- [MongoDB](https://mongodb.com/): distributed document database
+- [MongoDB Smasher](https://github.com/duckie/mongo_smasher): a small
+  tool to generate randomized datasets
+- [OpenSpace](https://openspaceproject.com/): an open-source
+  astrovisualization framework
+- [PenUltima Online (POL)](https://www.polserver.com/): an MMO server,
+  compatible with most Ultima Online clients
+- [PyTorch](https://github.com/pytorch/pytorch): an open-source
+  machine learning library
+- [quasardb](https://www.quasardb.net/): a distributed,
+  high-performance, associative database
+- [Quill](https://github.com/odygrd/quill): asynchronous low-latency
+  logging library
+- [QKW](https://github.com/ravijanjam/qkw): generalizing aliasing to
+  simplify navigation, and executing complex multi-line terminal
+  command sequences
+- [redis-cerberus](https://github.com/HunanTV/redis-cerberus): a Redis
+  cluster proxy
+- [redpanda](https://vectorized.io/redpanda): a 10x faster Kafka®
+  replacement for mission-critical systems written in C++
+- [rpclib](http://rpclib.net/): a modern C++ msgpack-RPC server and
+  client library
+- [Salesforce Analytics
+  Cloud](https://www.salesforce.com/analytics-cloud/overview/):
+  business intelligence software
+- [Scylla](https://www.scylladb.com/): a Cassandra-compatible NoSQL
+  data store that can handle 1 million transactions per second on a
+  single server
+- [Seastar](http://www.seastar-project.org/): an advanced, open-source
+  C++ framework for high-performance server applications on modern
+  hardware
+- [spdlog](https://github.com/gabime/spdlog): super fast C++ logging
+  library
+- [Stellar](https://www.stellar.org/): financial platform
+- [Touch Surgery](https://www.touchsurgery.com/): surgery simulator
+- [TrinityCore](https://github.com/TrinityCore/TrinityCore):
+  open-source MMORPG framework
+- [🐙 userver framework](https://userver.tech/): open-source
+  asynchronous framework with a rich set of abstractions and database
+  drivers
+- [Windows Terminal](https://github.com/microsoft/terminal): the new
+  Windows terminal
+
+[More\...](https://github.com/search?q=fmtlib&type=Code)
+
+If you are aware of other projects using this library, please let me
+know by [email](mailto:victor.zverovich@gmail.com) or by submitting an
+[issue](https://github.com/fmtlib/fmt/issues).
+
+# Motivation
+
+So why yet another formatting library?
+
+There are plenty of methods for doing this task, from standard ones like
+the printf family of function and iostreams to Boost Format and
+FastFormat libraries. The reason for creating a new library is that
+every existing solution that I found either had serious issues or
+didn\'t provide all the features I needed.
+
+## printf
+
+The good thing about `printf` is that it is pretty fast and readily
+available being a part of the C standard library. The main drawback is
+that it doesn\'t support user-defined types. `printf` also has safety
+issues although they are somewhat mitigated with [\_\_attribute\_\_
+((format (printf,
+\...))](https://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html) in
+GCC. There is a POSIX extension that adds positional arguments required
+for
+[i18n](https://en.wikipedia.org/wiki/Internationalization_and_localization)
+to `printf` but it is not a part of C99 and may not be available on some
+platforms.
+
+## iostreams
+
+The main issue with iostreams is best illustrated with an example:
+
+``` c++
+std::cout << std::setprecision(2) << std::fixed << 1.23456 << "\n";
+```
+
+which is a lot of typing compared to printf:
+
+``` c++
+printf("%.2f\n", 1.23456);
+```
+
+Matthew Wilson, the author of FastFormat, called this \"chevron hell\".
+iostreams don\'t support positional arguments by design.
+
+The good part is that iostreams support user-defined types and are safe
+although error handling is awkward.
+
+## Boost Format
+
+This is a very powerful library that supports both `printf`-like format
+strings and positional arguments. Its main drawback is performance.
+According to various benchmarks, it is much slower than other methods
+considered here. Boost Format also has excessive build times and severe
+code bloat issues (see [Benchmarks](#benchmarks)).
+
+## FastFormat
+
+This is an interesting library that is fast, safe, and has positional
+arguments. However, it has significant limitations, citing its author:
+
+> Three features that have no hope of being accommodated within the
+> current design are:
+>
+> - Leading zeros (or any other non-space padding)
+> - Octal/hexadecimal encoding
+> - Runtime width/alignment specification
+
+It is also quite big and has a heavy dependency, STLSoft, which might be
+too restrictive for using it in some projects.
+
+## Boost Spirit.Karma
+
+This is not a formatting library but I decided to include it here for
+completeness. As iostreams, it suffers from the problem of mixing
+verbatim text with arguments. The library is pretty fast, but slower on
+integer formatting than `fmt::format_to` with format string compilation
+on Karma\'s own benchmark, see [Converting a hundred million integers to
+strings per
+second](http://www.zverovich.net/2020/06/13/fast-int-to-string-revisited.html).
+
+# License
+
+{fmt} is distributed under the MIT
+[license](https://github.com/fmtlib/fmt/blob/master/LICENSE).
+
+# Documentation License
+
+The [Format String Syntax](https://fmt.dev/latest/syntax.html) section
+in the documentation is based on the one from Python [string module
+documentation](https://docs.python.org/3/library/string.html#module-string).
+For this reason, the documentation is distributed under the Python
+Software Foundation license available in
+[doc/python-license.txt](https://raw.github.com/fmtlib/fmt/master/doc/python-license.txt).
+It only applies if you distribute the documentation of {fmt}.
+
+# Maintainers
+
+The {fmt} library is maintained by Victor Zverovich
+([vitaut](https://github.com/vitaut)) with contributions from many other
+people. See
+[Contributors](https://github.com/fmtlib/fmt/graphs/contributors) and
+[Releases](https://github.com/fmtlib/fmt/releases) for some of the
+names. Let us know if your contribution is not listed or mentioned
+incorrectly and we\'ll make it right.
+
+# Security Policy
+
+To report a security issue, please disclose it at [security
+advisory](https://github.com/fmtlib/fmt/security/advisories/new).
+
+This project is maintained by a team of volunteers on a
+reasonable-effort basis. As such, please give us at least 90 days to
+work on a fix before public exposure.

dep/fmt/UPSTREAM.md

@@ -0,0 +1,2 @@
+This is a pruned version of fmt 10.2.1, obtained from
+https://github.com/fmtlib/fmt/releases/tag/10.2.1.

dep/fmt/build.py

@@ -0,0 +1,18 @@
+from build.c import cxxlibrary, HostToolchain
+
+cxxlibrary(
+    name="fmt",
+    srcs=[
+        "./src/format.cc",
+        "./src/os.cc",
+    ],
+    cflags=["-Idep/fmt/include"],
+    hdrs={
+        "fmt/args.h": "./include/fmt/args.h",
+        "fmt/chrono.h": "./include/fmt/chrono.h",
+        "fmt/core.h": "./include/fmt/core.h",
+        "fmt/format.h": "./include/fmt/format.h",
+        "fmt/ostream.h": "./include/fmt/ostream.h",
+        "fmt/ranges.h": "./include/fmt/ranges.h",
+    },
+)

dep/fmt/include/fmt/args.h

@@ -0,0 +1,235 @@
+// Formatting library for C++ - dynamic argument lists
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_ARGS_H_
+#define FMT_ARGS_H_
+
+#include <functional>  // std::reference_wrapper
+#include <memory>      // std::unique_ptr
+#include <vector>
+
+#include "core.h"
+
+FMT_BEGIN_NAMESPACE
+
+namespace detail {
+
+template <typename T> struct is_reference_wrapper : std::false_type {};
+template <typename T>
+struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {};
+
+template <typename T> auto unwrap(const T& v) -> const T& { return v; }
+template <typename T>
+auto unwrap(const std::reference_wrapper<T>& v) -> const T& {
+  return static_cast<const T&>(v);
+}
+
+class dynamic_arg_list {
+  // Workaround for clang's -Wweak-vtables. Unlike for regular classes, for
+  // templates it doesn't complain about inability to deduce single translation
+  // unit for placing vtable. So storage_node_base is made a fake template.
+  template <typename = void> struct node {
+    virtual ~node() = default;
+    std::unique_ptr<node<>> next;
+  };
+
+  template <typename T> struct typed_node : node<> {
+    T value;
+
+    template <typename Arg>
+    FMT_CONSTEXPR typed_node(const Arg& arg) : value(arg) {}
+
+    template <typename Char>
+    FMT_CONSTEXPR typed_node(const basic_string_view<Char>& arg)
+        : value(arg.data(), arg.size()) {}
+  };
+
+  std::unique_ptr<node<>> head_;
+
+ public:
+  template <typename T, typename Arg> auto push(const Arg& arg) -> const T& {
+    auto new_node = std::unique_ptr<typed_node<T>>(new typed_node<T>(arg));
+    auto& value = new_node->value;
+    new_node->next = std::move(head_);
+    head_ = std::move(new_node);
+    return value;
+  }
+};
+}  // namespace detail
+
+/**
+  \rst
+  A dynamic version of `fmt::format_arg_store`.
+  It's equipped with a storage to potentially temporary objects which lifetimes
+  could be shorter than the format arguments object.
+
+  It can be implicitly converted into `~fmt::basic_format_args` for passing
+  into type-erased formatting functions such as `~fmt::vformat`.
+  \endrst
+ */
+template <typename Context>
+class dynamic_format_arg_store
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+    // Workaround a GCC template argument substitution bug.
+    : public basic_format_args<Context>
+#endif
+{
+ private:
+  using char_type = typename Context::char_type;
+
+  template <typename T> struct need_copy {
+    static constexpr detail::type mapped_type =
+        detail::mapped_type_constant<T, Context>::value;
+
+    enum {
+      value = !(detail::is_reference_wrapper<T>::value ||
+                std::is_same<T, basic_string_view<char_type>>::value ||
+                std::is_same<T, detail::std_string_view<char_type>>::value ||
+                (mapped_type != detail::type::cstring_type &&
+                 mapped_type != detail::type::string_type &&
+                 mapped_type != detail::type::custom_type))
+    };
+  };
+
+  template <typename T>
+  using stored_type = conditional_t<
+      std::is_convertible<T, std::basic_string<char_type>>::value &&
+          !detail::is_reference_wrapper<T>::value,
+      std::basic_string<char_type>, T>;
+
+  // Storage of basic_format_arg must be contiguous.
+  std::vector<basic_format_arg<Context>> data_;
+  std::vector<detail::named_arg_info<char_type>> named_info_;
+
+  // Storage of arguments not fitting into basic_format_arg must grow
+  // without relocation because items in data_ refer to it.
+  detail::dynamic_arg_list dynamic_args_;
+
+  friend class basic_format_args<Context>;
+
+  auto get_types() const -> unsigned long long {
+    return detail::is_unpacked_bit | data_.size() |
+           (named_info_.empty()
+                ? 0ULL
+                : static_cast<unsigned long long>(detail::has_named_args_bit));
+  }
+
+  auto data() const -> const basic_format_arg<Context>* {
+    return named_info_.empty() ? data_.data() : data_.data() + 1;
+  }
+
+  template <typename T> void emplace_arg(const T& arg) {
+    data_.emplace_back(detail::make_arg<Context>(arg));
+  }
+
+  template <typename T>
+  void emplace_arg(const detail::named_arg<char_type, T>& arg) {
+    if (named_info_.empty()) {
+      constexpr const detail::named_arg_info<char_type>* zero_ptr{nullptr};
+      data_.insert(data_.begin(), {zero_ptr, 0});
+    }
+    data_.emplace_back(detail::make_arg<Context>(detail::unwrap(arg.value)));
+    auto pop_one = [](std::vector<basic_format_arg<Context>>* data) {
+      data->pop_back();
+    };
+    std::unique_ptr<std::vector<basic_format_arg<Context>>, decltype(pop_one)>
+        guard{&data_, pop_one};
+    named_info_.push_back({arg.name, static_cast<int>(data_.size() - 2u)});
+    data_[0].value_.named_args = {named_info_.data(), named_info_.size()};
+    guard.release();
+  }
+
+ public:
+  constexpr dynamic_format_arg_store() = default;
+
+  /**
+    \rst
+    Adds an argument into the dynamic store for later passing to a formatting
+    function.
+
+    Note that custom types and string types (but not string views) are copied
+    into the store dynamically allocating memory if necessary.
+
+    **Example**::
+
+      fmt::dynamic_format_arg_store<fmt::format_context> store;
+      store.push_back(42);
+      store.push_back("abc");
+      store.push_back(1.5f);
+      std::string result = fmt::vformat("{} and {} and {}", store);
+    \endrst
+  */
+  template <typename T> void push_back(const T& arg) {
+    if (detail::const_check(need_copy<T>::value))
+      emplace_arg(dynamic_args_.push<stored_type<T>>(arg));
+    else
+      emplace_arg(detail::unwrap(arg));
+  }
+
+  /**
+    \rst
+    Adds a reference to the argument into the dynamic store for later passing to
+    a formatting function.
+
+    **Example**::
+
+      fmt::dynamic_format_arg_store<fmt::format_context> store;
+      char band[] = "Rolling Stones";
+      store.push_back(std::cref(band));
+      band[9] = 'c'; // Changing str affects the output.
+      std::string result = fmt::vformat("{}", store);
+      // result == "Rolling Scones"
+    \endrst
+  */
+  template <typename T> void push_back(std::reference_wrapper<T> arg) {
+    static_assert(
+        need_copy<T>::value,
+        "objects of built-in types and string views are always copied");
+    emplace_arg(arg.get());
+  }
+
+  /**
+    Adds named argument into the dynamic store for later passing to a formatting
+    function. ``std::reference_wrapper`` is supported to avoid copying of the
+    argument. The name is always copied into the store.
+  */
+  template <typename T>
+  void push_back(const detail::named_arg<char_type, T>& arg) {
+    const char_type* arg_name =
+        dynamic_args_.push<std::basic_string<char_type>>(arg.name).c_str();
+    if (detail::const_check(need_copy<T>::value)) {
+      emplace_arg(
+          fmt::arg(arg_name, dynamic_args_.push<stored_type<T>>(arg.value)));
+    } else {
+      emplace_arg(fmt::arg(arg_name, arg.value));
+    }
+  }
+
+  /** Erase all elements from the store */
+  void clear() {
+    data_.clear();
+    named_info_.clear();
+    dynamic_args_ = detail::dynamic_arg_list();
+  }
+
+  /**
+    \rst
+    Reserves space to store at least *new_cap* arguments including
+    *new_cap_named* named arguments.
+    \endrst
+  */
+  void reserve(size_t new_cap, size_t new_cap_named) {
+    FMT_ASSERT(new_cap >= new_cap_named,
+               "Set of arguments includes set of named arguments");
+    data_.reserve(new_cap);
+    named_info_.reserve(new_cap_named);
+  }
+};
+
+FMT_END_NAMESPACE
+
+#endif  // FMT_ARGS_H_

dep/fmt/include/fmt/color.h

@@ -0,0 +1,643 @@
+// Formatting library for C++ - color support
+//
+// Copyright (c) 2018 - present, Victor Zverovich and fmt contributors
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_COLOR_H_
+#define FMT_COLOR_H_
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+FMT_BEGIN_EXPORT
+
+enum class color : uint32_t {
+  alice_blue = 0xF0F8FF,               // rgb(240,248,255)
+  antique_white = 0xFAEBD7,            // rgb(250,235,215)
+  aqua = 0x00FFFF,                     // rgb(0,255,255)
+  aquamarine = 0x7FFFD4,               // rgb(127,255,212)
+  azure = 0xF0FFFF,                    // rgb(240,255,255)
+  beige = 0xF5F5DC,                    // rgb(245,245,220)
+  bisque = 0xFFE4C4,                   // rgb(255,228,196)
+  black = 0x000000,                    // rgb(0,0,0)
+  blanched_almond = 0xFFEBCD,          // rgb(255,235,205)
+  blue = 0x0000FF,                     // rgb(0,0,255)
+  blue_violet = 0x8A2BE2,              // rgb(138,43,226)
+  brown = 0xA52A2A,                    // rgb(165,42,42)
+  burly_wood = 0xDEB887,               // rgb(222,184,135)
+  cadet_blue = 0x5F9EA0,               // rgb(95,158,160)
+  chartreuse = 0x7FFF00,               // rgb(127,255,0)
+  chocolate = 0xD2691E,                // rgb(210,105,30)
+  coral = 0xFF7F50,                    // rgb(255,127,80)
+  cornflower_blue = 0x6495ED,          // rgb(100,149,237)
+  cornsilk = 0xFFF8DC,                 // rgb(255,248,220)
+  crimson = 0xDC143C,                  // rgb(220,20,60)
+  cyan = 0x00FFFF,                     // rgb(0,255,255)
+  dark_blue = 0x00008B,                // rgb(0,0,139)
+  dark_cyan = 0x008B8B,                // rgb(0,139,139)
+  dark_golden_rod = 0xB8860B,          // rgb(184,134,11)
+  dark_gray = 0xA9A9A9,                // rgb(169,169,169)
+  dark_green = 0x006400,               // rgb(0,100,0)
+  dark_khaki = 0xBDB76B,               // rgb(189,183,107)
+  dark_magenta = 0x8B008B,             // rgb(139,0,139)
+  dark_olive_green = 0x556B2F,         // rgb(85,107,47)
+  dark_orange = 0xFF8C00,              // rgb(255,140,0)
+  dark_orchid = 0x9932CC,              // rgb(153,50,204)
+  dark_red = 0x8B0000,                 // rgb(139,0,0)
+  dark_salmon = 0xE9967A,              // rgb(233,150,122)
+  dark_sea_green = 0x8FBC8F,           // rgb(143,188,143)
+  dark_slate_blue = 0x483D8B,          // rgb(72,61,139)
+  dark_slate_gray = 0x2F4F4F,          // rgb(47,79,79)
+  dark_turquoise = 0x00CED1,           // rgb(0,206,209)
+  dark_violet = 0x9400D3,              // rgb(148,0,211)
+  deep_pink = 0xFF1493,                // rgb(255,20,147)
+  deep_sky_blue = 0x00BFFF,            // rgb(0,191,255)
+  dim_gray = 0x696969,                 // rgb(105,105,105)
+  dodger_blue = 0x1E90FF,              // rgb(30,144,255)
+  fire_brick = 0xB22222,               // rgb(178,34,34)
+  floral_white = 0xFFFAF0,             // rgb(255,250,240)
+  forest_green = 0x228B22,             // rgb(34,139,34)
+  fuchsia = 0xFF00FF,                  // rgb(255,0,255)
+  gainsboro = 0xDCDCDC,                // rgb(220,220,220)
+  ghost_white = 0xF8F8FF,              // rgb(248,248,255)
+  gold = 0xFFD700,                     // rgb(255,215,0)
+  golden_rod = 0xDAA520,               // rgb(218,165,32)
+  gray = 0x808080,                     // rgb(128,128,128)
+  green = 0x008000,                    // rgb(0,128,0)
+  green_yellow = 0xADFF2F,             // rgb(173,255,47)
+  honey_dew = 0xF0FFF0,                // rgb(240,255,240)
+  hot_pink = 0xFF69B4,                 // rgb(255,105,180)
+  indian_red = 0xCD5C5C,               // rgb(205,92,92)
+  indigo = 0x4B0082,                   // rgb(75,0,130)
+  ivory = 0xFFFFF0,                    // rgb(255,255,240)
+  khaki = 0xF0E68C,                    // rgb(240,230,140)
+  lavender = 0xE6E6FA,                 // rgb(230,230,250)
+  lavender_blush = 0xFFF0F5,           // rgb(255,240,245)
+  lawn_green = 0x7CFC00,               // rgb(124,252,0)
+  lemon_chiffon = 0xFFFACD,            // rgb(255,250,205)
+  light_blue = 0xADD8E6,               // rgb(173,216,230)
+  light_coral = 0xF08080,              // rgb(240,128,128)
+  light_cyan = 0xE0FFFF,               // rgb(224,255,255)
+  light_golden_rod_yellow = 0xFAFAD2,  // rgb(250,250,210)
+  light_gray = 0xD3D3D3,               // rgb(211,211,211)
+  light_green = 0x90EE90,              // rgb(144,238,144)
+  light_pink = 0xFFB6C1,               // rgb(255,182,193)
+  light_salmon = 0xFFA07A,             // rgb(255,160,122)
+  light_sea_green = 0x20B2AA,          // rgb(32,178,170)
+  light_sky_blue = 0x87CEFA,           // rgb(135,206,250)
+  light_slate_gray = 0x778899,         // rgb(119,136,153)
+  light_steel_blue = 0xB0C4DE,         // rgb(176,196,222)
+  light_yellow = 0xFFFFE0,             // rgb(255,255,224)
+  lime = 0x00FF00,                     // rgb(0,255,0)
+  lime_green = 0x32CD32,               // rgb(50,205,50)
+  linen = 0xFAF0E6,                    // rgb(250,240,230)
+  magenta = 0xFF00FF,                  // rgb(255,0,255)
+  maroon = 0x800000,                   // rgb(128,0,0)
+  medium_aquamarine = 0x66CDAA,        // rgb(102,205,170)
+  medium_blue = 0x0000CD,              // rgb(0,0,205)
+  medium_orchid = 0xBA55D3,            // rgb(186,85,211)
+  medium_purple = 0x9370DB,            // rgb(147,112,219)
+  medium_sea_green = 0x3CB371,         // rgb(60,179,113)
+  medium_slate_blue = 0x7B68EE,        // rgb(123,104,238)
+  medium_spring_green = 0x00FA9A,      // rgb(0,250,154)
+  medium_turquoise = 0x48D1CC,         // rgb(72,209,204)
+  medium_violet_red = 0xC71585,        // rgb(199,21,133)
+  midnight_blue = 0x191970,            // rgb(25,25,112)
+  mint_cream = 0xF5FFFA,               // rgb(245,255,250)
+  misty_rose = 0xFFE4E1,               // rgb(255,228,225)
+  moccasin = 0xFFE4B5,                 // rgb(255,228,181)
+  navajo_white = 0xFFDEAD,             // rgb(255,222,173)
+  navy = 0x000080,                     // rgb(0,0,128)
+  old_lace = 0xFDF5E6,                 // rgb(253,245,230)
+  olive = 0x808000,                    // rgb(128,128,0)
+  olive_drab = 0x6B8E23,               // rgb(107,142,35)
+  orange = 0xFFA500,                   // rgb(255,165,0)
+  orange_red = 0xFF4500,               // rgb(255,69,0)
+  orchid = 0xDA70D6,                   // rgb(218,112,214)
+  pale_golden_rod = 0xEEE8AA,          // rgb(238,232,170)
+  pale_green = 0x98FB98,               // rgb(152,251,152)
+  pale_turquoise = 0xAFEEEE,           // rgb(175,238,238)
+  pale_violet_red = 0xDB7093,          // rgb(219,112,147)
+  papaya_whip = 0xFFEFD5,              // rgb(255,239,213)
+  peach_puff = 0xFFDAB9,               // rgb(255,218,185)
+  peru = 0xCD853F,                     // rgb(205,133,63)
+  pink = 0xFFC0CB,                     // rgb(255,192,203)
+  plum = 0xDDA0DD,                     // rgb(221,160,221)
+  powder_blue = 0xB0E0E6,              // rgb(176,224,230)
+  purple = 0x800080,                   // rgb(128,0,128)
+  rebecca_purple = 0x663399,           // rgb(102,51,153)
+  red = 0xFF0000,                      // rgb(255,0,0)
+  rosy_brown = 0xBC8F8F,               // rgb(188,143,143)
+  royal_blue = 0x4169E1,               // rgb(65,105,225)
+  saddle_brown = 0x8B4513,             // rgb(139,69,19)
+  salmon = 0xFA8072,                   // rgb(250,128,114)
+  sandy_brown = 0xF4A460,              // rgb(244,164,96)
+  sea_green = 0x2E8B57,                // rgb(46,139,87)
+  sea_shell = 0xFFF5EE,                // rgb(255,245,238)
+  sienna = 0xA0522D,                   // rgb(160,82,45)
+  silver = 0xC0C0C0,                   // rgb(192,192,192)
+  sky_blue = 0x87CEEB,                 // rgb(135,206,235)
+  slate_blue = 0x6A5ACD,               // rgb(106,90,205)
+  slate_gray = 0x708090,               // rgb(112,128,144)
+  snow = 0xFFFAFA,                     // rgb(255,250,250)
+  spring_green = 0x00FF7F,             // rgb(0,255,127)
+  steel_blue = 0x4682B4,               // rgb(70,130,180)
+  tan = 0xD2B48C,                      // rgb(210,180,140)
+  teal = 0x008080,                     // rgb(0,128,128)
+  thistle = 0xD8BFD8,                  // rgb(216,191,216)
+  tomato = 0xFF6347,                   // rgb(255,99,71)
+  turquoise = 0x40E0D0,                // rgb(64,224,208)
+  violet = 0xEE82EE,                   // rgb(238,130,238)
+  wheat = 0xF5DEB3,                    // rgb(245,222,179)
+  white = 0xFFFFFF,                    // rgb(255,255,255)
+  white_smoke = 0xF5F5F5,              // rgb(245,245,245)
+  yellow = 0xFFFF00,                   // rgb(255,255,0)
+  yellow_green = 0x9ACD32              // rgb(154,205,50)
+};                                     // enum class color
+
+enum class terminal_color : uint8_t {
+  black = 30,
+  red,
+  green,
+  yellow,
+  blue,
+  magenta,
+  cyan,
+  white,
+  bright_black = 90,
+  bright_red,
+  bright_green,
+  bright_yellow,
+  bright_blue,
+  bright_magenta,
+  bright_cyan,
+  bright_white
+};
+
+enum class emphasis : uint8_t {
+  bold = 1,
+  faint = 1 << 1,
+  italic = 1 << 2,
+  underline = 1 << 3,
+  blink = 1 << 4,
+  reverse = 1 << 5,
+  conceal = 1 << 6,
+  strikethrough = 1 << 7,
+};
+
+// rgb is a struct for red, green and blue colors.
+// Using the name "rgb" makes some editors show the color in a tooltip.
+struct rgb {
+  FMT_CONSTEXPR rgb() : r(0), g(0), b(0) {}
+  FMT_CONSTEXPR rgb(uint8_t r_, uint8_t g_, uint8_t b_) : r(r_), g(g_), b(b_) {}
+  FMT_CONSTEXPR rgb(uint32_t hex)
+      : r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b(hex & 0xFF) {}
+  FMT_CONSTEXPR rgb(color hex)
+      : r((uint32_t(hex) >> 16) & 0xFF),
+        g((uint32_t(hex) >> 8) & 0xFF),
+        b(uint32_t(hex) & 0xFF) {}
+  uint8_t r;
+  uint8_t g;
+  uint8_t b;
+};
+
+namespace detail {
+
+// color is a struct of either a rgb color or a terminal color.
+struct color_type {
+  FMT_CONSTEXPR color_type() noexcept : is_rgb(), value{} {}
+  FMT_CONSTEXPR color_type(color rgb_color) noexcept : is_rgb(true), value{} {
+    value.rgb_color = static_cast<uint32_t>(rgb_color);
+  }
+  FMT_CONSTEXPR color_type(rgb rgb_color) noexcept : is_rgb(true), value{} {
+    value.rgb_color = (static_cast<uint32_t>(rgb_color.r) << 16) |
+                      (static_cast<uint32_t>(rgb_color.g) << 8) | rgb_color.b;
+  }
+  FMT_CONSTEXPR color_type(terminal_color term_color) noexcept
+      : is_rgb(), value{} {
+    value.term_color = static_cast<uint8_t>(term_color);
+  }
+  bool is_rgb;
+  union color_union {
+    uint8_t term_color;
+    uint32_t rgb_color;
+  } value;
+};
+}  // namespace detail
+
+/** A text style consisting of foreground and background colors and emphasis. */
+class text_style {
+ public:
+  FMT_CONSTEXPR text_style(emphasis em = emphasis()) noexcept
+      : set_foreground_color(), set_background_color(), ems(em) {}
+
+  FMT_CONSTEXPR auto operator|=(const text_style& rhs) -> text_style& {
+    if (!set_foreground_color) {
+      set_foreground_color = rhs.set_foreground_color;
+      foreground_color = rhs.foreground_color;
+    } else if (rhs.set_foreground_color) {
+      if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb)
+        FMT_THROW(format_error("can't OR a terminal color"));
+      foreground_color.value.rgb_color |= rhs.foreground_color.value.rgb_color;
+    }
+
+    if (!set_background_color) {
+      set_background_color = rhs.set_background_color;
+      background_color = rhs.background_color;
+    } else if (rhs.set_background_color) {
+      if (!background_color.is_rgb || !rhs.background_color.is_rgb)
+        FMT_THROW(format_error("can't OR a terminal color"));
+      background_color.value.rgb_color |= rhs.background_color.value.rgb_color;
+    }
+
+    ems = static_cast<emphasis>(static_cast<uint8_t>(ems) |
+                                static_cast<uint8_t>(rhs.ems));
+    return *this;
+  }
+
+  friend FMT_CONSTEXPR auto operator|(text_style lhs, const text_style& rhs)
+      -> text_style {
+    return lhs |= rhs;
+  }
+
+  FMT_CONSTEXPR auto has_foreground() const noexcept -> bool {
+    return set_foreground_color;
+  }
+  FMT_CONSTEXPR auto has_background() const noexcept -> bool {
+    return set_background_color;
+  }
+  FMT_CONSTEXPR auto has_emphasis() const noexcept -> bool {
+    return static_cast<uint8_t>(ems) != 0;
+  }
+  FMT_CONSTEXPR auto get_foreground() const noexcept -> detail::color_type {
+    FMT_ASSERT(has_foreground(), "no foreground specified for this style");
+    return foreground_color;
+  }
+  FMT_CONSTEXPR auto get_background() const noexcept -> detail::color_type {
+    FMT_ASSERT(has_background(), "no background specified for this style");
+    return background_color;
+  }
+  FMT_CONSTEXPR auto get_emphasis() const noexcept -> emphasis {
+    FMT_ASSERT(has_emphasis(), "no emphasis specified for this style");
+    return ems;
+  }
+
+ private:
+  FMT_CONSTEXPR text_style(bool is_foreground,
+                           detail::color_type text_color) noexcept
+      : set_foreground_color(), set_background_color(), ems() {
+    if (is_foreground) {
+      foreground_color = text_color;
+      set_foreground_color = true;
+    } else {
+      background_color = text_color;
+      set_background_color = true;
+    }
+  }
+
+  friend FMT_CONSTEXPR auto fg(detail::color_type foreground) noexcept
+      -> text_style;
+
+  friend FMT_CONSTEXPR auto bg(detail::color_type background) noexcept
+      -> text_style;
+
+  detail::color_type foreground_color;
+  detail::color_type background_color;
+  bool set_foreground_color;
+  bool set_background_color;
+  emphasis ems;
+};
+
+/** Creates a text style from the foreground (text) color. */
+FMT_CONSTEXPR inline auto fg(detail::color_type foreground) noexcept
+    -> text_style {
+  return text_style(true, foreground);
+}
+
+/** Creates a text style from the background color. */
+FMT_CONSTEXPR inline auto bg(detail::color_type background) noexcept
+    -> text_style {
+  return text_style(false, background);
+}
+
+FMT_CONSTEXPR inline auto operator|(emphasis lhs, emphasis rhs) noexcept
+    -> text_style {
+  return text_style(lhs) | rhs;
+}
+
+namespace detail {
+
+template <typename Char> struct ansi_color_escape {
+  FMT_CONSTEXPR ansi_color_escape(detail::color_type text_color,
+                                  const char* esc) noexcept {
+    // If we have a terminal color, we need to output another escape code
+    // sequence.
+    if (!text_color.is_rgb) {
+      bool is_background = esc == string_view("\x1b[48;2;");
+      uint32_t value = text_color.value.term_color;
+      // Background ASCII codes are the same as the foreground ones but with
+      // 10 more.
+      if (is_background) value += 10u;
+
+      size_t index = 0;
+      buffer[index++] = static_cast<Char>('\x1b');
+      buffer[index++] = static_cast<Char>('[');
+
+      if (value >= 100u) {
+        buffer[index++] = static_cast<Char>('1');
+        value %= 100u;
+      }
+      buffer[index++] = static_cast<Char>('0' + value / 10u);
+      buffer[index++] = static_cast<Char>('0' + value % 10u);
+
+      buffer[index++] = static_cast<Char>('m');
+      buffer[index++] = static_cast<Char>('\0');
+      return;
+    }
+
+    for (int i = 0; i < 7; i++) {
+      buffer[i] = static_cast<Char>(esc[i]);
+    }
+    rgb color(text_color.value.rgb_color);
+    to_esc(color.r, buffer + 7, ';');
+    to_esc(color.g, buffer + 11, ';');
+    to_esc(color.b, buffer + 15, 'm');
+    buffer[19] = static_cast<Char>(0);
+  }
+  FMT_CONSTEXPR ansi_color_escape(emphasis em) noexcept {
+    uint8_t em_codes[num_emphases] = {};
+    if (has_emphasis(em, emphasis::bold)) em_codes[0] = 1;
+    if (has_emphasis(em, emphasis::faint)) em_codes[1] = 2;
+    if (has_emphasis(em, emphasis::italic)) em_codes[2] = 3;
+    if (has_emphasis(em, emphasis::underline)) em_codes[3] = 4;
+    if (has_emphasis(em, emphasis::blink)) em_codes[4] = 5;
+    if (has_emphasis(em, emphasis::reverse)) em_codes[5] = 7;
+    if (has_emphasis(em, emphasis::conceal)) em_codes[6] = 8;
+    if (has_emphasis(em, emphasis::strikethrough)) em_codes[7] = 9;
+
+    size_t index = 0;
+    for (size_t i = 0; i < num_emphases; ++i) {
+      if (!em_codes[i]) continue;
+      buffer[index++] = static_cast<Char>('\x1b');
+      buffer[index++] = static_cast<Char>('[');
+      buffer[index++] = static_cast<Char>('0' + em_codes[i]);
+      buffer[index++] = static_cast<Char>('m');
+    }
+    buffer[index++] = static_cast<Char>(0);
+  }
+  FMT_CONSTEXPR operator const Char*() const noexcept { return buffer; }
+
+  FMT_CONSTEXPR auto begin() const noexcept -> const Char* { return buffer; }
+  FMT_CONSTEXPR_CHAR_TRAITS auto end() const noexcept -> const Char* {
+    return buffer + std::char_traits<Char>::length(buffer);
+  }
+
+ private:
+  static constexpr size_t num_emphases = 8;
+  Char buffer[7u + 3u * num_emphases + 1u];
+
+  static FMT_CONSTEXPR void to_esc(uint8_t c, Char* out,
+                                   char delimiter) noexcept {
+    out[0] = static_cast<Char>('0' + c / 100);
+    out[1] = static_cast<Char>('0' + c / 10 % 10);
+    out[2] = static_cast<Char>('0' + c % 10);
+    out[3] = static_cast<Char>(delimiter);
+  }
+  static FMT_CONSTEXPR auto has_emphasis(emphasis em, emphasis mask) noexcept
+      -> bool {
+    return static_cast<uint8_t>(em) & static_cast<uint8_t>(mask);
+  }
+};
+
+template <typename Char>
+FMT_CONSTEXPR auto make_foreground_color(detail::color_type foreground) noexcept
+    -> ansi_color_escape<Char> {
+  return ansi_color_escape<Char>(foreground, "\x1b[38;2;");
+}
+
+template <typename Char>
+FMT_CONSTEXPR auto make_background_color(detail::color_type background) noexcept
+    -> ansi_color_escape<Char> {
+  return ansi_color_escape<Char>(background, "\x1b[48;2;");
+}
+
+template <typename Char>
+FMT_CONSTEXPR auto make_emphasis(emphasis em) noexcept
+    -> ansi_color_escape<Char> {
+  return ansi_color_escape<Char>(em);
+}
+
+template <typename Char> inline void reset_color(buffer<Char>& buffer) {
+  auto reset_color = string_view("\x1b[0m");
+  buffer.append(reset_color.begin(), reset_color.end());
+}
+
+template <typename T> struct styled_arg : detail::view {
+  const T& value;
+  text_style style;
+  styled_arg(const T& v, text_style s) : value(v), style(s) {}
+};
+
+template <typename Char>
+void vformat_to(buffer<Char>& buf, const text_style& ts,
+                basic_string_view<Char> format_str,
+                basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  bool has_style = false;
+  if (ts.has_emphasis()) {
+    has_style = true;
+    auto emphasis = detail::make_emphasis<Char>(ts.get_emphasis());
+    buf.append(emphasis.begin(), emphasis.end());
+  }
+  if (ts.has_foreground()) {
+    has_style = true;
+    auto foreground = detail::make_foreground_color<Char>(ts.get_foreground());
+    buf.append(foreground.begin(), foreground.end());
+  }
+  if (ts.has_background()) {
+    has_style = true;
+    auto background = detail::make_background_color<Char>(ts.get_background());
+    buf.append(background.begin(), background.end());
+  }
+  detail::vformat_to(buf, format_str, args, {});
+  if (has_style) detail::reset_color<Char>(buf);
+}
+
+}  // namespace detail
+
+inline void vprint(std::FILE* f, const text_style& ts, string_view fmt,
+                   format_args args) {
+  // Legacy wide streams are not supported.
+  auto buf = memory_buffer();
+  detail::vformat_to(buf, ts, fmt, args);
+  if (detail::is_utf8()) {
+    detail::print(f, string_view(buf.begin(), buf.size()));
+    return;
+  }
+  buf.push_back('\0');
+  int result = std::fputs(buf.data(), f);
+  if (result < 0)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
+}
+
+/**
+  \rst
+  Formats a string and prints it to the specified file stream using ANSI
+  escape sequences to specify text formatting.
+
+  **Example**::
+
+    fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
+               "Elapsed time: {0:.2f} seconds", 1.23);
+  \endrst
+ */
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_string<S>::value)>
+void print(std::FILE* f, const text_style& ts, const S& format_str,
+           const Args&... args) {
+  vprint(f, ts, format_str,
+         fmt::make_format_args<buffer_context<char_t<S>>>(args...));
+}
+
+/**
+  \rst
+  Formats a string and prints it to stdout using ANSI escape sequences to
+  specify text formatting.
+
+  **Example**::
+
+    fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
+               "Elapsed time: {0:.2f} seconds", 1.23);
+  \endrst
+ */
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_string<S>::value)>
+void print(const text_style& ts, const S& format_str, const Args&... args) {
+  return print(stdout, ts, format_str, args...);
+}
+
+template <typename S, typename Char = char_t<S>>
+inline auto vformat(
+    const text_style& ts, const S& format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> std::basic_string<Char> {
+  basic_memory_buffer<Char> buf;
+  detail::vformat_to(buf, ts, detail::to_string_view(format_str), args);
+  return fmt::to_string(buf);
+}
+
+/**
+  \rst
+  Formats arguments and returns the result as a string using ANSI
+  escape sequences to specify text formatting.
+
+  **Example**::
+
+    #include <fmt/color.h>
+    std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red),
+                                      "The answer is {}", 42);
+  \endrst
+*/
+template <typename S, typename... Args, typename Char = char_t<S>>
+inline auto format(const text_style& ts, const S& format_str,
+                   const Args&... args) -> std::basic_string<Char> {
+  return fmt::vformat(ts, detail::to_string_view(format_str),
+                      fmt::make_format_args<buffer_context<Char>>(args...));
+}
+
+/**
+  Formats a string with the given text_style and writes the output to ``out``.
+ */
+template <typename OutputIt, typename Char,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value)>
+auto vformat_to(OutputIt out, const text_style& ts,
+                basic_string_view<Char> format_str,
+                basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> OutputIt {
+  auto&& buf = detail::get_buffer<Char>(out);
+  detail::vformat_to(buf, ts, format_str, args);
+  return detail::get_iterator(buf, out);
+}
+
+/**
+  \rst
+  Formats arguments with the given text_style, writes the result to the output
+  iterator ``out`` and returns the iterator past the end of the output range.
+
+  **Example**::
+
+    std::vector<char> out;
+    fmt::format_to(std::back_inserter(out),
+                   fmt::emphasis::bold | fg(fmt::color::red), "{}", 42);
+  \endrst
+*/
+template <
+    typename OutputIt, typename S, typename... Args,
+    bool enable = detail::is_output_iterator<OutputIt, char_t<S>>::value &&
+                  detail::is_string<S>::value>
+inline auto format_to(OutputIt out, const text_style& ts, const S& format_str,
+                      Args&&... args) ->
+    typename std::enable_if<enable, OutputIt>::type {
+  return vformat_to(out, ts, detail::to_string_view(format_str),
+                    fmt::make_format_args<buffer_context<char_t<S>>>(args...));
+}
+
+template <typename T, typename Char>
+struct formatter<detail::styled_arg<T>, Char> : formatter<T, Char> {
+  template <typename FormatContext>
+  auto format(const detail::styled_arg<T>& arg, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    const auto& ts = arg.style;
+    const auto& value = arg.value;
+    auto out = ctx.out();
+
+    bool has_style = false;
+    if (ts.has_emphasis()) {
+      has_style = true;
+      auto emphasis = detail::make_emphasis<Char>(ts.get_emphasis());
+      out = std::copy(emphasis.begin(), emphasis.end(), out);
+    }
+    if (ts.has_foreground()) {
+      has_style = true;
+      auto foreground =
+          detail::make_foreground_color<Char>(ts.get_foreground());
+      out = std::copy(foreground.begin(), foreground.end(), out);
+    }
+    if (ts.has_background()) {
+      has_style = true;
+      auto background =
+          detail::make_background_color<Char>(ts.get_background());
+      out = std::copy(background.begin(), background.end(), out);
+    }
+    out = formatter<T, Char>::format(value, ctx);
+    if (has_style) {
+      auto reset_color = string_view("\x1b[0m");
+      out = std::copy(reset_color.begin(), reset_color.end(), out);
+    }
+    return out;
+  }
+};
+
+/**
+  \rst
+  Returns an argument that will be formatted using ANSI escape sequences,
+  to be used in a formatting function.
+
+  **Example**::
+
+    fmt::print("Elapsed time: {0:.2f} seconds",
+               fmt::styled(1.23, fmt::fg(fmt::color::green) |
+                                 fmt::bg(fmt::color::blue)));
+  \endrst
+ */
+template <typename T>
+FMT_CONSTEXPR auto styled(const T& value, text_style ts)
+    -> detail::styled_arg<remove_cvref_t<T>> {
+  return detail::styled_arg<remove_cvref_t<T>>{value, ts};
+}
+
+FMT_END_EXPORT
+FMT_END_NAMESPACE
+
+#endif  // FMT_COLOR_H_

dep/fmt/include/fmt/compile.h

@@ -0,0 +1,535 @@
+// Formatting library for C++ - experimental format string compilation
+//
+// Copyright (c) 2012 - present, Victor Zverovich and fmt contributors
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_COMPILE_H_
+#define FMT_COMPILE_H_
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+namespace detail {
+
+template <typename Char, typename InputIt>
+FMT_CONSTEXPR inline auto copy_str(InputIt begin, InputIt end,
+                                   counting_iterator it) -> counting_iterator {
+  return it + (end - begin);
+}
+
+// A compile-time string which is compiled into fast formatting code.
+class compiled_string {};
+
+template <typename S>
+struct is_compiled_string : std::is_base_of<compiled_string, S> {};
+
+/**
+  \rst
+  Converts a string literal *s* into a format string that will be parsed at
+  compile time and converted into efficient formatting code. Requires C++17
+  ``constexpr if`` compiler support.
+
+  **Example**::
+
+    // Converts 42 into std::string using the most efficient method and no
+    // runtime format string processing.
+    std::string s = fmt::format(FMT_COMPILE("{}"), 42);
+  \endrst
+ */
+#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
+#  define FMT_COMPILE(s) \
+    FMT_STRING_IMPL(s, fmt::detail::compiled_string, explicit)
+#else
+#  define FMT_COMPILE(s) FMT_STRING(s)
+#endif
+
+#if FMT_USE_NONTYPE_TEMPLATE_ARGS
+template <typename Char, size_t N,
+          fmt::detail_exported::fixed_string<Char, N> Str>
+struct udl_compiled_string : compiled_string {
+  using char_type = Char;
+  explicit constexpr operator basic_string_view<char_type>() const {
+    return {Str.data, N - 1};
+  }
+};
+#endif
+
+template <typename T, typename... Tail>
+auto first(const T& value, const Tail&...) -> const T& {
+  return value;
+}
+
+#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
+template <typename... Args> struct type_list {};
+
+// Returns a reference to the argument at index N from [first, rest...].
+template <int N, typename T, typename... Args>
+constexpr const auto& get([[maybe_unused]] const T& first,
+                          [[maybe_unused]] const Args&... rest) {
+  static_assert(N < 1 + sizeof...(Args), "index is out of bounds");
+  if constexpr (N == 0)
+    return first;
+  else
+    return detail::get<N - 1>(rest...);
+}
+
+template <typename Char, typename... Args>
+constexpr int get_arg_index_by_name(basic_string_view<Char> name,
+                                    type_list<Args...>) {
+  return get_arg_index_by_name<Args...>(name);
+}
+
+template <int N, typename> struct get_type_impl;
+
+template <int N, typename... Args> struct get_type_impl<N, type_list<Args...>> {
+  using type =
+      remove_cvref_t<decltype(detail::get<N>(std::declval<Args>()...))>;
+};
+
+template <int N, typename T>
+using get_type = typename get_type_impl<N, T>::type;
+
+template <typename T> struct is_compiled_format : std::false_type {};
+
+template <typename Char> struct text {
+  basic_string_view<Char> data;
+  using char_type = Char;
+
+  template <typename OutputIt, typename... Args>
+  constexpr OutputIt format(OutputIt out, const Args&...) const {
+    return write<Char>(out, data);
+  }
+};
+
+template <typename Char>
+struct is_compiled_format<text<Char>> : std::true_type {};
+
+template <typename Char>
+constexpr text<Char> make_text(basic_string_view<Char> s, size_t pos,
+                               size_t size) {
+  return {{&s[pos], size}};
+}
+
+template <typename Char> struct code_unit {
+  Char value;
+  using char_type = Char;
+
+  template <typename OutputIt, typename... Args>
+  constexpr OutputIt format(OutputIt out, const Args&...) const {
+    *out++ = value;
+    return out;
+  }
+};
+
+// This ensures that the argument type is convertible to `const T&`.
+template <typename T, int N, typename... Args>
+constexpr const T& get_arg_checked(const Args&... args) {
+  const auto& arg = detail::get<N>(args...);
+  if constexpr (detail::is_named_arg<remove_cvref_t<decltype(arg)>>()) {
+    return arg.value;
+  } else {
+    return arg;
+  }
+}
+
+template <typename Char>
+struct is_compiled_format<code_unit<Char>> : std::true_type {};
+
+// A replacement field that refers to argument N.
+template <typename Char, typename T, int N> struct field {
+  using char_type = Char;
+
+  template <typename OutputIt, typename... Args>
+  constexpr OutputIt format(OutputIt out, const Args&... args) const {
+    const T& arg = get_arg_checked<T, N>(args...);
+    if constexpr (std::is_convertible_v<T, basic_string_view<Char>>) {
+      auto s = basic_string_view<Char>(arg);
+      return copy_str<Char>(s.begin(), s.end(), out);
+    }
+    return write<Char>(out, arg);
+  }
+};
+
+template <typename Char, typename T, int N>
+struct is_compiled_format<field<Char, T, N>> : std::true_type {};
+
+// A replacement field that refers to argument with name.
+template <typename Char> struct runtime_named_field {
+  using char_type = Char;
+  basic_string_view<Char> name;
+
+  template <typename OutputIt, typename T>
+  constexpr static bool try_format_argument(
+      OutputIt& out,
+      // [[maybe_unused]] due to unused-but-set-parameter warning in GCC 7,8,9
+      [[maybe_unused]] basic_string_view<Char> arg_name, const T& arg) {
+    if constexpr (is_named_arg<typename std::remove_cv<T>::type>::value) {
+      if (arg_name == arg.name) {
+        out = write<Char>(out, arg.value);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  template <typename OutputIt, typename... Args>
+  constexpr OutputIt format(OutputIt out, const Args&... args) const {
+    bool found = (try_format_argument(out, name, args) || ...);
+    if (!found) {
+      FMT_THROW(format_error("argument with specified name is not found"));
+    }
+    return out;
+  }
+};
+
+template <typename Char>
+struct is_compiled_format<runtime_named_field<Char>> : std::true_type {};
+
+// A replacement field that refers to argument N and has format specifiers.
+template <typename Char, typename T, int N> struct spec_field {
+  using char_type = Char;
+  formatter<T, Char> fmt;
+
+  template <typename OutputIt, typename... Args>
+  constexpr FMT_INLINE OutputIt format(OutputIt out,
+                                       const Args&... args) const {
+    const auto& vargs =
+        fmt::make_format_args<basic_format_context<OutputIt, Char>>(args...);
+    basic_format_context<OutputIt, Char> ctx(out, vargs);
+    return fmt.format(get_arg_checked<T, N>(args...), ctx);
+  }
+};
+
+template <typename Char, typename T, int N>
+struct is_compiled_format<spec_field<Char, T, N>> : std::true_type {};
+
+template <typename L, typename R> struct concat {
+  L lhs;
+  R rhs;
+  using char_type = typename L::char_type;
+
+  template <typename OutputIt, typename... Args>
+  constexpr OutputIt format(OutputIt out, const Args&... args) const {
+    out = lhs.format(out, args...);
+    return rhs.format(out, args...);
+  }
+};
+
+template <typename L, typename R>
+struct is_compiled_format<concat<L, R>> : std::true_type {};
+
+template <typename L, typename R>
+constexpr concat<L, R> make_concat(L lhs, R rhs) {
+  return {lhs, rhs};
+}
+
+struct unknown_format {};
+
+template <typename Char>
+constexpr size_t parse_text(basic_string_view<Char> str, size_t pos) {
+  for (size_t size = str.size(); pos != size; ++pos) {
+    if (str[pos] == '{' || str[pos] == '}') break;
+  }
+  return pos;
+}
+
+template <typename Args, size_t POS, int ID, typename S>
+constexpr auto compile_format_string(S format_str);
+
+template <typename Args, size_t POS, int ID, typename T, typename S>
+constexpr auto parse_tail(T head, S format_str) {
+  if constexpr (POS !=
+                basic_string_view<typename S::char_type>(format_str).size()) {
+    constexpr auto tail = compile_format_string<Args, POS, ID>(format_str);
+    if constexpr (std::is_same<remove_cvref_t<decltype(tail)>,
+                               unknown_format>())
+      return tail;
+    else
+      return make_concat(head, tail);
+  } else {
+    return head;
+  }
+}
+
+template <typename T, typename Char> struct parse_specs_result {
+  formatter<T, Char> fmt;
+  size_t end;
+  int next_arg_id;
+};
+
+enum { manual_indexing_id = -1 };
+
+template <typename T, typename Char>
+constexpr parse_specs_result<T, Char> parse_specs(basic_string_view<Char> str,
+                                                  size_t pos, int next_arg_id) {
+  str.remove_prefix(pos);
+  auto ctx =
+      compile_parse_context<Char>(str, max_value<int>(), nullptr, next_arg_id);
+  auto f = formatter<T, Char>();
+  auto end = f.parse(ctx);
+  return {f, pos + fmt::detail::to_unsigned(end - str.data()),
+          next_arg_id == 0 ? manual_indexing_id : ctx.next_arg_id()};
+}
+
+template <typename Char> struct arg_id_handler {
+  arg_ref<Char> arg_id;
+
+  constexpr int on_auto() {
+    FMT_ASSERT(false, "handler cannot be used with automatic indexing");
+    return 0;
+  }
+  constexpr int on_index(int id) {
+    arg_id = arg_ref<Char>(id);
+    return 0;
+  }
+  constexpr int on_name(basic_string_view<Char> id) {
+    arg_id = arg_ref<Char>(id);
+    return 0;
+  }
+};
+
+template <typename Char> struct parse_arg_id_result {
+  arg_ref<Char> arg_id;
+  const Char* arg_id_end;
+};
+
+template <int ID, typename Char>
+constexpr auto parse_arg_id(const Char* begin, const Char* end) {
+  auto handler = arg_id_handler<Char>{arg_ref<Char>{}};
+  auto arg_id_end = parse_arg_id(begin, end, handler);
+  return parse_arg_id_result<Char>{handler.arg_id, arg_id_end};
+}
+
+template <typename T, typename Enable = void> struct field_type {
+  using type = remove_cvref_t<T>;
+};
+
+template <typename T>
+struct field_type<T, enable_if_t<detail::is_named_arg<T>::value>> {
+  using type = remove_cvref_t<decltype(T::value)>;
+};
+
+template <typename T, typename Args, size_t END_POS, int ARG_INDEX, int NEXT_ID,
+          typename S>
+constexpr auto parse_replacement_field_then_tail(S format_str) {
+  using char_type = typename S::char_type;
+  constexpr auto str = basic_string_view<char_type>(format_str);
+  constexpr char_type c = END_POS != str.size() ? str[END_POS] : char_type();
+  if constexpr (c == '}') {
+    return parse_tail<Args, END_POS + 1, NEXT_ID>(
+        field<char_type, typename field_type<T>::type, ARG_INDEX>(),
+        format_str);
+  } else if constexpr (c != ':') {
+    FMT_THROW(format_error("expected ':'"));
+  } else {
+    constexpr auto result = parse_specs<typename field_type<T>::type>(
+        str, END_POS + 1, NEXT_ID == manual_indexing_id ? 0 : NEXT_ID);
+    if constexpr (result.end >= str.size() || str[result.end] != '}') {
+      FMT_THROW(format_error("expected '}'"));
+      return 0;
+    } else {
+      return parse_tail<Args, result.end + 1, result.next_arg_id>(
+          spec_field<char_type, typename field_type<T>::type, ARG_INDEX>{
+              result.fmt},
+          format_str);
+    }
+  }
+}
+
+// Compiles a non-empty format string and returns the compiled representation
+// or unknown_format() on unrecognized input.
+template <typename Args, size_t POS, int ID, typename S>
+constexpr auto compile_format_string(S format_str) {
+  using char_type = typename S::char_type;
+  constexpr auto str = basic_string_view<char_type>(format_str);
+  if constexpr (str[POS] == '{') {
+    if constexpr (POS + 1 == str.size())
+      FMT_THROW(format_error("unmatched '{' in format string"));
+    if constexpr (str[POS + 1] == '{') {
+      return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str);
+    } else if constexpr (str[POS + 1] == '}' || str[POS + 1] == ':') {
+      static_assert(ID != manual_indexing_id,
+                    "cannot switch from manual to automatic argument indexing");
+      constexpr auto next_id =
+          ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
+      return parse_replacement_field_then_tail<get_type<ID, Args>, Args,
+                                               POS + 1, ID, next_id>(
+          format_str);
+    } else {
+      constexpr auto arg_id_result =
+          parse_arg_id<ID>(str.data() + POS + 1, str.data() + str.size());
+      constexpr auto arg_id_end_pos = arg_id_result.arg_id_end - str.data();
+      constexpr char_type c =
+          arg_id_end_pos != str.size() ? str[arg_id_end_pos] : char_type();
+      static_assert(c == '}' || c == ':', "missing '}' in format string");
+      if constexpr (arg_id_result.arg_id.kind == arg_id_kind::index) {
+        static_assert(
+            ID == manual_indexing_id || ID == 0,
+            "cannot switch from automatic to manual argument indexing");
+        constexpr auto arg_index = arg_id_result.arg_id.val.index;
+        return parse_replacement_field_then_tail<get_type<arg_index, Args>,
+                                                 Args, arg_id_end_pos,
+                                                 arg_index, manual_indexing_id>(
+            format_str);
+      } else if constexpr (arg_id_result.arg_id.kind == arg_id_kind::name) {
+        constexpr auto arg_index =
+            get_arg_index_by_name(arg_id_result.arg_id.val.name, Args{});
+        if constexpr (arg_index >= 0) {
+          constexpr auto next_id =
+              ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
+          return parse_replacement_field_then_tail<
+              decltype(get_type<arg_index, Args>::value), Args, arg_id_end_pos,
+              arg_index, next_id>(format_str);
+        } else if constexpr (c == '}') {
+          return parse_tail<Args, arg_id_end_pos + 1, ID>(
+              runtime_named_field<char_type>{arg_id_result.arg_id.val.name},
+              format_str);
+        } else if constexpr (c == ':') {
+          return unknown_format();  // no type info for specs parsing
+        }
+      }
+    }
+  } else if constexpr (str[POS] == '}') {
+    if constexpr (POS + 1 == str.size())
+      FMT_THROW(format_error("unmatched '}' in format string"));
+    return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str);
+  } else {
+    constexpr auto end = parse_text(str, POS + 1);
+    if constexpr (end - POS > 1) {
+      return parse_tail<Args, end, ID>(make_text(str, POS, end - POS),
+                                       format_str);
+    } else {
+      return parse_tail<Args, end, ID>(code_unit<char_type>{str[POS]},
+                                       format_str);
+    }
+  }
+}
+
+template <typename... Args, typename S,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+constexpr auto compile(S format_str) {
+  constexpr auto str = basic_string_view<typename S::char_type>(format_str);
+  if constexpr (str.size() == 0) {
+    return detail::make_text(str, 0, 0);
+  } else {
+    constexpr auto result =
+        detail::compile_format_string<detail::type_list<Args...>, 0, 0>(
+            format_str);
+    return result;
+  }
+}
+#endif  // defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
+}  // namespace detail
+
+FMT_BEGIN_EXPORT
+
+#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
+
+template <typename CompiledFormat, typename... Args,
+          typename Char = typename CompiledFormat::char_type,
+          FMT_ENABLE_IF(detail::is_compiled_format<CompiledFormat>::value)>
+FMT_INLINE std::basic_string<Char> format(const CompiledFormat& cf,
+                                          const Args&... args) {
+  auto s = std::basic_string<Char>();
+  cf.format(std::back_inserter(s), args...);
+  return s;
+}
+
+template <typename OutputIt, typename CompiledFormat, typename... Args,
+          FMT_ENABLE_IF(detail::is_compiled_format<CompiledFormat>::value)>
+constexpr FMT_INLINE OutputIt format_to(OutputIt out, const CompiledFormat& cf,
+                                        const Args&... args) {
+  return cf.format(out, args...);
+}
+
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+FMT_INLINE std::basic_string<typename S::char_type> format(const S&,
+                                                           Args&&... args) {
+  if constexpr (std::is_same<typename S::char_type, char>::value) {
+    constexpr auto str = basic_string_view<typename S::char_type>(S());
+    if constexpr (str.size() == 2 && str[0] == '{' && str[1] == '}') {
+      const auto& first = detail::first(args...);
+      if constexpr (detail::is_named_arg<
+                        remove_cvref_t<decltype(first)>>::value) {
+        return fmt::to_string(first.value);
+      } else {
+        return fmt::to_string(first);
+      }
+    }
+  }
+  constexpr auto compiled = detail::compile<Args...>(S());
+  if constexpr (std::is_same<remove_cvref_t<decltype(compiled)>,
+                             detail::unknown_format>()) {
+    return fmt::format(
+        static_cast<basic_string_view<typename S::char_type>>(S()),
+        std::forward<Args>(args)...);
+  } else {
+    return fmt::format(compiled, std::forward<Args>(args)...);
+  }
+}
+
+template <typename OutputIt, typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) {
+  constexpr auto compiled = detail::compile<Args...>(S());
+  if constexpr (std::is_same<remove_cvref_t<decltype(compiled)>,
+                             detail::unknown_format>()) {
+    return fmt::format_to(
+        out, static_cast<basic_string_view<typename S::char_type>>(S()),
+        std::forward<Args>(args)...);
+  } else {
+    return fmt::format_to(out, compiled, std::forward<Args>(args)...);
+  }
+}
+#endif
+
+template <typename OutputIt, typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+auto format_to_n(OutputIt out, size_t n, const S& format_str, Args&&... args)
+    -> format_to_n_result<OutputIt> {
+  using traits = detail::fixed_buffer_traits;
+  auto buf = detail::iterator_buffer<OutputIt, char, traits>(out, n);
+  fmt::format_to(std::back_inserter(buf), format_str,
+                 std::forward<Args>(args)...);
+  return {buf.out(), buf.count()};
+}
+
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+FMT_CONSTEXPR20 auto formatted_size(const S& format_str, const Args&... args)
+    -> size_t {
+  return fmt::format_to(detail::counting_iterator(), format_str, args...)
+      .count();
+}
+
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+void print(std::FILE* f, const S& format_str, const Args&... args) {
+  memory_buffer buffer;
+  fmt::format_to(std::back_inserter(buffer), format_str, args...);
+  detail::print(f, {buffer.data(), buffer.size()});
+}
+
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+void print(const S& format_str, const Args&... args) {
+  print(stdout, format_str, args...);
+}
+
+#if FMT_USE_NONTYPE_TEMPLATE_ARGS
+inline namespace literals {
+template <detail_exported::fixed_string Str> constexpr auto operator""_cf() {
+  using char_t = remove_cvref_t<decltype(Str.data[0])>;
+  return detail::udl_compiled_string<char_t, sizeof(Str.data) / sizeof(char_t),
+                                     Str>();
+}
+}  // namespace literals
+#endif
+
+FMT_END_EXPORT
+FMT_END_NAMESPACE
+
+#endif  // FMT_COMPILE_H_