Move common.proto into config.

Update ab.

.github/workflows/ccpp.yml

@@ -10,90 +10,92 @@ jobs:
   build-linux:
     runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
       with:
         repository: 'davidgiven/fluxengine'
         path: 'fluxengine'
-    - uses: actions/checkout@v2
+    - 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 -C fluxengine
+      run: CXXFLAGS="-Wp,-D_GLIBCXX_ASSERTIONS" make -j`nproc` -C fluxengine
 
   build-macos-current:
-    runs-on: macos-latest
+    strategy:
+      matrix:
+        runs-on: [macos-13, macos-latest]
+    runs-on: ${{ matrix.runs-on }}
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
       with:
         repository: 'davidgiven/fluxengine'
         path: 'fluxengine'
-    - uses: actions/checkout@v2
+    - 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
+      run: |
+        brew install sqlite pkg-config libusb protobuf wxwidgets fmt make coreutils dylibbundler libjpeg
     - name: make
-      run: gmake -j2 -C fluxengine
-
+      run: gmake -C fluxengine -j2
     - name: Upload build artifacts
-      uses: actions/upload-artifact@v2
+      uses: actions/upload-artifact@v4
       with:
-        name: ${{ github.event.repository.name }}.${{ github.sha }}
-        path: fluxengine.FluxEngine.pkg
+        name: ${{ github.event.repository.name }}.${{ github.sha }}.fluxengine.${{ runner.arch }}.pkg
+        path: fluxengine/FluxEngine.pkg
 
   build-windows:
     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@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:
         repository: 'davidgiven/fluxengine'
         path: 'fluxengine'
-    - uses: actions/checkout@v2
+
+    - uses: actions/checkout@v4
       with:
         repository: 'davidgiven/fluxengine-testdata'
         path: 'fluxengine-testdata'
-    - name: build
-      run: make -j2 -C fluxengine
+
+    - name: run
+      run: |
+        wsl sh -c 'make -C fluxengine BUILDTYPE=windows -j$(nproc)'
 
     - name: nsis
       run: |
-        cd fluxengine
-        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: |
-        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
+        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 }}
+        name: ${{ github.event.repository.name }}.${{ github.sha }}.windows.zip
         path: fluxengine/fluxengine-windows.zip

.github/workflows/release.yml

@@ -1,7 +1,7 @@
 name: Autorelease
 
 concurrency: 
-  group: environment-${{ github.head_ref }}
+  group: environment-release-${{ github.head_ref }}
   cancel-in-progress: true
 
 on:
@@ -12,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: |
@@ -59,6 +59,7 @@ jobs:
       with:
         tag-name: dev
         force-branch: false
+        git-directory: 'fluxengine'
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
@@ -77,20 +78,27 @@ 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
+    strategy:
+      matrix:
+        runs-on: [macos-13, macos-latest]
+    runs-on: ${{ matrix.runs-on }}
     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 -j2
+        mv FluxEngine.pkg FluxEngine-${{ runner.arch }}.pkg
 
     - name: tag
       uses: EndBug/latest-tag@latest
@@ -106,7 +114,7 @@ jobs:
         token: ${{ github.token }}
         tag: dev
         assets: | 
-          FluxEngine.pkg
+          FluxEngine-${{ runner.arch }}.pkg
         fail-if-no-assets: false
 
     - name: release
@@ -114,7 +122,7 @@ jobs:
       with:
         name: Development build ${{ env.RELEASE_DATE }}
         files: |
-          FluxEngine.pkg
+          FluxEngine-${{ runner.arch }}.pkg
         tag_name: dev
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.hgignore

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

Makefile

@@ -1,299 +1,96 @@
-#Special Windows settings.
+BUILDTYPE ?= host
+export BUILDTYPE
 
-ifeq ($(OS), Windows_NT)
-	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
-	LDFLAGS += \
-		-static
+ifeq ($(BUILDTYPE),windows)
+	MINGW = i686-w64-mingw32-
+	CC = $(MINGW)gcc
+	CXX = $(MINGW)g++ -std=c++17
+	CFLAGS += -g -O3
 	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.
-	export PATH := $(PATH):$(MINGWBIN)
-	EXT ?= .exe
+	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
 
-#Special OSX settings.
+HOSTCC = gcc
+HOSTCXX = g++ -std=c++17
+HOSTCFLAGS = -g -O3
+HOSTLDFLAGS =
 
-ifeq ($(shell uname),Darwin)
-	PLATFORM = OSX
-	LDFLAGS += \
-		-framework IOKit \
-		-framework Foundation
-endif
-
-#Check the Make version.
-
-
-ifeq ($(findstring 4.,$(MAKE_VERSION)),)
-$(error You need GNU Make 4.x for this (if you're on OSX, use gmake).)
-endif
-
-#Normal settings.
-
-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 ?=
+REALOBJ = .obj
+OBJ = $(REALOBJ)/$(BUILDTYPE)
 DESTDIR ?=
 PREFIX ?= /usr/local
 BINDIR ?= $(PREFIX)/bin
 
-CFLAGS += \
-	-Iarch \
-	-Ilib \
-	-I. \
-	-I$(OBJDIR)/arch \
-	-I$(OBJDIR)/lib \
-	-I$(OBJDIR) \
-	-Wno-deprecated-declarations \
+# Special Windows settings.
 
-LDFLAGS += \
-	-lz \
-	-lfmt
+ifeq ($(OS), Windows_NT)
+	EXT ?= .exe
+	MINGWBIN = /mingw32/bin
+	CCPREFIX = $(MINGWBIN)/
+	PKG_CONFIG = $(MINGWBIN)/pkg-config
+	WX_CONFIG = /usr/bin/sh $(MINGWBIN)/wx-config --static=yes
+	PROTOC = $(MINGWBIN)/protoc
+	WINDRES = windres
+	LDFLAGS += \
+		-static
+	CXXFLAGS += \
+		-fext-numeric-literals \
+		-Wno-deprecated-enum-float-conversion \
+		-Wno-deprecated-enum-enum-conversion
 
-.SUFFIXES:
-.DELETE_ON_ERROR:
-
-define nl
-
-endef
-
-empty :=
-space := $(empty) $(empty)
-
-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)
+	# Required to get the gcc run - time libraries on the path.
+	export PATH := $(PATH):$(MINGWBIN)
 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 docs
-
-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/rolandd20/rolandd20.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
-.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$$(subst $$(space),_,$3).flux.encodedecode
-$(OBJDIR)/$1$$(subst $$(space),_,$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$$(subst $$(space),_,$3).scp.encodedecode
-$(OBJDIR)/$1$$(subst $$(space),_,$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,agat,,--drive.tpi=96)
-$(call do-encodedecodetest,amiga,,--drive.tpi=135)
-$(call do-encodedecodetest,apple2,,--140 --drive.tpi=96)
-$(call do-encodedecodetest,atarist,,--360 --drive.tpi=135)
-$(call do-encodedecodetest,atarist,,--370 --drive.tpi=135)
-$(call do-encodedecodetest,atarist,,--400 --drive.tpi=135)
-$(call do-encodedecodetest,atarist,,--410 --drive.tpi=135)
-$(call do-encodedecodetest,atarist,,--720 --drive.tpi=135)
-$(call do-encodedecodetest,atarist,,--740 --drive.tpi=135)
-$(call do-encodedecodetest,atarist,,--800 --drive.tpi=135)
-$(call do-encodedecodetest,atarist,,--820 --drive.tpi=135)
-$(call do-encodedecodetest,bk)
-$(call do-encodedecodetest,brother,,--120 --drive.tpi=135)
-$(call do-encodedecodetest,brother,,--240 --drive.tpi=135)
-$(call do-encodedecodetest,commodore,scripts/commodore1541_test.textpb,--171 --drive.tpi=96)
-$(call do-encodedecodetest,commodore,scripts/commodore1541_test.textpb,--192 --drive.tpi=96)
-$(call do-encodedecodetest,commodore,,--800 --drive.tpi=135)
-$(call do-encodedecodetest,commodore,,--1620 --drive.tpi=135)
-$(call do-encodedecodetest,hplif,,--264 --drive.tpi=135)
-$(call do-encodedecodetest,hplif,,--616 --drive.tpi=135)
-$(call do-encodedecodetest,hplif,,--770 --drive.tpi=135)
-$(call do-encodedecodetest,ibm,,--1200 --drive.tpi=96)
-$(call do-encodedecodetest,ibm,,--1232 --drive.tpi=96)
-$(call do-encodedecodetest,ibm,,--1440 --drive.tpi=135)
-$(call do-encodedecodetest,ibm,,--1680 --drive.tpi=135)
-$(call do-encodedecodetest,ibm,,--180 --drive.tpi=96)
-$(call do-encodedecodetest,ibm,,--160 --drive.tpi=96)
-$(call do-encodedecodetest,ibm,,--320 --drive.tpi=96)
-$(call do-encodedecodetest,ibm,,--360 --drive.tpi=96)
-$(call do-encodedecodetest,ibm,,--720_96 --drive.tpi=96)
-$(call do-encodedecodetest,ibm,,--720_135 --drive.tpi=135)
-$(call do-encodedecodetest,mac,scripts/mac400_test.textpb,--400 --drive.tpi=135)
-$(call do-encodedecodetest,mac,scripts/mac800_test.textpb,--800 --drive.tpi=135)
-$(call do-encodedecodetest,n88basic,,--drive.tpi=96)
-$(call do-encodedecodetest,rx50,,--drive.tpi=96)
-$(call do-encodedecodetest,tids990,,--drive.tpi=48)
-$(call do-encodedecodetest,victor9k,,--612 --drive.tpi=96)
-$(call do-encodedecodetest,victor9k,,--1224 --drive.tpi=96)
-
-do-corpustest = $(eval $(do-corpustest-impl))
-define do-corpustest-impl
-
-tests: $(OBJDIR)/corpustest/$2
-$(OBJDIR)/corpustest/$2: $(FLUXENGINE_BIN) \
-		../fluxengine-testdata/data/$1 ../fluxengine-testdata/data/$2
-	@mkdir -p $(OBJDIR)/corpustest
-	@echo CORPUSTEST $1 $2 $3
-	@$(FLUXENGINE_BIN) read $3 -s ../fluxengine-testdata/data/$1 -o $$@ > $$@.log
-	@cmp $$@ ../fluxengine-testdata/data/$2
-
-endef
-
-ifneq ($(wildcard ../fluxengine-testdata/data),)
-
-$(call do-corpustest,amiga.flux,amiga.adf,amiga --drive.tpi=135)
-$(call do-corpustest,atarist360.flux,atarist360.st,atarist --360 --drive.tpi=135)
-$(call do-corpustest,atarist720.flux,atarist720.st,atarist --720 --drive.tpi=135)
-$(call do-corpustest,brother120.flux,brother120.img,brother --120 --drive.tpi=135)
-$(call do-corpustest,cmd-fd2000.flux,cmd-fd2000.img,commodore --1620 --drive.tpi=135)
-$(call do-corpustest,ibm1232.flux,ibm1232.img,ibm --1232 --drive.tpi=96)
-$(call do-corpustest,ibm1440.flux,ibm1440.img,ibm --1440 --drive.tpi=135)
-$(call do-corpustest,mac800.flux,mac800.dsk,mac --800 --drive.tpi=135)
-$(call do-corpustest,micropolis315.flux,micropolis315.img,micropolis --315 --drive.tpi=100)
-$(call do-corpustest,northstar87-synthetic.flux,northstar87-synthetic.nsi,northstar --87 --drive.tpi=48)
-$(call do-corpustest,northstar175-synthetic.flux,northstar175-synthetic.nsi,northstar --175 --drive.tpi=48)
-$(call do-corpustest,northstar350-synthetic.flux,northstar350-synthetic.nsi,northstar --350 --drive.tpi=48)
-$(call do-corpustest,victor9k_ss.flux,victor9k_ss.img,victor9k --612 --drive.tpi=96)
-$(call do-corpustest,victor9k_ds.flux,victor9k_ds.img,victor9k --1224 --drive.tpi=96)
+# Special OSX settings.
 
+ifeq ($(shell uname),Darwin)
+	LDFLAGS += \
+		-framework IOKit \
+		-framework Foundation 
 endif
 
-$(OBJDIR)/%.a:
-	@mkdir -p $(dir $@)
-	@echo AR $@
-	@$(AR) rc $@ $^
+.PHONY: all
+all: +all README.md
 
-%.exe:
-	@mkdir -p $(dir $@)
-	@echo LINK $@
-	@$(CXX) -o $@ $(filter %.o,$^) $(filter %.a,$^) $(LDFLAGS) $(filter %.a,$^) $(LDFLAGS)
+.PHONY: binaries tests
+binaries: all
+tests: all
+	
+README.md: $(OBJ)/scripts/+mkdocindex/mkdocindex$(EXT)
+	@echo $(PROGRESSINFO) MKDOC $@
+	@csplit -s -f$(OBJ)/README. README.md '/<!-- FORMATSSTART -->/' '%<!-- FORMATSEND -->%'
+	@(cat $(OBJ)/README.00 && $< && cat $(OBJ)/README.01) > README.md
 
-$(OBJDIR)/%.o: %.cpp
-	@mkdir -p $(dir $@)
-	@echo CXX $<
-	@$(CXX) $(CFLAGS) $(CXXFLAGS) -MMD -MP -MF $(@:.o=.d) -c -o $@ $<
+.PHONY: tests
 
-$(OBJDIR)/%.o: %.cc
-	@mkdir -p $(dir $@)
-	@echo CXX $<
-	@$(CXX) $(CFLAGS) $(CXXFLAGS) -MMD -MP -MF $(@:.o=.d) -c -o $@ $<
+.PHONY: install install-bin
+install:: all install-bin
 
-$(OBJDIR)/%.o: $(OBJDIR)/%.cc
-	@mkdir -p $(dir $@)
-	@echo CXX $<
-	@$(CXX) $(CFLAGS) $(CXXFLAGS) -MMD -MP -MF $(@:.o=.d) -c -o $@ $<
+clean::
+	$(hide) rm -rf $(REALOBJ)
 
-$(OBJDIR)/%.o: %.c
-	@mkdir -p $(dir $@)
-	@echo CC $<
-	@$(CC) $(CFLAGS) $(CFLAGS) -MMD -MP -MF $(@:.o=.d) -c -o $@ $<
+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"
 
-$(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

@@ -4,11 +4,8 @@ FluxEngine
 (If you're reading this on GitHub, the formatting's a bit messed up. [Try the
 version on cowlark.com instead.](http://cowlark.com/fluxengine/))
 
-**Breaking news!** As of 2022-09-09, there's new [filesystem
-support](doc/filesystem.md). Read (and sometimes write) files directly from
-(and to) your disks, with eight different file systems! It works in the GUI,
-too, which is available for Linux (and other Unix clones), Windows and OSX. See
-the details below.
+**Breaking news!** As of 2024-10-01, the FluxEngine client software works
+(to a point) with [Applesauce](doc/applesauce.md) hardware.
 
 <div style="text-align: center">
 <a href="doc/screenshot.jpg"><img src="doc/screenshot.jpg" style="width:60%" alt="screenshot of the GUI in action"></a>
@@ -35,12 +32,14 @@ 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
-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)
-for more information.
+[Greaseweazle](https://github.com/keirf/Greaseweazle/wiki) and
+[Applesauce](https://applesaucefdc.com/) 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; the Applesauce is a
+bit less supported but still works. See the [dedicated Greaseweazle
+documentation page](doc/greaseweazle.md) or the [Applesauce
+page](doc/applesauce.md) for more information.
 
 Where?
 ------
@@ -65,7 +64,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
 
@@ -128,17 +127,19 @@ choices because they can store multiple types of file system.
 | [`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 | 🦖 |  |  |
+| [`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 | 🦖 |  |  |
+| [`zilogmcz`](doc/disk-zilogmcz.md) | Zilog MCZ: 320kB 8" 77-track SSSD hard-sectored | 🦖 |  | ZDOS  |
 {: .datatable }
 
 <!-- FORMATSEND -->

arch/aeslanier/decoder.cc

@@ -1,11 +1,12 @@
-#include "globals.h"
-#include "decoders/decoders.h"
+#include "lib/core/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/core/crc.h"
+#include "lib/data/fluxmap.h"
+#include "lib/data/fluxmapreader.h"
+#include "lib/data/fluxpattern.h"
+#include "lib/data/sector.h"
+#include "lib/core/bytes.h"
 #include "fmt/format.h"
 #include <string.h>
 

arch/agat/agat.cc

@@ -1,7 +1,7 @@
-#include "globals.h"
-#include "decoders/decoders.h"
+#include "lib/core/globals.h"
+#include "lib/decoders/decoders.h"
 #include "agat.h"
-#include "bytes.h"
+#include "lib/core/bytes.h"
 #include "fmt/format.h"
 
 uint8_t agatChecksum(const Bytes& bytes)

arch/agat/agat.proto

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

arch/agat/decoder.cc

@@ -1,11 +1,12 @@
-#include "globals.h"
-#include "decoders/decoders.h"
+#include "lib/core/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/core/crc.h"
+#include "lib/data/fluxmap.h"
+#include "lib/data/fluxmapreader.h"
+#include "lib/data/fluxpattern.h"
+#include "lib/data/sector.h"
+#include "lib/core/bytes.h"
 #include "fmt/format.h"
 #include <string.h>
 

arch/agat/encoder.cc

@@ -1,11 +1,11 @@
-#include "lib/globals.h"
+#include "lib/core/globals.h"
+#include "lib/core/utils.h"
 #include "lib/decoders/decoders.h"
 #include "lib/encoders/encoders.h"
 #include "agat.h"
-#include "lib/crc.h"
-#include "lib/readerwriter.h"
-#include "lib/image.h"
-#include "lib/layout.h"
+#include "lib/core/crc.h"
+#include "lib/data/image.h"
+#include "lib/data/layout.h"
 #include "arch/agat/agat.pb.h"
 #include "lib/encoders/encoders.pb.h"
 

arch/amiga/amiga.cc

@@ -1,7 +1,7 @@
-#include "globals.h"
-#include "decoders/decoders.h"
+#include "lib/core/globals.h"
+#include "lib/decoders/decoders.h"
 #include "amiga.h"
-#include "bytes.h"
+#include "lib/core/bytes.h"
 #include "fmt/format.h"
 
 uint32_t amigaChecksum(const Bytes& bytes)

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/amiga.proto

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

arch/amiga/decoder.cc

@@ -1,11 +1,12 @@
-#include "globals.h"
-#include "fluxmap.h"
-#include "decoders/fluxmapreader.h"
+#include "lib/core/globals.h"
+#include "lib/data/fluxmap.h"
+#include "lib/data/fluxmapreader.h"
+#include "lib/data/fluxpattern.h"
 #include "protocol.h"
-#include "decoders/decoders.h"
-#include "sector.h"
+#include "lib/decoders/decoders.h"
+#include "lib/data/sector.h"
 #include "amiga.h"
-#include "bytes.h"
+#include "lib/core/bytes.h"
 #include "fmt/format.h"
 #include "lib/decoders/decoders.pb.h"
 #include <string.h>

arch/amiga/encoder.cc

@@ -1,10 +1,10 @@
-#include "globals.h"
-#include "decoders/decoders.h"
-#include "encoders/encoders.h"
+#include "lib/core/globals.h"
+#include "lib/core/utils.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/core/crc.h"
+#include "lib/data/image.h"
 #include "arch/amiga/amiga.pb.h"
 #include "lib/encoders/encoders.pb.h"
 

arch/apple2/apple2.h

@@ -2,8 +2,8 @@
 #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

arch/apple2/apple2.proto

@@ -1,6 +1,6 @@
 syntax = "proto2";
 
-import "lib/common.proto";
+import "lib/config/common.proto";
 
 message Apple2DecoderProto {
 	optional uint32 side_one_track_offset = 1

arch/apple2/decoder.cc

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

arch/apple2/encoder.cc

@@ -1,14 +1,14 @@
-#include "globals.h"
+#include "lib/core/globals.h"
+#include "lib/core/utils.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/data/sector.h"
+#include "lib/data/image.h"
 #include "fmt/format.h"
 #include "lib/encoders/encoders.pb.h"
 #include <ctype.h>
-#include "bytes.h"
+#include "lib/core/bytes.h"
 
 static int encode_data_gcr(uint8_t data)
 {

arch/arch.cc

@@ -0,0 +1,97 @@
+#include "lib/core/globals.h"
+#include "lib/encoders/encoders.h"
+#include "lib/decoders/decoders.h"
+#include "lib/config/config.h"
+#include "arch/agat/agat.h"
+#include "arch/aeslanier/aeslanier.h"
+#include "arch/amiga/amiga.h"
+#include "arch/apple2/apple2.h"
+#include "arch/brother/brother.h"
+#include "arch/c64/c64.h"
+#include "arch/f85/f85.h"
+#include "arch/fb100/fb100.h"
+#include "arch/ibm/ibm.h"
+#include "arch/macintosh/macintosh.h"
+#include "arch/micropolis/micropolis.h"
+#include "arch/mx/mx.h"
+#include "arch/northstar/northstar.h"
+#include "arch/rolandd20/rolandd20.h"
+#include "arch/smaky6/smaky6.h"
+#include "arch/tartu/tartu.h"
+#include "arch/tids990/tids990.h"
+#include "arch/victor9k/victor9k.h"
+#include "arch/zilogmcz/zilogmcz.h"
+#include "arch/arch.h"
+
+std::unique_ptr<Encoder> Arch::createEncoder(Config& config)
+{
+    if (!config.hasEncoder())
+        error("no encoder configured");
+    return createEncoder(config->encoder());
+}
+
+std::unique_ptr<Encoder> Arch::createEncoder(const EncoderProto& config)
+{
+    static const std::map<int,
+        std::function<std::unique_ptr<Encoder>(const EncoderProto&)>>
+        encoders = {
+            {EncoderProto::kAgat,       createAgatEncoder       },
+            {EncoderProto::kAmiga,      createAmigaEncoder      },
+            {EncoderProto::kApple2,     createApple2Encoder     },
+            {EncoderProto::kBrother,    createBrotherEncoder    },
+            {EncoderProto::kC64,        createCommodore64Encoder},
+            {EncoderProto::kIbm,        createIbmEncoder        },
+            {EncoderProto::kMacintosh,  createMacintoshEncoder  },
+            {EncoderProto::kMicropolis, createMicropolisEncoder },
+            {EncoderProto::kNorthstar,  createNorthstarEncoder  },
+            {EncoderProto::kTartu,      createTartuEncoder      },
+            {EncoderProto::kTids990,    createTids990Encoder    },
+            {EncoderProto::kVictor9K,   createVictor9kEncoder   },
+    };
+
+    auto encoder = encoders.find(config.format_case());
+    if (encoder == encoders.end())
+        error("no encoder specified");
+
+    return (encoder->second)(config);
+}
+
+std::unique_ptr<Decoder> Arch::createDecoder(Config& config)
+{
+    if (!config.hasDecoder())
+        error("no decoder configured");
+    return createDecoder(config->decoder());
+}
+
+std::unique_ptr<Decoder> Arch::createDecoder(const DecoderProto& config)
+{
+    static const std::map<int,
+        std::function<std::unique_ptr<Decoder>(const DecoderProto&)>>
+        decoders = {
+            {DecoderProto::kAgat,       createAgatDecoder       },
+            {DecoderProto::kAeslanier,  createAesLanierDecoder  },
+            {DecoderProto::kAmiga,      createAmigaDecoder      },
+            {DecoderProto::kApple2,     createApple2Decoder     },
+            {DecoderProto::kBrother,    createBrotherDecoder    },
+            {DecoderProto::kC64,        createCommodore64Decoder},
+            {DecoderProto::kF85,        createDurangoF85Decoder },
+            {DecoderProto::kFb100,      createFb100Decoder      },
+            {DecoderProto::kIbm,        createIbmDecoder        },
+            {DecoderProto::kMacintosh,  createMacintoshDecoder  },
+            {DecoderProto::kMicropolis, createMicropolisDecoder },
+            {DecoderProto::kMx,         createMxDecoder         },
+            {DecoderProto::kNorthstar,  createNorthstarDecoder  },
+            {DecoderProto::kRolandd20,  createRolandD20Decoder  },
+            {DecoderProto::kSmaky6,     createSmaky6Decoder     },
+            {DecoderProto::kTartu,      createTartuDecoder      },
+            {DecoderProto::kTids990,    createTids990Decoder    },
+            {DecoderProto::kVictor9K,   createVictor9kDecoder   },
+            {DecoderProto::kZilogmcz,   createZilogMczDecoder   },
+    };
+
+    auto decoder = decoders.find(config.format_case());
+    if (decoder == decoders.end())
+        error("no decoder specified");
+
+    return (decoder->second)(config);
+}

arch/arch.h

@@ -0,0 +1,16 @@
+#pragma once
+
+class Encoder;
+class Decoder;
+class DecoderProto;
+class EncoderProto;
+class Config;
+
+namespace Arch
+{
+    std::unique_ptr<Decoder> createDecoder(Config& config);
+    std::unique_ptr<Decoder> createDecoder(const DecoderProto& config);
+
+    std::unique_ptr<Encoder> createEncoder(Config& config);
+    std::unique_ptr<Encoder> createEncoder(const EncoderProto& config);
+}

arch/brother/decoder.cc

@@ -1,12 +1,13 @@
-#include "globals.h"
-#include "fluxmap.h"
-#include "decoders/fluxmapreader.h"
-#include "decoders/decoders.h"
-#include "encoders/encoders.h"
+#include "lib/core/globals.h"
+#include "lib/data/fluxmap.h"
+#include "lib/data/fluxmapreader.h"
+#include "lib/data/fluxpattern.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/data/sector.h"
+#include "lib/core/bytes.h"
+#include "lib/core/crc.h"
 #include <ctype.h>
 
 const FluxPattern SECTOR_RECORD_PATTERN(32, BROTHER_SECTOR_RECORD);

arch/brother/encoder.cc

@@ -1,10 +1,10 @@
-#include "globals.h"
-#include "decoders/decoders.h"
-#include "encoders/encoders.h"
+#include "lib/core/globals.h"
+#include "lib/core/utils.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/core/crc.h"
+#include "lib/data/image.h"
 #include "arch/brother/brother.pb.h"
 #include "lib/encoders/encoders.pb.h"
 

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/rolandd20/decoder.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_LDFLAGS =
-$(LIBARCH_LIB): $(LIBARCH_OBJS)
-
-$(call use-pkgconfig, $(LIBARCH_LIB), $(LIBARCH_OBJS), fmt)

arch/build.py

@@ -0,0 +1,102 @@
+from build.c import cxxlibrary
+from build.protobuf import proto, protocc
+
+proto(
+    name="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",
+    ],
+    deps=["lib/config+common_proto"],
+)
+
+protocc(name="proto_lib", srcs=[".+proto"], deps=["lib/config+common_proto_lib"])
+
+cxxlibrary(
+    name="arch",
+    srcs=[
+        "./arch.cc",
+        "./aeslanier/decoder.cc",
+        "./agat/agat.cc",
+        "./agat/decoder.cc",
+        "./agat/encoder.cc",
+        "./amiga/amiga.cc",
+        "./amiga/decoder.cc",
+        "./amiga/encoder.cc",
+        "./apple2/decoder.cc",
+        "./apple2/encoder.cc",
+        "./brother/decoder.cc",
+        "./brother/encoder.cc",
+        "./c64/c64.cc",
+        "./c64/decoder.cc",
+        "./c64/encoder.cc",
+        "./f85/decoder.cc",
+        "./fb100/decoder.cc",
+        "./ibm/decoder.cc",
+        "./ibm/encoder.cc",
+        "./macintosh/decoder.cc",
+        "./macintosh/encoder.cc",
+        "./micropolis/decoder.cc",
+        "./micropolis/encoder.cc",
+        "./mx/decoder.cc",
+        "./northstar/decoder.cc",
+        "./northstar/encoder.cc",
+        "./rolandd20/decoder.cc",
+        "./smaky6/decoder.cc",
+        "./tartu/decoder.cc",
+        "./tartu/encoder.cc",
+        "./tids990/decoder.cc",
+        "./tids990/encoder.cc",
+        "./victor9k/decoder.cc",
+        "./victor9k/encoder.cc",
+        "./zilogmcz/decoder.cc",
+    ],
+    hdrs={
+        "arch/ibm/ibm.h": "./ibm/ibm.h",
+        "arch/apple2/data_gcr.h": "./apple2/data_gcr.h",
+        "arch/apple2/apple2.h": "./apple2/apple2.h",
+        "arch/amiga/amiga.h": "./amiga/amiga.h",
+        "arch/smaky6/smaky6.h": "./smaky6/smaky6.h",
+        "arch/tids990/tids990.h": "./tids990/tids990.h",
+        "arch/zilogmcz/zilogmcz.h": "./zilogmcz/zilogmcz.h",
+        "arch/amiga/amiga.h": "./amiga/amiga.h",
+        "arch/f85/data_gcr.h": "./f85/data_gcr.h",
+        "arch/f85/f85.h": "./f85/f85.h",
+        "arch/mx/mx.h": "./mx/mx.h",
+        "arch/aeslanier/aeslanier.h": "./aeslanier/aeslanier.h",
+        "arch/northstar/northstar.h": "./northstar/northstar.h",
+        "arch/brother/data_gcr.h": "./brother/data_gcr.h",
+        "arch/brother/brother.h": "./brother/brother.h",
+        "arch/brother/header_gcr.h": "./brother/header_gcr.h",
+        "arch/macintosh/data_gcr.h": "./macintosh/data_gcr.h",
+        "arch/macintosh/macintosh.h": "./macintosh/macintosh.h",
+        "arch/agat/agat.h": "./agat/agat.h",
+        "arch/fb100/fb100.h": "./fb100/fb100.h",
+        "arch/victor9k/data_gcr.h": "./victor9k/data_gcr.h",
+        "arch/victor9k/victor9k.h": "./victor9k/victor9k.h",
+        "arch/rolandd20/rolandd20.h": "./rolandd20/rolandd20.h",
+        "arch/micropolis/micropolis.h": "./micropolis/micropolis.h",
+        "arch/c64/data_gcr.h": "./c64/data_gcr.h",
+        "arch/c64/c64.h": "./c64/c64.h",
+        "arch/tartu/tartu.h": "./tartu/tartu.h",
+        "arch/arch.h": "./arch.h",
+    },
+    deps=["lib/core", "lib/data", "lib/config", "lib/encoders", "lib/decoders"],
+)

arch/c64/c64.cc

@@ -1,4 +1,4 @@
-#include "globals.h"
+#include "lib/core/globals.h"
 #include "c64.h"
 
 /*

arch/c64/c64.h

@@ -1,8 +1,8 @@
 #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

arch/c64/c64.proto

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

arch/c64/decoder.cc

@@ -1,12 +1,13 @@
-#include "globals.h"
-#include "fluxmap.h"
-#include "decoders/fluxmapreader.h"
+#include "lib/core/globals.h"
+#include "lib/data/fluxmap.h"
+#include "lib/data/fluxmapreader.h"
+#include "lib/data/fluxpattern.h"
 #include "protocol.h"
-#include "decoders/decoders.h"
-#include "sector.h"
+#include "lib/decoders/decoders.h"
+#include "lib/data/sector.h"
 #include "c64.h"
-#include "crc.h"
-#include "bytes.h"
+#include "lib/core/crc.h"
+#include "lib/core/bytes.h"
 #include "fmt/format.h"
 #include <string.h>
 #include <algorithm>

arch/c64/encoder.cc

@@ -1,17 +1,17 @@
-#include "globals.h"
-#include "decoders/decoders.h"
-#include "encoders/encoders.h"
+#include "lib/core/globals.h"
+#include "lib/core/utils.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/core/crc.h"
+#include "lib/data/sector.h"
+#include "lib/data/image.h"
 #include "fmt/format.h"
 #include "arch/c64/c64.pb.h"
 #include "lib/encoders/encoders.pb.h"
-#include "lib/layout.h"
+#include "lib/data/layout.h"
 #include <ctype.h>
-#include "bytes.h"
+#include "lib/core/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)
 {
     /*

arch/f85/decoder.cc

@@ -1,12 +1,13 @@
-#include "globals.h"
-#include "fluxmap.h"
-#include "decoders/fluxmapreader.h"
+#include "lib/core/globals.h"
+#include "lib/data/fluxmap.h"
+#include "lib/data/fluxmapreader.h"
+#include "lib/data/fluxpattern.h"
 #include "protocol.h"
-#include "decoders/decoders.h"
-#include "sector.h"
+#include "lib/decoders/decoders.h"
+#include "lib/data/sector.h"
 #include "f85.h"
-#include "crc.h"
-#include "bytes.h"
+#include "lib/core/crc.h"
+#include "lib/core/bytes.h"
 #include "fmt/format.h"
 #include <string.h>
 #include <algorithm>

arch/fb100/decoder.cc

@@ -1,13 +1,14 @@
-#include "globals.h"
-#include "fluxmap.h"
-#include "decoders/fluxmapreader.h"
+#include "lib/core/globals.h"
+#include "lib/data/fluxmap.h"
+#include "lib/data/fluxmapreader.h"
+#include "lib/data/fluxpattern.h"
 #include "protocol.h"
-#include "decoders/decoders.h"
-#include "sector.h"
+#include "lib/decoders/decoders.h"
+#include "lib/data/sector.h"
 #include "fb100.h"
-#include "crc.h"
-#include "bytes.h"
-#include "decoders/rawbits.h"
+#include "lib/core/crc.h"
+#include "lib/core/bytes.h"
+#include "lib/decoders/rawbits.h"
 #include "fmt/format.h"
 #include <string.h>
 #include <algorithm>

arch/ibm/decoder.cc

@@ -1,13 +1,14 @@
-#include "globals.h"
-#include "decoders/decoders.h"
+#include "lib/core/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/core/crc.h"
+#include "lib/data/fluxmap.h"
+#include "lib/data/fluxmapreader.h"
+#include "lib/data/fluxpattern.h"
+#include "lib/data/sector.h"
 #include "arch/ibm/ibm.pb.h"
-#include "proto.h"
-#include "lib/layout.h"
+#include "lib/config/proto.h"
+#include "lib/data/layout.h"
 #include <string.h>
 
 static_assert(std::is_trivially_copyable<IbmIdam>::value,

arch/ibm/encoder.cc

@@ -1,15 +1,15 @@
-#include "globals.h"
-#include "decoders/decoders.h"
-#include "encoders/encoders.h"
+#include "lib/core/globals.h"
+#include "lib/config/config.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/core/crc.h"
+#include "lib/data/image.h"
 #include "arch/ibm/ibm.pb.h"
 #include "lib/encoders/encoders.pb.h"
 #include "fmt/format.h"
-#include "lib/proto.h"
-#include "lib/layout.h"
+#include "lib/config/proto.h"
+#include "lib/data/layout.h"
 #include <ctype.h>
 
 /* IAM record separator:

arch/ibm/ibm.proto

@@ -1,6 +1,6 @@
 syntax = "proto2";
 
-import "lib/common.proto";
+import "lib/config/common.proto";
 
 message IbmDecoderProto {
 	// Next: 11

arch/macintosh/decoder.cc

@@ -1,11 +1,12 @@
-#include "globals.h"
-#include "fluxmap.h"
-#include "decoders/fluxmapreader.h"
+#include "lib/core/globals.h"
+#include "lib/data/fluxmap.h"
+#include "lib/data/fluxmapreader.h"
+#include "lib/data/fluxpattern.h"
 #include "protocol.h"
-#include "decoders/decoders.h"
-#include "sector.h"
+#include "lib/decoders/decoders.h"
+#include "lib/data/sector.h"
 #include "macintosh.h"
-#include "bytes.h"
+#include "lib/core/bytes.h"
 #include "fmt/format.h"
 #include <string.h>
 #include <algorithm>

arch/macintosh/encoder.cc

@@ -1,13 +1,13 @@
-#include "globals.h"
-#include "decoders/decoders.h"
-#include "encoders/encoders.h"
+#include "lib/core/globals.h"
+#include "lib/core/utils.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/core/crc.h"
+#include "lib/data/image.h"
 #include "fmt/format.h"
 #include "lib/encoders/encoders.pb.h"
-#include "lib/layout.h"
+#include "lib/data/layout.h"
 #include "arch/macintosh/macintosh.pb.h"
 #include <ctype.h>
 

arch/macintosh/macintosh.proto

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

arch/micropolis/decoder.cc

@@ -1,10 +1,11 @@
-#include "globals.h"
-#include "fluxmap.h"
-#include "decoders/fluxmapreader.h"
-#include "decoders/decoders.h"
-#include "sector.h"
+#include "lib/core/globals.h"
+#include "lib/data/fluxmap.h"
+#include "lib/data/fluxmapreader.h"
+#include "lib/data/fluxpattern.h"
+#include "lib/decoders/decoders.h"
+#include "lib/data/sector.h"
 #include "micropolis.h"
-#include "bytes.h"
+#include "lib/core/bytes.h"
 #include "fmt/format.h"
 #include "lib/decoders/decoders.pb.h"
 
@@ -59,6 +60,76 @@ uint8_t mzosChecksum(const Bytes& bytes)
     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:
@@ -85,9 +156,10 @@ public:
         /* 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.
+         * 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.5e6))
+        if (now > (getFluxmapDuration() - 12.0e6))
         {
             seekToIndexMark();
             return 0;
@@ -114,9 +186,10 @@ public:
         _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.
+         * too close to the end of the Fluxmap, discard the sector. The
+         * preamble was expected to be 640uS long.
          */
-        if (_sector->headerStartTime > (getFluxmapDuration() - 12.5e6))
+        if (_sector->headerStartTime > (getFluxmapDuration() - 11.3e6))
         {
             return 0;
         }
@@ -130,6 +203,19 @@ public:
         auto rawbits = readRawBits(MICROPOLIS_ENCODED_SECTOR_SIZE * 16);
         auto bytes =
             decodeFmMfm(rawbits).slice(0, MICROPOLIS_ENCODED_SECTOR_SIZE);
+
+        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));
+            }
+        }
+
         ByteReader br(bytes);
 
         int syncByte = br.read_8(); /* sync */
@@ -191,8 +277,10 @@ public:
             _sector->data = bytes;
         else
             error("Sector output size may only be 256 or 275");
-        _sector->status =
-            (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
+        if (wantChecksum == gotChecksum && (!eccPresent || ecc == 0))
+            _sector->status = Sector::OK;
+        else
+            _sector->status = Sector::BAD_CHECKSUM;
     }
 
 private:

arch/micropolis/encoder.cc

@@ -1,14 +1,15 @@
-#include "globals.h"
+#include "lib/core/globals.h"
 #include "micropolis.h"
-#include "sector.h"
-#include "decoders/decoders.h"
-#include "encoders/encoders.h"
-#include "image.h"
+#include "lib/data/sector.h"
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
+#include "lib/data/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))
@@ -45,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);
@@ -86,18 +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");
 
         std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
-        fluxmap->appendBits(bits,
+        nanoseconds_t clockPeriod =
             calculatePhysicalClockPeriod(_config.clock_period_us() * 1e3,
-                _config.rotational_period_ms() * 1e6));
+                _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;
     }
 

arch/micropolis/micropolis.h

@@ -17,5 +17,6 @@ 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

@@ -1,6 +1,6 @@
 syntax = "proto2";
 
-import "lib/common.proto";
+import "lib/config/common.proto";
 
 message MicropolisDecoderProto {
 	enum ChecksumType {
@@ -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 = 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,11 @@
-#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/core/globals.h"
+#include "lib/decoders/decoders.h"
+#include "arch/mx/mx.h"
+#include "lib/core/crc.h"
+#include "lib/data/fluxmap.h"
+#include "lib/data/fluxmapreader.h"
+#include "lib/data/fluxpattern.h"
+#include "lib/data/sector.h"
 #include <string.h>
 
 const int SECTOR_SIZE = 256;

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,13 +11,14 @@
  * 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/core/globals.h"
+#include "lib/data/fluxmap.h"
+#include "lib/data/fluxmapreader.h"
+#include "lib/data/fluxpattern.h"
+#include "lib/decoders/decoders.h"
+#include "lib/data/sector.h"
 #include "northstar.h"
-#include "bytes.h"
+#include "lib/core/bytes.h"
 #include "lib/decoders/decoders.pb.h"
 #include "fmt/format.h"
 

arch/northstar/encoder.cc

@@ -1,10 +1,10 @@
-#include "globals.h"
+#include "lib/core/globals.h"
 #include "northstar.h"
-#include "sector.h"
-#include "bytes.h"
-#include "decoders/decoders.h"
-#include "encoders/encoders.h"
-#include "image.h"
+#include "lib/data/sector.h"
+#include "lib/core/bytes.h"
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
+#include "lib/data/image.h"
 #include "lib/encoders/encoders.pb.h"
 
 #define GAP_FILL_SIZE_SD 30

arch/northstar/northstar.proto

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

arch/rolandd20/decoder.cc

@@ -1,10 +1,11 @@
-#include "lib/globals.h"
+#include "lib/core/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 "lib/core/crc.h"
+#include "lib/data/fluxmap.h"
+#include "lib/data/fluxmapreader.h"
+#include "lib/data/fluxpattern.h"
+#include "lib/data/sector.h"
+#include "lib/core/bytes.h"
 #include "rolandd20.h"
 #include <string.h>
 

arch/smaky6/decoder.cc

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

arch/smaky6/smaky6.proto

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

arch/tartu/decoder.cc

@@ -0,0 +1,81 @@
+#include "lib/core/globals.h"
+#include "lib/config/config.h"
+#include "lib/decoders/decoders.h"
+#include "arch/tartu/tartu.h"
+#include "lib/core/crc.h"
+#include "lib/data/fluxmap.h"
+#include "lib/data/fluxmapreader.h"
+#include "lib/data/fluxpattern.h"
+#include "lib/data/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,115 @@
+#include "lib/core/globals.h"
+#include "lib/config/config.h"
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
+#include "arch/tartu/tartu.h"
+#include "lib/core/crc.h"
+#include "lib/data/fluxmap.h"
+#include "lib/data/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,7 @@
+#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/config/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,13 +1,14 @@
-#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/core/globals.h"
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
+#include "arch/tids990/tids990.h"
+#include "lib/core/crc.h"
+#include "lib/data/fluxmap.h"
+#include "lib/data/fluxmapreader.h"
+#include "lib/data/fluxpattern.h"
+#include "lib/data/sector.h"
 #include <string.h>
-#include <fmt/format.h>
+#include "fmt/format.h"
 
 /* The Texas Instruments DS990 uses MFM with a scheme similar to a simplified
  * version of the IBM record scheme (it's actually easier to parse than IBM).

arch/tids990/encoder.cc

@@ -1,13 +1,12 @@
-#include "globals.h"
-#include "decoders/decoders.h"
-#include "encoders/encoders.h"
+#include "lib/core/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/core/crc.h"
+#include "lib/data/image.h"
 #include "arch/tids990/tids990.pb.h"
 #include "lib/encoders/encoders.pb.h"
-#include <fmt/format.h>
+#include "fmt/format.h"
 
 static int charToInt(char c)
 {

arch/tids990/tids990.proto

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

arch/victor9k/decoder.cc

@@ -1,12 +1,13 @@
-#include "globals.h"
-#include "fluxmap.h"
-#include "decoders/fluxmapreader.h"
+#include "lib/core/globals.h"
+#include "lib/data/fluxmap.h"
+#include "lib/data/fluxmapreader.h"
+#include "lib/data/fluxpattern.h"
 #include "protocol.h"
-#include "decoders/decoders.h"
-#include "sector.h"
+#include "lib/decoders/decoders.h"
+#include "lib/data/sector.h"
 #include "victor9k.h"
-#include "crc.h"
-#include "bytes.h"
+#include "lib/core/crc.h"
+#include "lib/core/bytes.h"
 #include "fmt/format.h"
 #include <string.h>
 #include <algorithm>

arch/victor9k/encoder.cc

@@ -1,17 +1,17 @@
-#include "globals.h"
-#include "decoders/decoders.h"
-#include "encoders/encoders.h"
+#include "lib/core/globals.h"
+#include "lib/core/utils.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/core/crc.h"
+#include "lib/data/sector.h"
+#include "lib/data/image.h"
 #include "fmt/format.h"
 #include "arch/victor9k/victor9k.pb.h"
 #include "lib/encoders/encoders.pb.h"
-#include "lib/layout.h"
+#include "lib/data/layout.h"
 #include <ctype.h>
-#include "bytes.h"
+#include "lib/core/bytes.h"
 
 static bool lastBit;
 

arch/victor9k/victor9k.proto

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

arch/zilogmcz/decoder.cc

@@ -1,12 +1,13 @@
-#include "globals.h"
-#include "fluxmap.h"
-#include "decoders/fluxmapreader.h"
+#include "lib/core/globals.h"
+#include "lib/data/fluxmap.h"
+#include "lib/data/fluxmapreader.h"
+#include "lib/data/fluxpattern.h"
 #include "protocol.h"
-#include "decoders/decoders.h"
-#include "sector.h"
+#include "lib/decoders/decoders.h"
+#include "lib/data/sector.h"
 #include "zilogmcz.h"
-#include "bytes.h"
-#include "crc.h"
+#include "lib/core/bytes.h"
+#include "lib/core/crc.h"
 #include "fmt/format.h"
 #include <string.h>
 #include <algorithm>

build.lua

@@ -1,194 +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/rolandd20/rolandd20.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/rolandd20/rolandd20.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,113 @@
+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", fallback="dep/fmt")
+hostpackage(name="sqlite3_host_lib", package="sqlite3")
+
+clibrary(name="protocol", hdrs={"protocol.h": "./protocol.h"})
+
+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/ab.mk

@@ -0,0 +1,91 @@
+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
+HOST_PKG_CONFIG ?= $(PKG_CONFIG)
+ECHO ?= echo
+CP ?= cp
+
+export PKG_CONFIG
+export HOST_PKG_CONFIG
+
+ifdef VERBOSE
+	hide =
+else
+	ifdef V
+		hide =
+	else
+		hide = @
+	endif
+endif
+
+WINDOWS := no
+OSX := no
+LINUX := no
+ifeq ($(OS),Windows_NT)
+    WINDOWS := yes
+else
+    UNAME_S := $(shell uname -s)
+    ifeq ($(UNAME_S),Linux)
+		LINUX := yes
+    endif
+    ifeq ($(UNAME_S),Darwin)
+		OSX := yes
+    endif
+endif
+
+ifeq ($(OS), Windows_NT)
+	EXT ?= .exe
+endif
+EXT ?=
+
+ifeq ($(PROGRESSINFO),)
+# The first make invocation here has to have its output discarded or else it
+# produces spurious 'Leaving directory' messages... don't know why.
+rulecount := $(strip $(shell $(MAKE) --no-print-directory -q $(OBJ)/build.mk PROGRESSINFO=1 > /dev/null \
+	&& $(MAKE) --no-print-directory -n $(MAKECMDGOALS) PROGRESSINFO=XXXPROGRESSINFOXXX | grep XXXPROGRESSINFOXXX | wc -l))
+ruleindex := 1
+PROGRESSINFO = "[$(ruleindex)/$(rulecount)]$(eval ruleindex := $(shell expr $(ruleindex) + 1))"
+endif
+
+PKG_CONFIG_HASHES = $(OBJ)/.pkg-config-hashes/target-$(word 1, $(shell $(PKG_CONFIG) --list-all | md5sum))
+HOST_PKG_CONFIG_HASHES = $(OBJ)/.pkg-config-hashes/host-$(word 1, $(shell $(HOST_PKG_CONFIG) --list-all | md5sum))
+
+$(OBJ)/build.mk : $(PKG_CONFIG_HASHES) $(HOST_PKG_CONFIG_HASHES)
+$(PKG_CONFIG_HASHES) $(HOST_PKG_CONFIG_HASHES) &:
+	$(hide) rm -rf $(OBJ)/.pkg-config-hashes
+	$(hide) mkdir -p $(OBJ)/.pkg-config-hashes
+	$(hide) touch $(PKG_CONFIG_HASHES) $(HOST_PKG_CONFIG_HASHES)
+
+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,548 @@
+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.deps = []
+        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}") if label else None,
+        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="",
+        )
+        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,394 @@
+from build.ab import (
+    Rule,
+    Targets,
+    TargetsMap,
+    filenameof,
+    filenamesof,
+    flatten,
+    simplerule,
+    emit,
+)
+from build.utils import filenamesmatchingof, stripext, collectattrs
+from os.path import *
+
+emit(
+    """
+ifeq ($(OSX),no)
+HOSTSTARTGROUP ?= -Wl,--start-group
+HOSTENDGROUP ?= -Wl,--end-group
+endif
+STARTGROUP ?= $(HOSTSTARTGROUP)
+ENDGROUP ?= $(HOSTENDGROUP)
+"""
+)
+
+
+class Toolchain:
+    label = ""
+    cfile = ["$(CC) -c -o {outs[0]} {ins[0]} $(CFLAGS) {cflags}"]
+    cxxfile = ["$(CXX) -c -o {outs[0]} {ins[0]} $(CFLAGS) {cflags}"]
+    clibrary = ["rm -f {outs[0]} && $(AR) cqs {outs[0]} {ins}"]
+    cxxlibrary = ["rm -f {outs[0]} && $(AR) cqs {outs[0]} {ins}"]
+    cprogram = [
+        "$(CC) -o {outs[0]} $(STARTGROUP) {ins} {ldflags} $(LDFLAGS) $(ENDGROUP)"
+    ]
+    cxxprogram = [
+        "$(CXX) -o {outs[0]} $(STARTGROUP) {ins} {ldflags} $(LDFLAGS) $(ENDGROUP)"
+    ]
+
+
+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 = ["rm -f {outs[0]} && $(HOSTAR) cqs {outs[0]} {ins}"]
+    cxxlibrary = ["rm -f {outs[0]} && $(HOSTAR) cqs {outs[0]} {ins}"]
+    cprogram = [
+        "$(HOSTCC) -o {outs[0]} $(HOSTSTARTGROUP) {ins} {ldflags} $(HOSTLDFLAGS) $(HOSTENDGROUP)"
+    ]
+    cxxprogram = [
+        "$(HOSTCXX) -o {outs[0]} $(HOSTSTARTGROUP) {ins} {ldflags} $(HOSTLDFLAGS) $(HOSTENDGROUP)"
+    ]
+
+
+def _indirect(deps, name):
+    r = set()
+    for d in deps:
+        r.update(d.args.get(name, {d}))
+    return r
+
+
+def cfileimpl(self, name, srcs, deps, suffix, commands, label, kind, cflags):
+    outleaf = "=" + stripext(basename(filenameof(srcs[0]))) + suffix
+
+    hdr_deps = _indirect(deps, "cheader_deps")
+    cflags = collectattrs(
+        targets=hdr_deps, name="caller_cflags", initial=cflags
+    )
+
+    t = simplerule(
+        replaces=self,
+        ins=srcs,
+        deps=sorted(_indirect(hdr_deps, "cheader_files")),
+        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):
+    for f in filenamesof(srcs):
+        if f.endswith(".h") or f.endswith(".hh"):
+            cflags = cflags + [f"-I{dirname(f)}"]
+
+    objs = []
+    for s in flatten(srcs):
+        objs += [
+            filerule(
+                name=join(name, f.removeprefix("$(OBJ)/")),
+                srcs=[f],
+                deps=deps,
+                cflags=sorted(set(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
+
+
+def libraryimpl(
+    self,
+    name,
+    srcs,
+    deps,
+    hdrs,
+    caller_cflags,
+    caller_ldflags,
+    cflags,
+    ldflags,
+    toolchain,
+    commands,
+    label,
+    kind,
+):
+    hdr_deps = _indirect(deps, "cheader_deps") | {self}
+    lib_deps = _indirect(deps, "clibrary_deps") | {self}
+
+    hr = None
+    hf = []
+    ar = None
+    if hdrs:
+        cs = []
+        ins = 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
+
+        hr = simplerule(
+            name=f"{self.localname}_hdr",
+            ins=ins,
+            outs=outs,
+            commands=cs,
+            label="CHEADERS",
+        )
+        hr.materialise()
+        hf = [f"-I{hr.dir}"]
+
+    if srcs:
+        objs = findsources(
+            self.localname,
+            srcs,
+            deps + ([hr] if hr else []),
+            cflags + hf,
+            toolchain,
+            kind,
+            self.cwd,
+        )
+
+        ar = simplerule(
+            name=f"{self.localname}_lib",
+            ins=objs,
+            outs=[f"={self.localname}.a"],
+            label=label,
+            commands=commands,
+        )
+        ar.materialise()
+
+    self.outs = ([hr] if hr else []) + ([ar] if ar else [])
+    self.deps = self.outs
+    self.args["cheader_deps"] = hdr_deps
+    self.args["clibrary_deps"] = lib_deps
+    self.args["cheader_files"] = [hr] if hr else []
+    self.args["clibrary_files"] = [ar] if ar else []
+    self.args["caller_cflags"] = caller_cflags + hf
+    self.args["caller_ldflags"] = caller_ldflags
+
+
+@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,
+    cxxfilerule=cxxfile,
+):
+    if not label:
+        label = toolchain.label + "LIB"
+    if not commands:
+        commands = toolchain.cxxlibrary
+    libraryimpl(
+        self,
+        name,
+        srcs,
+        deps,
+        hdrs,
+        caller_cflags,
+        caller_ldflags,
+        cflags,
+        ldflags,
+        toolchain,
+        commands,
+        label,
+        cxxfilerule,
+    )
+
+
+def programimpl(
+    self,
+    name,
+    srcs,
+    deps,
+    cflags,
+    ldflags,
+    toolchain,
+    commands,
+    label,
+    filerule,
+    kind,
+):
+    cfiles = findsources(
+        self.localname, srcs, deps, cflags, toolchain, filerule, self.cwd
+    )
+
+    lib_deps = set()
+    for d in deps:
+        lib_deps.update(d.args.get("clibrary_deps", {d}))
+    libs = sorted(filenamesmatchingof(lib_deps, "*.a"))
+    ldflags = collectattrs(
+        targets=lib_deps, name="caller_ldflags", initial=ldflags
+    )
+
+    simplerule(
+        replaces=self,
+        ins=cfiles + libs,
+        outs=[f"={self.localname}$(EXT)"],
+        deps=sorted(_indirect(lib_deps, "clibrary_files")),
+        label=toolchain.label + label,
+        commands=commands,
+        args={
+            "ldflags": collectattrs(
+                targets=lib_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",
+):
+    if not commands:
+        commands = toolchain.cprogram
+    programimpl(
+        self,
+        name,
+        srcs,
+        deps,
+        cflags,
+        ldflags,
+        toolchain,
+        commands,
+        label,
+        cfile,
+        "cprogram",
+    )
+
+
+@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,77 @@
+from build.ab import Rule, emit, Target, filenamesof
+from types import SimpleNamespace
+import os
+import subprocess
+
+
+class _PkgConfig:
+    package_present = set()
+    package_properties = {}
+    pkgconfig = None
+
+    def __init__(self, cmd):
+        assert cmd, "no pkg-config environment variable supplied"
+        self.pkgconfig = cmd
+
+        r = subprocess.run(f"{cmd} --list-all", shell=True, capture_output=True)
+        ps = r.stdout.decode("utf-8")
+        self.package_present = {l.split(" ", 1)[0] for l in ps.splitlines()}
+
+    def has_package(self, name):
+        return name in self.package_present
+
+    def get_property(self, name, flag):
+        p = f"{name}.{flag}"
+        if p not in self.package_properties:
+            r = subprocess.run(
+                f"{self.pkgconfig} {flag} {name}",
+                shell=True,
+                capture_output=True,
+            )
+            self.package_properties[p] = r.stdout.decode("utf-8").strip()
+        return self.package_properties[p]
+
+
+TargetPkgConfig = _PkgConfig(os.getenv("PKG_CONFIG"))
+HostPkgConfig = _PkgConfig(os.getenv("HOST_PKG_CONFIG"))
+
+
+def _package(self, name, package, fallback, pkgconfig):
+    if pkgconfig.has_package(package):
+        cflags = pkgconfig.get_property(package, "--cflags")
+        ldflags = pkgconfig.get_property(package, "--libs")
+
+        if cflags:
+            self.args["caller_cflags"] = [cflags]
+        if ldflags:
+            self.args["caller_ldflags"] = [ldflags]
+        self.traits.add("clibrary")
+        self.traits.add("cheaders")
+        return
+
+    assert (
+        fallback
+    ), f"Required package '{package}' not installed when materialising target '{name}'"
+
+    if "cheader_deps" in fallback.args:
+        self.args["cheader_deps"] = fallback.args["cheader_deps"]
+    if "clibrary_deps" in fallback.args:
+        self.args["clibrary_deps"] = fallback.args["clibrary_deps"]
+    if "cheader_files" in fallback.args:
+        self.args["cheader_files"] = fallback.args["cheader_files"]
+    if "clibrary_files" in fallback.args:
+        self.args["clibrary_files"] = fallback.args["clibrary_files"]
+    self.ins = fallback.ins
+    self.outs = fallback.outs
+    self.deps = fallback.deps
+    self.traits = fallback.traits
+
+
+@Rule
+def package(self, name, package=None, fallback: Target = None):
+    _package(self, name, package, fallback, TargetPkgConfig)
+
+
+@Rule
+def hostpackage(self, name, package=None, fallback: Target = None):
+    _package(self, name, package, fallback, HostPkgConfig)

build/protobuf.py

@@ -0,0 +1,173 @@
+from build.ab import Rule, Targets, emit, simplerule, filenamesof
+from build.utils import filenamesmatchingof, collectattrs
+from os.path import join, abspath, dirname, relpath
+import build.pkg  # to get the protobuf package check
+
+emit(
+    """
+PROTOC ?= protoc
+"""
+)
+
+assert build.pkg.TargetPkgConfig.has_package(
+    "protobuf"
+), "required package 'protobuf' not installed"
+
+
+def _getprotodeps(deps):
+    r = set()
+    for d in deps:
+        r.update(d.args.get("protodeps", {d}))
+    return sorted(r)
+
+
+@Rule
+def proto(self, name, srcs: Targets = [], deps: Targets = []):
+    protodeps = _getprotodeps(deps)
+    descriptorlist = ":".join(
+        [
+            relpath(f, start=self.dir)
+            for f in filenamesmatchingof(protodeps, "*.descriptor")
+        ]
+    )
+
+    dirs = sorted({"{dir}/" + dirname(f) for f in filenamesof(srcs)})
+    simplerule(
+        replaces=self,
+        ins=srcs,
+        outs=[f"={self.localname}.descriptor"],
+        deps=protodeps,
+        commands=(
+            ["mkdir -p " + (" ".join(dirs))]
+            + [f"$(CP) {f} {{dir}}/{f}" for f in filenamesof(srcs)]
+            + [
+                "cd {dir} && "
+                + (
+                    " ".join(
+                        [
+                            "$(PROTOC)",
+                            "--proto_path=.",
+                            "--include_source_info",
+                            f"--descriptor_set_out={self.localname}.descriptor",
+                        ]
+                        + (
+                            [f"--descriptor_set_in={descriptorlist}"]
+                            if descriptorlist
+                            else []
+                        )
+                        + ["{ins}"]
+                    )
+                )
+            ]
+        ),
+        label="PROTO",
+        args={
+            "protosrcs": filenamesof(srcs),
+            "protodeps": set(protodeps) | {self},
+        },
+    )
+
+
+@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]
+        outs += ["=" + cc, "=" + h]
+
+    protodeps = _getprotodeps(deps + srcs)
+    descriptorlist = ":".join(
+        [
+            relpath(f, start=self.dir)
+            for f in filenamesmatchingof(protodeps, "*.descriptor")
+        ]
+    )
+
+    r = simplerule(
+        name=f"{self.localname}_srcs",
+        cwd=self.cwd,
+        ins=srcs,
+        outs=outs,
+        deps=protodeps,
+        commands=[
+            "cd {dir} && "
+            + (
+                " ".join(
+                    [
+                        "$(PROTOC)",
+                        "--proto_path=.",
+                        "--cpp_out=.",
+                        f"--descriptor_set_in={descriptorlist}",
+                    ]
+                    + protos
+                )
+            )
+        ],
+        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]
+
+    descriptorlist = ":".join(
+        [abspath(f) for f in filenamesmatchingof(srcs + deps, "*.descriptor")]
+    )
+
+    r = simplerule(
+        name=f"{self.localname}_srcs",
+        cwd=self.cwd,
+        ins=protos,
+        outs=[f"={self.localname}.srcjar"],
+        deps=srcs + deps,
+        commands=[
+            "mkdir -p {dir}/srcs",
+            "cd {dir} && "
+            + (
+                " ".join(
+                    [
+                        "$(PROTOC)",
+                        "--proto_path=.",
+                        "--java_out=.",
+                        f"--descriptor_set_in={descriptorlist}",
+                    ]
+                    + protos
+                )
+            ),
+            "$(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(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/adf_nativ.h

@@ -2,33 +2,34 @@
 #define ADF_NATIV_H
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
 #include "adf_str.h"
 
 #define NATIVE_FILE 8001
 
-struct nativeDevice
-{
-	FILE* fd;
-};
+    struct nativeDevice
+    {
+        FILE* fd;
+    };
 
-struct nativeFunctions
-{
-    /* called by adfMount() */
-    RETCODE (*adfInitDevice)(struct Device*, char*, BOOL);
-    /* called by adfReadBlock() */
-    RETCODE (*adfNativeReadSector)(struct Device*, int32_t, int, uint8_t*);
-    /* called by adfWriteBlock() */
-    RETCODE (*adfNativeWriteSector)(struct Device*, int32_t, int, uint8_t*);
-    /* called by adfMount() */
-    BOOL (*adfIsDevNative)(char*);
-    /* called by adfUnMount() */
-    RETCODE (*adfReleaseDevice)(struct Device*);
-};
+    struct nativeFunctions
+    {
+        /* called by adfMount() */
+        RETCODE (*adfInitDevice)(struct Device*, char*, BOOL);
+        /* called by adfReadBlock() */
+        RETCODE (*adfNativeReadSector)(struct Device*, int32_t, int, uint8_t*);
+        /* called by adfWriteBlock() */
+        RETCODE (*adfNativeWriteSector)(struct Device*, int32_t, int, uint8_t*);
+        /* called by adfMount() */
+        BOOL (*adfIsDevNative)(char*);
+        /* called by adfUnMount() */
+        RETCODE (*adfReleaseDevice)(struct Device*);
+    };
 
-extern void adfInitNativeFct();
+    extern void adfInitNativeFct();
 
 #ifdef __cplusplus
 }

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 =
-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/adflib/config.h

@@ -1,2 +1 @@
 /* empty config.h to keep the source happy */
-

dep/adflib/src/adf_bitm.h

@@ -27,25 +27,28 @@
  *
  */
 
-#include"adf_str.h"
-#include"prefix.h"
+#include "adf_str.h"
+#include "prefix.h"
 
 RETCODE adfReadBitmapBlock(struct Volume*, SECTNUM nSect, struct bBitmapBlock*);
-RETCODE adfWriteBitmapBlock(struct Volume*, SECTNUM nSect, struct bBitmapBlock*);
-RETCODE adfReadBitmapExtBlock(struct Volume*, SECTNUM nSect, struct bBitmapExtBlock*);
-RETCODE adfWriteBitmapExtBlock(struct Volume*, SECTNUM, struct bBitmapExtBlock* );
+RETCODE adfWriteBitmapBlock(
+    struct Volume*, SECTNUM nSect, struct bBitmapBlock*);
+RETCODE adfReadBitmapExtBlock(
+    struct Volume*, SECTNUM nSect, struct bBitmapExtBlock*);
+RETCODE adfWriteBitmapExtBlock(
+    struct Volume*, SECTNUM, struct bBitmapExtBlock*);
 
-SECTNUM adfGet1FreeBlock(struct Volume *vol);
-RETCODE adfUpdateBitmap(struct Volume *vol);
+SECTNUM adfGet1FreeBlock(struct Volume* vol);
+RETCODE adfUpdateBitmap(struct Volume* vol);
 PREFIX int32_t adfCountFreeBlocks(struct Volume* vol);
-RETCODE adfReadBitmap(struct Volume* , SECTNUM nBlock, struct bRootBlock* root);
+RETCODE adfReadBitmap(struct Volume*, SECTNUM nBlock, struct bRootBlock* root);
 BOOL adfIsBlockFree(struct Volume* vol, SECTNUM nSect);
 void adfSetBlockFree(struct Volume* vol, SECTNUM nSect);
 void adfSetBlockUsed(struct Volume* vol, SECTNUM nSect);
 BOOL adfGetFreeBlocks(struct Volume* vol, int nbSect, SECTNUM* sectList);
-RETCODE adfCreateBitmap(struct Volume *vol);
-RETCODE adfWriteNewBitmap(struct Volume *vol);
-void adfFreeBitmap(struct Volume *vol);
+RETCODE adfCreateBitmap(struct Volume* vol);
+RETCODE adfWriteNewBitmap(struct Volume* vol);
+void adfFreeBitmap(struct Volume* vol);
 
 #endif /* ADF_BITM_H */
 

dep/adflib/src/adf_blk.h

@@ -25,264 +25,255 @@
  *
  */
 
-
 #ifndef ADF_BLK_H
 #define ADF_BLK_H 1
 
-#define ULONG   uint32_t
-#define USHORT  uint16_t
-#define UCHAR   uint8_t
+#define ULONG uint32_t
+#define USHORT uint16_t
+#define UCHAR uint8_t
 
-#define LOGICAL_BLOCK_SIZE    512
+#define LOGICAL_BLOCK_SIZE 512
 
 /* ----- FILE SYSTEM ----- */
 
-#define FSMASK_FFS         1
-#define FSMASK_INTL        2
-#define FSMASK_DIRCACHE    4
-
-#define isFFS(c)           ((c)&FSMASK_FFS)
-#define isOFS(c)           (!((c)&FSMASK_FFS))
-#define isINTL(c)          ((c)&FSMASK_INTL)
-#define isDIRCACHE(c)      ((c)&FSMASK_DIRCACHE)
+#define FSMASK_FFS 1
+#define FSMASK_INTL 2
+#define FSMASK_DIRCACHE 4
 
+#define isFFS(c) ((c)&FSMASK_FFS)
+#define isOFS(c) (!((c)&FSMASK_FFS))
+#define isINTL(c) ((c)&FSMASK_INTL)
+#define isDIRCACHE(c) ((c)&FSMASK_DIRCACHE)
 
 /* ----- ENTRIES ----- */
 
 /* access constants */
 
-#define ACCMASK_D	(1<<0)
-#define ACCMASK_E	(1<<1)
-#define ACCMASK_W	(1<<2)
-#define ACCMASK_R	(1<<3)
-#define ACCMASK_A	(1<<4)
-#define ACCMASK_P	(1<<5)
-#define ACCMASK_S	(1<<6)
-#define ACCMASK_H	(1<<7)
-
-#define hasD(c)    ((c)&ACCMASK_D)
-#define hasE(c)    ((c)&ACCMASK_E)
-#define hasW(c)    ((c)&ACCMASK_W)
-#define hasR(c)    ((c)&ACCMASK_R)
-#define hasA(c)    ((c)&ACCMASK_A)
-#define hasP(c)	   ((c)&ACCMASK_P)
-#define hasS(c)    ((c)&ACCMASK_S)
-#define hasH(c)    ((c)&ACCMASK_H)
+#define ACCMASK_D (1 << 0)
+#define ACCMASK_E (1 << 1)
+#define ACCMASK_W (1 << 2)
+#define ACCMASK_R (1 << 3)
+#define ACCMASK_A (1 << 4)
+#define ACCMASK_P (1 << 5)
+#define ACCMASK_S (1 << 6)
+#define ACCMASK_H (1 << 7)
 
+#define hasD(c) ((c)&ACCMASK_D)
+#define hasE(c) ((c)&ACCMASK_E)
+#define hasW(c) ((c)&ACCMASK_W)
+#define hasR(c) ((c)&ACCMASK_R)
+#define hasA(c) ((c)&ACCMASK_A)
+#define hasP(c) ((c)&ACCMASK_P)
+#define hasS(c) ((c)&ACCMASK_S)
+#define hasH(c) ((c)&ACCMASK_H)
 
 /* ----- BLOCKS ----- */
 
 /* block constants */
 
-#define BM_VALID	-1
-#define BM_INVALID	0
+#define BM_VALID -1
+#define BM_INVALID 0
 
-#define HT_SIZE		72
-#define BM_SIZE     25
-#define MAX_DATABLK	72
-
-#define MAXNAMELEN	30
-#define MAXCMMTLEN	79
+#define HT_SIZE 72
+#define BM_SIZE 25
+#define MAX_DATABLK 72
 
+#define MAXNAMELEN 30
+#define MAXCMMTLEN 79
 
 /* block primary and secondary types */
 
-#define T_HEADER	2
-#define ST_ROOT		1
-#define ST_DIR		2
-#define ST_FILE		-3
-#define ST_LFILE	-4
-#define ST_LDIR		4
-#define ST_LSOFT	3
-#define T_LIST		16
-#define T_DATA		8
-#define T_DIRC		33
-
+#define T_HEADER 2
+#define ST_ROOT 1
+#define ST_DIR 2
+#define ST_FILE -3
+#define ST_LFILE -4
+#define ST_LDIR 4
+#define ST_LSOFT 3
+#define T_LIST 16
+#define T_DATA 8
+#define T_DIRC 33
 
 /*--- blocks structures --- */
 
-
-struct bBootBlock {
-/*000*/	char	dosType[4];
-/*004*/	ULONG	checkSum;
-/*008*/	int32_t	rootBlock;
-/*00c*/	UCHAR	data[500+512];
+struct bBootBlock
+{
+    /*000*/ char dosType[4];
+    /*004*/ ULONG checkSum;
+    /*008*/ int32_t rootBlock;
+    /*00c*/ UCHAR data[500 + 512];
 };
 
-
-struct bRootBlock {
-/*000*/	int32_t	type;
-        int32_t	headerKey;
-        int32_t	highSeq;
-/*00c*/	int32_t	hashTableSize;
-        int32_t	firstData;
-/*014*/	ULONG	checkSum;
-/*018*/	int32_t	hashTable[HT_SIZE];		/* hash table */
-/*138*/	int32_t	bmFlag;				/* bitmap flag, -1 means VALID */
-/*13c*/	int32_t	bmPages[BM_SIZE];
-/*1a0*/	int32_t	bmExt;
-/*1a4*/	int32_t	cDays; 	/* creation date FFS and OFS */
-/*1a8*/	int32_t	cMins;
-/*1ac*/	int32_t	cTicks;
-/*1b0*/	char	nameLen;
-/*1b1*/	char 	diskName[MAXNAMELEN+1];
-        char	r2[8];
-/*1d8*/	int32_t	days;		/* last access : days after 1 jan 1978 */
-/*1dc*/	int32_t	mins;		/* hours and minutes in minutes */
-/*1e0*/	int32_t	ticks;		/* 1/50 seconds */
-/*1e4*/	int32_t	coDays;	/* creation date OFS */
-/*1e8*/	int32_t	coMins;
-/*1ec*/	int32_t	coTicks;
-        int32_t	nextSameHash;	/* == 0 */
-        int32_t	parent;		/* == 0 */
-/*1f8*/	int32_t	extension;		/* FFS: first directory cache block */
-/*1fc*/	int32_t	secType;	/* == 1 */
+struct bRootBlock
+{
+    /*000*/ int32_t type;
+    int32_t headerKey;
+    int32_t highSeq;
+    /*00c*/ int32_t hashTableSize;
+    int32_t firstData;
+    /*014*/ ULONG checkSum;
+    /*018*/ int32_t hashTable[HT_SIZE]; /* hash table */
+    /*138*/ int32_t bmFlag;             /* bitmap flag, -1 means VALID */
+    /*13c*/ int32_t bmPages[BM_SIZE];
+    /*1a0*/ int32_t bmExt;
+    /*1a4*/ int32_t cDays; /* creation date FFS and OFS */
+    /*1a8*/ int32_t cMins;
+    /*1ac*/ int32_t cTicks;
+    /*1b0*/ char nameLen;
+    /*1b1*/ char diskName[MAXNAMELEN + 1];
+    char r2[8];
+    /*1d8*/ int32_t days;   /* last access : days after 1 jan 1978 */
+    /*1dc*/ int32_t mins;   /* hours and minutes in minutes */
+    /*1e0*/ int32_t ticks;  /* 1/50 seconds */
+    /*1e4*/ int32_t coDays; /* creation date OFS */
+    /*1e8*/ int32_t coMins;
+    /*1ec*/ int32_t coTicks;
+    int32_t nextSameHash;      /* == 0 */
+    int32_t parent;            /* == 0 */
+    /*1f8*/ int32_t extension; /* FFS: first directory cache block */
+    /*1fc*/ int32_t secType;   /* == 1 */
 };
 
-
-struct bFileHeaderBlock {
-/*000*/	int32_t	type;		/* == 2 */
-/*004*/	int32_t	headerKey;	/* current block number */
-/*008*/	int32_t	highSeq;	/* number of data block in this hdr block */
-/*00c*/	int32_t	dataSize;	/* == 0 */
-/*010*/	int32_t	firstData;
-/*014*/	ULONG	checkSum;
-/*018*/	int32_t	dataBlocks[MAX_DATABLK];
-/*138*/	int32_t	r1;
-/*13c*/	int32_t	r2;
-/*140*/	int32_t	access;	/* bit0=del, 1=modif, 2=write, 3=read */
-/*144*/	uint32_t	byteSize;
-/*148*/	char	commLen;
-/*149*/	char	comment[MAXCMMTLEN+1];
-        char	r3[91-(MAXCMMTLEN+1)];
-/*1a4*/	int32_t	days;
-/*1a8*/	int32_t	mins;
-/*1ac*/	int32_t	ticks;
-/*1b0*/	char	nameLen;
-/*1b1*/	char	fileName[MAXNAMELEN+1];
-        int32_t	r4;
-/*1d4*/	int32_t	real;		/* unused == 0 */
-/*1d8*/	int32_t	nextLink;	/* link chain */
-        int32_t	r5[5];
-/*1f0*/	int32_t	nextSameHash;	/* next entry with sane hash */
-/*1f4*/	int32_t	parent;		/* parent directory */
-/*1f8*/	int32_t	extension;	/* pointer to extension block */
-/*1fc*/	int32_t	secType;	/* == -3 */
+struct bFileHeaderBlock
+{
+    /*000*/ int32_t type;      /* == 2 */
+    /*004*/ int32_t headerKey; /* current block number */
+    /*008*/ int32_t highSeq;   /* number of data block in this hdr block */
+    /*00c*/ int32_t dataSize;  /* == 0 */
+    /*010*/ int32_t firstData;
+    /*014*/ ULONG checkSum;
+    /*018*/ int32_t dataBlocks[MAX_DATABLK];
+    /*138*/ int32_t r1;
+    /*13c*/ int32_t r2;
+    /*140*/ int32_t access; /* bit0=del, 1=modif, 2=write, 3=read */
+    /*144*/ uint32_t byteSize;
+    /*148*/ char commLen;
+    /*149*/ char comment[MAXCMMTLEN + 1];
+    char r3[91 - (MAXCMMTLEN + 1)];
+    /*1a4*/ int32_t days;
+    /*1a8*/ int32_t mins;
+    /*1ac*/ int32_t ticks;
+    /*1b0*/ char nameLen;
+    /*1b1*/ char fileName[MAXNAMELEN + 1];
+    int32_t r4;
+    /*1d4*/ int32_t real;     /* unused == 0 */
+    /*1d8*/ int32_t nextLink; /* link chain */
+    int32_t r5[5];
+    /*1f0*/ int32_t nextSameHash; /* next entry with sane hash */
+    /*1f4*/ int32_t parent;       /* parent directory */
+    /*1f8*/ int32_t extension;    /* pointer to extension block */
+    /*1fc*/ int32_t secType;      /* == -3 */
 };
 
-
 /*--- file header extension block structure ---*/
 
-struct bFileExtBlock {
-/*000*/	int32_t	type;		/* == 0x10 */
-/*004*/	int32_t	headerKey;
-/*008*/	int32_t	highSeq;
-/*00c*/	int32_t	dataSize;	/* == 0 */
-/*010*/	int32_t	firstData;	/* == 0 */
-/*014*/	ULONG	checkSum;
-/*018*/	int32_t	dataBlocks[MAX_DATABLK];
-        int32_t	r[45];
-        int32_t	info;		/* == 0 */
-        int32_t	nextSameHash;	/* == 0 */
-/*1f4*/	int32_t	parent;		/* header block */
-/*1f8*/	int32_t	extension;	/* next header extension block */
-/*1fc*/	int32_t	secType;	/* -3 */	
+struct bFileExtBlock
+{
+    /*000*/ int32_t type; /* == 0x10 */
+    /*004*/ int32_t headerKey;
+    /*008*/ int32_t highSeq;
+    /*00c*/ int32_t dataSize;  /* == 0 */
+    /*010*/ int32_t firstData; /* == 0 */
+    /*014*/ ULONG checkSum;
+    /*018*/ int32_t dataBlocks[MAX_DATABLK];
+    int32_t r[45];
+    int32_t info;              /* == 0 */
+    int32_t nextSameHash;      /* == 0 */
+    /*1f4*/ int32_t parent;    /* header block */
+    /*1f8*/ int32_t extension; /* next header extension block */
+    /*1fc*/ int32_t secType;   /* -3 */
 };
 
-
-
-struct bDirBlock {
-/*000*/	int32_t	type;		/* == 2 */
-/*004*/	int32_t	headerKey;
-/*008*/	int32_t	highSeq;	/* == 0 */
-/*00c*/	int32_t	hashTableSize;	/* == 0 */
-        int32_t	r1;		/* == 0 */
-/*014*/	ULONG	checkSum;
-/*018*/	int32_t	hashTable[HT_SIZE];		/* hash table */
-        int32_t	r2[2];
-/*140*/	int32_t	access;
-        int32_t	r4;		/* == 0 */
-/*148*/	char	commLen;
-/*149*/	char	comment[MAXCMMTLEN+1];
-        char	r5[91-(MAXCMMTLEN+1)];
-/*1a4*/	int32_t	days;		/* last access */
-/*1a8*/	int32_t	mins;
-/*1ac*/	int32_t	ticks;
-/*1b0*/	char	nameLen;
-/*1b1*/	char 	dirName[MAXNAMELEN+1];
-        int32_t	r6;
-/*1d4*/	int32_t	real;		/* ==0 */
-/*1d8*/	int32_t	nextLink;	/* link list */
-        int32_t	r7[5];
-/*1f0*/	int32_t	nextSameHash;
-/*1f4*/	int32_t	parent;
-/*1f8*/	int32_t	extension;		/* FFS : first directory cache */
-/*1fc*/	int32_t	secType;	/* == 2 */
+struct bDirBlock
+{
+    /*000*/ int32_t type; /* == 2 */
+    /*004*/ int32_t headerKey;
+    /*008*/ int32_t highSeq;       /* == 0 */
+    /*00c*/ int32_t hashTableSize; /* == 0 */
+    int32_t r1;                    /* == 0 */
+    /*014*/ ULONG checkSum;
+    /*018*/ int32_t hashTable[HT_SIZE]; /* hash table */
+    int32_t r2[2];
+    /*140*/ int32_t access;
+    int32_t r4; /* == 0 */
+    /*148*/ char commLen;
+    /*149*/ char comment[MAXCMMTLEN + 1];
+    char r5[91 - (MAXCMMTLEN + 1)];
+    /*1a4*/ int32_t days; /* last access */
+    /*1a8*/ int32_t mins;
+    /*1ac*/ int32_t ticks;
+    /*1b0*/ char nameLen;
+    /*1b1*/ char dirName[MAXNAMELEN + 1];
+    int32_t r6;
+    /*1d4*/ int32_t real;     /* ==0 */
+    /*1d8*/ int32_t nextLink; /* link list */
+    int32_t r7[5];
+    /*1f0*/ int32_t nextSameHash;
+    /*1f4*/ int32_t parent;
+    /*1f8*/ int32_t extension; /* FFS : first directory cache */
+    /*1fc*/ int32_t secType;   /* == 2 */
 };
 
-
-
-struct bOFSDataBlock{
-/*000*/	int32_t	type;		/* == 8 */
-/*004*/	int32_t	headerKey;	/* pointer to file_hdr block */
-/*008*/	int32_t	seqNum;	/* file data block number */
-/*00c*/	int32_t	dataSize;	/* <= 0x1e8 */
-/*010*/	int32_t	nextData;	/* next data block */
-/*014*/	ULONG	checkSum;
-/*018*/	UCHAR	data[488];
+struct bOFSDataBlock
+{
+    /*000*/ int32_t type;      /* == 8 */
+    /*004*/ int32_t headerKey; /* pointer to file_hdr block */
+    /*008*/ int32_t seqNum;    /* file data block number */
+    /*00c*/ int32_t dataSize;  /* <= 0x1e8 */
+    /*010*/ int32_t nextData;  /* next data block */
+    /*014*/ ULONG checkSum;
+    /*018*/ UCHAR data[488];
 /*200*/	};
 
-
 /* --- bitmap --- */
 
-struct bBitmapBlock {
-/*000*/	ULONG	checkSum;
-/*004*/	ULONG	map[127];
-	};
-
-
-struct bBitmapExtBlock {
-/*000*/	int32_t	bmPages[127];
-/*1fc*/	int32_t	nextBlock;
-	};
-
-
-struct bLinkBlock {
-/*000*/	int32_t	type;		/* == 2 */
-/*004*/	int32_t	headerKey;	/* self pointer */
-        int32_t	r1[3];
-/*014*/	ULONG	checkSum;
-/*018*/	char	realName[64];
-        int32_t	r2[83];
-/*1a4*/	int32_t	days;		/* last access */
-/*1a8*/	int32_t	mins;
-/*1ac*/	int32_t	ticks;
-/*1b0*/	char	nameLen;
-/*1b1*/	char 	name[MAXNAMELEN+1];
-        int32_t	r3;
-/*1d4*/	int32_t	realEntry;
-/*1d8*/	int32_t	nextLink;
-        int32_t	r4[5];
-/*1f0*/	int32_t	nextSameHash;
-/*1f4*/	int32_t	parent;	
-        int32_t	r5;
-/*1fc*/	int32_t	secType;	/* == -4, 4, 3 */
-	};
+struct bBitmapBlock
+{
+    /*000*/ ULONG checkSum;
+    /*004*/ ULONG map[127];
+};
 
+struct bBitmapExtBlock
+{
+    /*000*/ int32_t bmPages[127];
+    /*1fc*/ int32_t nextBlock;
+};
 
+struct bLinkBlock
+{
+    /*000*/ int32_t type;      /* == 2 */
+    /*004*/ int32_t headerKey; /* self pointer */
+    int32_t r1[3];
+    /*014*/ ULONG checkSum;
+    /*018*/ char realName[64];
+    int32_t r2[83];
+    /*1a4*/ int32_t days; /* last access */
+    /*1a8*/ int32_t mins;
+    /*1ac*/ int32_t ticks;
+    /*1b0*/ char nameLen;
+    /*1b1*/ char name[MAXNAMELEN + 1];
+    int32_t r3;
+    /*1d4*/ int32_t realEntry;
+    /*1d8*/ int32_t nextLink;
+    int32_t r4[5];
+    /*1f0*/ int32_t nextSameHash;
+    /*1f4*/ int32_t parent;
+    int32_t r5;
+    /*1fc*/ int32_t secType; /* == -4, 4, 3 */
+};
 
 /*--- directory cache block structure ---*/
 
-struct bDirCacheBlock {
-/*000*/	int32_t	type;		/* == 33 */
-/*004*/	int32_t	headerKey;
-/*008*/	int32_t	parent;
-/*00c*/	int32_t	recordsNb;
-/*010*/	int32_t	nextDirC;
-/*014*/	ULONG	checkSum;
-/*018*/	uint8_t records[488];
-	};
-
+struct bDirCacheBlock
+{
+    /*000*/ int32_t type; /* == 33 */
+    /*004*/ int32_t headerKey;
+    /*008*/ int32_t parent;
+    /*00c*/ int32_t recordsNb;
+    /*010*/ int32_t nextDirC;
+    /*014*/ ULONG checkSum;
+    /*018*/ uint8_t records[488];
+};
 
 #endif /* ADF_BLK_H */
 /*##########################################################################*/

dep/adflib/src/adf_cache.h

@@ -27,20 +27,28 @@
  *
  */
 
-
 #include "adf_str.h"
 
-void adfGetCacheEntry(struct bDirCacheBlock *dirc, int *p, struct CacheEntry *cEntry);
-int adfPutCacheEntry( struct bDirCacheBlock *dirc, int *p, struct CacheEntry *cEntry);
+void adfGetCacheEntry(
+    struct bDirCacheBlock* dirc, int* p, struct CacheEntry* cEntry);
+int adfPutCacheEntry(
+    struct bDirCacheBlock* dirc, int* p, struct CacheEntry* cEntry);
 
-struct List* adfGetDirEntCache(struct Volume *vol, SECTNUM dir, BOOL recurs);
+struct List* adfGetDirEntCache(struct Volume* vol, SECTNUM dir, BOOL recurs);
 
-RETCODE adfCreateEmptyCache(struct Volume *vol, struct bEntryBlock *parent, SECTNUM nSect);
-RETCODE adfAddInCache(struct Volume *vol, struct bEntryBlock *parent, struct bEntryBlock *entry);
-RETCODE adfUpdateCache(struct Volume *vol, struct bEntryBlock *parent, struct bEntryBlock *entry, BOOL);
-RETCODE adfDelFromCache(struct Volume *vol, struct bEntryBlock *parent, SECTNUM);
+RETCODE adfCreateEmptyCache(
+    struct Volume* vol, struct bEntryBlock* parent, SECTNUM nSect);
+RETCODE adfAddInCache(
+    struct Volume* vol, struct bEntryBlock* parent, struct bEntryBlock* entry);
+RETCODE adfUpdateCache(struct Volume* vol,
+    struct bEntryBlock* parent,
+    struct bEntryBlock* entry,
+    BOOL);
+RETCODE adfDelFromCache(
+    struct Volume* vol, struct bEntryBlock* parent, SECTNUM);
 
-RETCODE adfReadDirCBlock(struct Volume *vol, SECTNUM nSect, struct bDirCacheBlock *dirc);
+RETCODE adfReadDirCBlock(
+    struct Volume* vol, SECTNUM nSect, struct bDirCacheBlock* dirc);
 RETCODE adfWriteDirCBlock(struct Volume*, int32_t, struct bDirCacheBlock* dirc);
 
 #endif /* _ADF_CACHE_H */

dep/adflib/src/adf_defs.h

@@ -24,7 +24,6 @@
  *
  */
 
-
 #ifndef _ADF_DEFS_H
 #define _ADF_DEFS_H 1
 
@@ -34,38 +33,33 @@
 #define SECTNUM int32_t
 #define RETCODE int32_t
 
-#define TRUE    1
-#define FALSE   0
+#define TRUE 1
+#define FALSE 0
 
 #include <stdint.h>
-#define ULONG   uint32_t
-#define USHORT  uint16_t
-#define UCHAR   uint8_t
-#define BOOL    int
-
+#define ULONG uint32_t
+#define USHORT uint16_t
+#define UCHAR uint8_t
+#define BOOL int
 
 /* defines max and min */
 
 #ifndef max
-#define max(a,b)        (a)>(b) ? (a) : (b)
+#define max(a, b) (a) > (b) ? (a) : (b)
 #endif
 #ifndef min
-#define min(a,b)        (a)<(b) ? (a) : (b)
+#define min(a, b) (a) < (b) ? (a) : (b)
 #endif
 
-
 /* (*byte) to (*short) and (*byte) to (*long) conversion */
 
-#define Short(p) ((p)[0]<<8 | (p)[1])
-#define Long(p) (Short(p)<<16 | Short(p+2))
-
+#define Short(p) ((p)[0] << 8 | (p)[1])
+#define Long(p) (Short(p) << 16 | Short(p + 2))
 
 /* swap short and swap long macros for little endian machines */
 
-#define swapShort(p) ((p)[0]<<8 | (p)[1])
-#define swapLong(p) (swapShort(p)<<16 | swapShort(p+2))
-
-
+#define swapShort(p) ((p)[0] << 8 | (p)[1])
+#define swapLong(p) (swapShort(p) << 16 | swapShort(p + 2))
 
 #endif /* _ADF_DEFS_H */
 /*##########################################################################*/

dep/adflib/src/adf_dir.h

@@ -26,45 +26,54 @@
  *
  */
 
-#include"adf_str.h"
-#include"adf_err.h"
-#include"adf_defs.h"
+#include "adf_str.h"
+#include "adf_err.h"
+#include "adf_defs.h"
 
-#include"prefix.h"
+#include "prefix.h"
 
-PREFIX RETCODE adfToRootDir(struct Volume *vol);
-BOOL isDirEmpty(struct bDirBlock *dir);
-PREFIX RETCODE adfRemoveEntry(struct Volume *vol, SECTNUM pSect, char *name);
-PREFIX struct List* adfGetDirEnt(struct Volume* vol, SECTNUM nSect );
-PREFIX struct List* adfGetRDirEnt(struct Volume* vol, SECTNUM nSect, BOOL recurs );
+PREFIX RETCODE adfToRootDir(struct Volume* vol);
+BOOL isDirEmpty(struct bDirBlock* dir);
+PREFIX RETCODE adfRemoveEntry(struct Volume* vol, SECTNUM pSect, char* name);
+PREFIX struct List* adfGetDirEnt(struct Volume* vol, SECTNUM nSect);
+PREFIX struct List* adfGetRDirEnt(
+    struct Volume* vol, SECTNUM nSect, BOOL recurs);
 PREFIX void adfFreeDirList(struct List* list);
 
-RETCODE adfEntBlock2Entry(struct bEntryBlock *entryBlk, struct Entry *entry);
-PREFIX void adfFreeEntry(struct Entry *entry);
-RETCODE adfCreateFile(struct Volume* vol, SECTNUM parent, char *name,
-    struct bFileHeaderBlock *fhdr);
+RETCODE adfEntBlock2Entry(struct bEntryBlock* entryBlk, struct Entry* entry);
+PREFIX void adfFreeEntry(struct Entry* entry);
+RETCODE adfCreateFile(struct Volume* vol,
+    SECTNUM parent,
+    char* name,
+    struct bFileHeaderBlock* fhdr);
 PREFIX RETCODE adfCreateDir(struct Volume* vol, SECTNUM parent, char* name);
-SECTNUM adfCreateEntry(struct Volume *vol, struct bEntryBlock *dir, char *name, SECTNUM );
-PREFIX RETCODE adfRenameEntry(struct Volume *vol, SECTNUM, char *old,SECTNUM,char *new);
+SECTNUM adfCreateEntry(
+    struct Volume* vol, struct bEntryBlock* dir, char* name, SECTNUM);
+PREFIX RETCODE adfRenameEntry(
+    struct Volume* vol, SECTNUM, char* old, SECTNUM, char* new);
 
-
-RETCODE adfReadEntryBlock(struct Volume* vol, SECTNUM nSect, struct bEntryBlock* ent);
-RETCODE adfWriteDirBlock(struct Volume* vol, SECTNUM nSect, struct bDirBlock *dir);
-RETCODE adfWriteEntryBlock(struct Volume* vol, SECTNUM nSect, struct bEntryBlock *ent);
+RETCODE adfReadEntryBlock(
+    struct Volume* vol, SECTNUM nSect, struct bEntryBlock* ent);
+RETCODE adfWriteDirBlock(
+    struct Volume* vol, SECTNUM nSect, struct bDirBlock* dir);
+RETCODE adfWriteEntryBlock(
+    struct Volume* vol, SECTNUM nSect, struct bEntryBlock* ent);
 
 char* adfAccess2String(int32_t acc);
 uint8_t adfIntlToUpper(uint8_t c);
-int adfGetHashValue(uint8_t *name, BOOL intl);
-void myToUpper( uint8_t *ostr, uint8_t *nstr, int,BOOL intl );
-PREFIX RETCODE adfChangeDir(struct Volume* vol, char *name);
+int adfGetHashValue(uint8_t* name, BOOL intl);
+void myToUpper(uint8_t* ostr, uint8_t* nstr, int, BOOL intl);
+PREFIX RETCODE adfChangeDir(struct Volume* vol, char* name);
 PREFIX RETCODE adfParentDir(struct Volume* vol);
 PREFIX RETCODE adfSetEntryAccess(struct Volume*, SECTNUM, char*, int32_t);
 PREFIX RETCODE adfSetEntryComment(struct Volume*, SECTNUM, char*, char*);
-SECTNUM adfNameToEntryBlk(struct Volume *vol, int32_t ht[], char* name, 
-    struct bEntryBlock *entry, SECTNUM *);
+SECTNUM adfNameToEntryBlk(struct Volume* vol,
+    int32_t ht[],
+    char* name,
+    struct bEntryBlock* entry,
+    SECTNUM*);
 
 PREFIX void printEntry(struct Entry* entry);
 void adfFreeDirList(struct List* list);
 
 #endif /* ADF_DIR_H */
-

dep/adflib/src/adf_disk.h

@@ -31,21 +31,21 @@
 #include "adf_str.h"
 #include "adf_defs.h"
 
-PREFIX RETCODE adfInstallBootBlock(struct Volume *vol,uint8_t*);
+PREFIX RETCODE adfInstallBootBlock(struct Volume* vol, uint8_t*);
 
-PREFIX BOOL isSectNumValid(struct Volume *vol, SECTNUM nSect);
+PREFIX BOOL isSectNumValid(struct Volume* vol, SECTNUM nSect);
 
-PREFIX struct Volume* adfMount( struct Device *dev, int nPart, BOOL readOnly );
-PREFIX void adfUnMount(struct Volume *vol);
-PREFIX void adfVolumeInfo(struct Volume *vol);
-struct Volume* adfCreateVol( struct Device* dev, int32_t start, int32_t len, 
-    char* volName, int volType );
+PREFIX struct Volume* adfMount(struct Device* dev, int nPart, BOOL readOnly);
+PREFIX void adfUnMount(struct Volume* vol);
+PREFIX void adfVolumeInfo(struct Volume* vol);
+struct Volume* adfCreateVol(
+    struct Device* dev, int32_t start, int32_t len, char* volName, int volType);
 
 /*void adfReadBitmap(struct Volume* , int32_t nBlock, struct bRootBlock* root);
 void adfUpdateBitmap(struct Volume*);
 */
-PREFIX RETCODE adfReadBlock(struct Volume* , int32_t nSect, uint8_t* buf);
-PREFIX RETCODE adfWriteBlock(struct Volume* , int32_t nSect, uint8_t* buf);
+PREFIX RETCODE adfReadBlock(struct Volume*, int32_t nSect, uint8_t* buf);
+PREFIX RETCODE adfWriteBlock(struct Volume*, int32_t nSect, uint8_t* buf);
 
 #endif /* _ADF_DISK_H */
 

dep/adflib/src/adf_dump.h

@@ -7,7 +7,7 @@
  *  adf_dump.h
  *
  *  $Id$
- *  
+ *
  *  This file is part of ADFLib.
  *
  *  ADFLib is free software; you can redistribute it and/or modify
@@ -26,14 +26,13 @@
  *
  */
 
-PREFIX     struct Device*
-adfCreateDumpDevice(char* filename, int32_t cyl, int32_t heads, int32_t sec);
+PREFIX struct Device* adfCreateDumpDevice(
+    char* filename, int32_t cyl, int32_t heads, int32_t sec);
 PREFIX RETCODE adfCreateHdFile(struct Device* dev, char* volName, int volType);
-BOOL adfInitDumpDevice(struct Device* dev, char* name,BOOL);
-BOOL adfReadDumpSector(struct Device *dev, int32_t n, int size, uint8_t* buf);
-BOOL adfWriteDumpSector(struct Device *dev, int32_t n, int size, uint8_t* buf);
-RETCODE adfReleaseDumpDevice(struct Device *dev);
-
+BOOL adfInitDumpDevice(struct Device* dev, char* name, BOOL);
+BOOL adfReadDumpSector(struct Device* dev, int32_t n, int size, uint8_t* buf);
+BOOL adfWriteDumpSector(struct Device* dev, int32_t n, int size, uint8_t* buf);
+RETCODE adfReleaseDumpDevice(struct Device* dev);
 
 #endif /* ADF_DUMP_H */
 /*##########################################################################*/

dep/adflib/src/adf_env.h

@@ -7,7 +7,7 @@
  *  adf_env.h
  *
  *  $Id$
- *  
+ *
  *  This file is part of ADFLib.
  *
  *  ADFLib is free software; you can redistribute it and/or modify
@@ -26,13 +26,15 @@
  *
  */
 
-#include"prefix.h"
+#include "prefix.h"
 
 PREFIX void adfEnvInitDefault();
-PREFIX void adfSetEnvFct( void(*e)(char*), void(*w)(char*), void(*v)(char*),
-	void(*n)(SECTNUM,int) );
+PREFIX void adfSetEnvFct(void (*e)(char*),
+    void (*w)(char*),
+    void (*v)(char*),
+    void (*n)(SECTNUM, int));
 PREFIX void adfEnvCleanUp();
-PREFIX void adfChgEnvProp(int prop, void *new);
+PREFIX void adfChgEnvProp(int prop, void* new);
 PREFIX char* adfGetVersionNumber();
 PREFIX char* adfGetVersionDate();
 

dep/adflib/src/adf_err.h

@@ -26,39 +26,36 @@
  *
  */
 
+#define hasRC(rc, c) ((rc) & (c))
 
-#define hasRC(rc,c) ((rc)&(c))
+#define RC_OK 0
+#define RC_ERROR -1
 
-#define RC_OK				0
-#define RC_ERROR			-1
+#define RC_MALLOC 1
+#define RC_VOLFULL 2
 
-#define RC_MALLOC           1
-#define RC_VOLFULL			2
-
-
-#define RC_FOPEN            1<<10
-#define RC_NULLPTR          1<<12
+#define RC_FOPEN 1 << 10
+#define RC_NULLPTR 1 << 12
 
 /* adfRead*Block() */
 
-#define RC_BLOCKTYPE        1
-#define RC_BLOCKSTYPE       1<<1
-#define RC_BLOCKSUM         1<<2
-#define RC_HEADERKEY		1<<3
-#define RC_BLOCKREAD        1<<4
+#define RC_BLOCKTYPE 1
+#define RC_BLOCKSTYPE 1 << 1
+#define RC_BLOCKSUM 1 << 2
+#define RC_HEADERKEY 1 << 3
+#define RC_BLOCKREAD 1 << 4
 
 /* adfWrite*Block */
-#define RC_BLOCKWRITE       1<<4
-
+#define RC_BLOCKWRITE 1 << 4
 
 /* adfReadBlock() */
-#define RC_BLOCKOUTOFRANGE  1
-#define RC_BLOCKNATREAD     1<<1
+#define RC_BLOCKOUTOFRANGE 1
+#define RC_BLOCKNATREAD 1 << 1
 
 /* adfWriteBlock() */
 /* RC_BLOCKOUTOFRANGE */
-#define RC_BLOCKNATWRITE    1<<1
-#define RC_BLOCKREADONLY    1<<2
+#define RC_BLOCKNATWRITE 1 << 1
+#define RC_BLOCKREADONLY 1 << 2
 
 /* adfInitDumpDevice() */
 /* RC_FOPEN */
@@ -66,17 +63,16 @@
 
 /* adfNativeReadBlock(), adfReadDumpSector() */
 
-#define RC_BLOCKSHORTREAD   1
-#define RC_BLOCKFSEEK       1<<1
+#define RC_BLOCKSHORTREAD 1
+#define RC_BLOCKFSEEK 1 << 1
 
 /* adfNativeWriteBlock(), adfWriteDumpSector() */
 
-#define RC_BLOCKSHORTWRITE  1
+#define RC_BLOCKSHORTWRITE 1
 /* RC_BLOCKFSEEK */
 
-
 /*-- adfReadRDSKblock --*/
-#define RC_BLOCKID          1<<5
+#define RC_BLOCKID 1 << 5
 
 /*-- adfWriteRDSKblock() --*/
 /*RC_BLOCKREADONLY*/

dep/adflib/src/adf_file.h

@@ -26,35 +26,40 @@
  *
  */
 
-#include"prefix.h"
+#include "prefix.h"
 
-#include"adf_str.h"
+#include "adf_str.h"
 
-RETCODE adfGetFileBlocks(struct Volume* vol, struct bFileHeaderBlock* entry,
-    struct FileBlocks* );
-RETCODE adfFreeFileBlocks(struct Volume* vol, struct bFileHeaderBlock *entry);
-PREFIX int32_t adfFileRealSize(uint32_t size, int blockSize, int32_t *dataN, int32_t *extN);
+RETCODE adfGetFileBlocks(
+    struct Volume* vol, struct bFileHeaderBlock* entry, struct FileBlocks*);
+RETCODE adfFreeFileBlocks(struct Volume* vol, struct bFileHeaderBlock* entry);
+PREFIX int32_t adfFileRealSize(
+    uint32_t size, int blockSize, int32_t* dataN, int32_t* extN);
 
-int32_t adfPos2DataBlock(int32_t pos, int blockSize, int *posInExtBlk, int *posInDataBlk, int32_t *curDataN );
+int32_t adfPos2DataBlock(int32_t pos,
+    int blockSize,
+    int* posInExtBlk,
+    int* posInDataBlk,
+    int32_t* curDataN);
 
-RETCODE adfWriteFileHdrBlock(struct Volume *vol, SECTNUM nSect, struct bFileHeaderBlock* fhdr);
+RETCODE adfWriteFileHdrBlock(
+    struct Volume* vol, SECTNUM nSect, struct bFileHeaderBlock* fhdr);
 
-RETCODE adfReadDataBlock(struct Volume *vol, SECTNUM nSect, void *data);
-RETCODE adfWriteDataBlock(struct Volume *vol, SECTNUM nSect, void *data);
-RETCODE adfReadFileExtBlock(struct Volume *vol, SECTNUM nSect, struct bFileExtBlock* fext);
-RETCODE adfWriteFileExtBlock(struct Volume *vol, SECTNUM nSect, struct bFileExtBlock* fext);
+RETCODE adfReadDataBlock(struct Volume* vol, SECTNUM nSect, void* data);
+RETCODE adfWriteDataBlock(struct Volume* vol, SECTNUM nSect, void* data);
+RETCODE adfReadFileExtBlock(
+    struct Volume* vol, SECTNUM nSect, struct bFileExtBlock* fext);
+RETCODE adfWriteFileExtBlock(
+    struct Volume* vol, SECTNUM nSect, struct bFileExtBlock* fext);
 
-PREFIX struct File* adfOpenFile(struct Volume *vol, char* name, char *mode);
-PREFIX void adfCloseFile(struct File *file);
-PREFIX int32_t adfReadFile(struct File* file, int32_t n, uint8_t *buffer);
+PREFIX struct File* adfOpenFile(struct Volume* vol, char* name, char* mode);
+PREFIX void adfCloseFile(struct File* file);
+PREFIX int32_t adfReadFile(struct File* file, int32_t n, uint8_t* buffer);
 PREFIX BOOL adfEndOfFile(struct File* file);
-PREFIX void adfFileSeek(struct File *file, uint32_t pos);		/* BV */
+PREFIX void adfFileSeek(struct File* file, uint32_t pos); /* BV */
 RETCODE adfReadNextFileBlock(struct File* file);
-PREFIX int32_t adfWriteFile(struct File *file, int32_t n, uint8_t *buffer);
+PREFIX int32_t adfWriteFile(struct File* file, int32_t n, uint8_t* buffer);
 SECTNUM adfCreateNextFileBlock(struct File* file);
-PREFIX void adfFlushFile(struct File *file);
-
-
+PREFIX void adfFlushFile(struct File* file);
 
 #endif /* ADF_FILE_H */
-

dep/adflib/src/adf_hd.h

@@ -28,38 +28,48 @@
  *
  */
 
-#include"prefix.h"
+#include "prefix.h"
 
 #include "adf_str.h"
 #include "hd_blk.h"
 #include "adf_err.h"
 
-int adfDevType(struct Device *dev);
-PREFIX void adfDeviceInfo(struct Device *dev);
+int adfDevType(struct Device* dev);
+PREFIX void adfDeviceInfo(struct Device* dev);
 
-RETCODE adfMountHd(struct Device *dev);
+RETCODE adfMountHd(struct Device* dev);
 RETCODE adfMountFlop(struct Device* dev);
-PREFIX struct Device* adfMountDev( char* filename,BOOL);
-PREFIX void adfUnMountDev( struct Device* dev);
+PREFIX struct Device* adfMountDev(char* filename, BOOL);
+PREFIX void adfUnMountDev(struct Device* dev);
 
-RETCODE adfCreateHdHeader(struct Device* dev, int n, struct Partition** partList );
-PREFIX RETCODE adfCreateFlop(struct Device* dev, char* volName, int volType );
-PREFIX RETCODE adfCreateHd(struct Device* dev, int n, struct Partition** partList );
+RETCODE adfCreateHdHeader(
+    struct Device* dev, int n, struct Partition** partList);
+PREFIX RETCODE adfCreateFlop(struct Device* dev, char* volName, int volType);
+PREFIX RETCODE adfCreateHd(
+    struct Device* dev, int n, struct Partition** partList);
 PREFIX RETCODE adfCreateHdFile(struct Device* dev, char* volName, int volType);
 
-struct Device* adfCreateDev(char* filename, int32_t cylinders, int32_t heads, int32_t sectors);
-
-RETCODE adfReadBlockDev( struct Device* dev, int32_t nSect, int32_t size, uint8_t* buf );
-RETCODE adfWriteBlockDev(struct Device* dev, int32_t nSect, int32_t size, uint8_t* buf );
-RETCODE adfReadRDSKblock( struct Device* dev, struct bRDSKblock* blk );
-RETCODE adfWriteRDSKblock(struct Device *dev, struct bRDSKblock* rdsk);
-RETCODE adfReadPARTblock( struct Device* dev, int32_t nSect, struct bPARTblock* blk );
-RETCODE adfWritePARTblock(struct Device *dev, int32_t nSect, struct bPARTblock* part);
-RETCODE adfReadFSHDblock( struct Device* dev, int32_t nSect, struct bFSHDblock* blk);
-RETCODE adfWriteFSHDblock(struct Device *dev, int32_t nSect, struct bFSHDblock* fshd);
-RETCODE adfReadLSEGblock(struct Device* dev, int32_t nSect, struct bLSEGblock* blk);
-RETCODE adfWriteLSEGblock(struct Device *dev, int32_t nSect, struct bLSEGblock* lseg);
+struct Device* adfCreateDev(
+    char* filename, int32_t cylinders, int32_t heads, int32_t sectors);
 
+RETCODE adfReadBlockDev(
+    struct Device* dev, int32_t nSect, int32_t size, uint8_t* buf);
+RETCODE adfWriteBlockDev(
+    struct Device* dev, int32_t nSect, int32_t size, uint8_t* buf);
+RETCODE adfReadRDSKblock(struct Device* dev, struct bRDSKblock* blk);
+RETCODE adfWriteRDSKblock(struct Device* dev, struct bRDSKblock* rdsk);
+RETCODE adfReadPARTblock(
+    struct Device* dev, int32_t nSect, struct bPARTblock* blk);
+RETCODE adfWritePARTblock(
+    struct Device* dev, int32_t nSect, struct bPARTblock* part);
+RETCODE adfReadFSHDblock(
+    struct Device* dev, int32_t nSect, struct bFSHDblock* blk);
+RETCODE adfWriteFSHDblock(
+    struct Device* dev, int32_t nSect, struct bFSHDblock* fshd);
+RETCODE adfReadLSEGblock(
+    struct Device* dev, int32_t nSect, struct bLSEGblock* blk);
+RETCODE adfWriteLSEGblock(
+    struct Device* dev, int32_t nSect, struct bLSEGblock* lseg);
 
 #endif /* _ADF_HD_H */
 

dep/adflib/src/adf_link.h

@@ -7,7 +7,7 @@
  *  adf_link.h
  *
  *  $Id$
- *  
+ *
  *  This file is part of ADFLib.
  *
  *  ADFLib is free software; you can redistribute it and/or modify
@@ -26,11 +26,13 @@
  *
  */
 
-#include"prefix.h"
+#include "prefix.h"
 #include <stdint.h>
-PREFIX RETCODE adfBlockPtr2EntryName(struct Volume *vol, SECTNUM nSect, SECTNUM lPar, 
-	char **name, int32_t *size);
-
+PREFIX RETCODE adfBlockPtr2EntryName(struct Volume* vol,
+    SECTNUM nSect,
+    SECTNUM lPar,
+    char** name,
+    int32_t* size);
 
 #endif /* ADF_LINK_H */
 /*##########################################################################*/

dep/adflib/src/adf_raw.h

@@ -30,38 +30,40 @@
 
 #include "adf_str.h"
 
-#define SW_LONG  4
+#define SW_LONG 4
 #define SW_SHORT 2
-#define SW_CHAR  1
+#define SW_CHAR 1
 
 #define MAX_SWTYPE 11
 
-#define SWBL_BOOT         0
-#define SWBL_ROOT         1
-#define SWBL_DATA         2
-#define SWBL_FILE         3
-#define SWBL_ENTRY        3
-#define SWBL_DIR          3
-#define SWBL_CACHE        4
-#define SWBL_BITMAP       5
-#define SWBL_FEXT         5
-#define SWBL_LINK         6
-#define SWBL_BITMAPE      5
-#define SWBL_RDSK         7
-#define SWBL_BADB         8
-#define SWBL_PART         9
-#define SWBL_FSHD         10 
-#define SWBL_LSEG         11
+#define SWBL_BOOT 0
+#define SWBL_ROOT 1
+#define SWBL_DATA 2
+#define SWBL_FILE 3
+#define SWBL_ENTRY 3
+#define SWBL_DIR 3
+#define SWBL_CACHE 4
+#define SWBL_BITMAP 5
+#define SWBL_FEXT 5
+#define SWBL_LINK 6
+#define SWBL_BITMAPE 5
+#define SWBL_RDSK 7
+#define SWBL_BADB 8
+#define SWBL_PART 9
+#define SWBL_FSHD 10
+#define SWBL_LSEG 11
 
-RETCODE adfReadRootBlock(struct Volume*, int32_t nSect, struct bRootBlock* root);
-RETCODE adfWriteRootBlock(struct Volume* vol, int32_t nSect, struct bRootBlock* root);
+RETCODE adfReadRootBlock(
+    struct Volume*, int32_t nSect, struct bRootBlock* root);
+RETCODE adfWriteRootBlock(
+    struct Volume* vol, int32_t nSect, struct bRootBlock* root);
 RETCODE adfReadBootBlock(struct Volume*, struct bBootBlock* boot);
 RETCODE adfWriteBootBlock(struct Volume* vol, struct bBootBlock* boot);
 
-uint32_t adfBootSum(uint8_t *buf);
-uint32_t adfNormalSum( uint8_t *buf, int offset, int bufLen );
+uint32_t adfBootSum(uint8_t* buf);
+uint32_t adfNormalSum(uint8_t* buf, int offset, int bufLen);
 
-void swapEndian( uint8_t *buf, int type );
+void swapEndian(uint8_t* buf, int type);
 
 #endif /* _ADF_RAW_H */
 

dep/adflib/src/adf_salv.h

@@ -26,17 +26,16 @@
  *
  */
 
-#include"prefix.h"
+#include "prefix.h"
 
 #include "adf_str.h"
 
-RETCODE adfReadGenBlock(struct Volume *vol, SECTNUM nSect, struct GenBlock *block);
+RETCODE adfReadGenBlock(
+    struct Volume* vol, SECTNUM nSect, struct GenBlock* block);
 PREFIX RETCODE adfCheckEntry(struct Volume* vol, SECTNUM nSect, int level);
 PREFIX RETCODE adfUndelEntry(struct Volume* vol, SECTNUM parent, SECTNUM nSect);
-PREFIX struct List* adfGetDelEnt(struct Volume *vol);
+PREFIX struct List* adfGetDelEnt(struct Volume* vol);
 PREFIX void adfFreeDelList(struct List* list);
 
-
 /*##########################################################################*/
 #endif /* _ADF_SALV_H */
-

dep/adflib/src/adf_str.h

@@ -28,41 +28,43 @@
  *
  */
 
-#include<stdio.h>
+#include <stdio.h>
 
-#include"adf_defs.h"
-#include"adf_blk.h"
-#include"adf_err.h"
+#include "adf_defs.h"
+#include "adf_blk.h"
+#include "adf_err.h"
 
 /* ----- VOLUME ----- */
 
-struct Volume {
+struct Volume
+{
     struct Device* dev;
 
-    SECTNUM firstBlock;     /* first block of data area (from beginning of device) */
-    SECTNUM lastBlock;      /* last block of data area  (from beginning of device) */
-    SECTNUM rootBlock;      /* root block (from firstBlock) */
+    SECTNUM
+        firstBlock;    /* first block of data area (from beginning of device) */
+    SECTNUM lastBlock; /* last block of data area  (from beginning of device) */
+    SECTNUM rootBlock; /* root block (from firstBlock) */
 
-    char dosType;           /* FFS/OFS, DIRCACHE, INTERNATIONAL */
+    char dosType; /* FFS/OFS, DIRCACHE, INTERNATIONAL */
     BOOL bootCode;
     BOOL readOnly;
-    int datablockSize;      /* 488 or 512 */
-    int blockSize;			/* 512 */
+    int datablockSize; /* 488 or 512 */
+    int blockSize;     /* 512 */
 
-    char *volName;
+    char* volName;
 
     BOOL mounted;
 
-    int32_t bitmapSize;             /* in blocks */
-    SECTNUM *bitmapBlocks;       /* bitmap blocks pointers */
-    struct bBitmapBlock **bitmapTable;
-    BOOL *bitmapBlocksChg;
+    int32_t bitmapSize;    /* in blocks */
+    SECTNUM* bitmapBlocks; /* bitmap blocks pointers */
+    struct bBitmapBlock** bitmapTable;
+    BOOL* bitmapBlocksChg;
 
     SECTNUM curDirPtr;
 };
 
-
-struct Partition {
+struct Partition
+{
     int32_t startCyl;
     int32_t lenCyl;
     char* volName;
@@ -71,35 +73,36 @@ struct Partition {
 
 /* ----- DEVICES ----- */
 
-#define DEVTYPE_FLOPDD 		1
-#define DEVTYPE_FLOPHD 		2
-#define DEVTYPE_HARDDISK 	3
-#define DEVTYPE_HARDFILE 	4
+#define DEVTYPE_FLOPDD 1
+#define DEVTYPE_FLOPHD 2
+#define DEVTYPE_HARDDISK 3
+#define DEVTYPE_HARDFILE 4
 
-struct Device {
-    int devType;               /* see below */
+struct Device
+{
+    int devType; /* see below */
     BOOL readOnly;
-    int32_t size;                 /* in bytes */
+    int32_t size; /* in bytes */
 
-    int nVol;                  /* partitions */
-    struct Volume** volList;  
-	
-    int32_t cylinders;            /* geometry */
+    int nVol; /* partitions */
+    struct Volume** volList;
+
+    int32_t cylinders; /* geometry */
     int32_t heads;
     int32_t sectors;
 
     BOOL isNativeDev;
-    void *nativeDev;
+    void* nativeDev;
 };
 
-
 /* ----- FILE ----- */
 
-struct File {
-    struct Volume *volume;
+struct File
+{
+    struct Volume* volume;
 
     struct bFileHeaderBlock* fileHdr;
-    void *currentData;
+    void* currentData;
     struct bFileExtBlock* currentExt;
 
     int32_t nDataBlock;
@@ -109,12 +112,12 @@ struct File {
     int posInDataBlk;
     int posInExtBlk;
     BOOL eof, writeMode;
-    };
-
+};
 
 /* ----- ENTRY ---- */
 
-struct Entry{
+struct Entry
+{
     int type;
     char* name;
     SECTNUM sector;
@@ -127,72 +130,72 @@ struct Entry{
     int hour, mins, secs;
 };
 
-struct CacheEntry{
+struct CacheEntry
+{
     int32_t header, size, protect;
     short days, mins, ticks;
     signed char type;
     char nLen, cLen;
-    char name[MAXNAMELEN+1], comm[MAXCMMTLEN+1];
-/*    char *name, *comm;*/
-
+    char name[MAXNAMELEN + 1], comm[MAXCMMTLEN + 1];
+    /*    char *name, *comm;*/
 };
 
-
-
-
-struct DateTime{
-    int year,mon,day,hour,min,sec;
+struct DateTime
+{
+    int year, mon, day, hour, min, sec;
 };
 
 /* ----- ENVIRONMENT ----- */
 
-#define PR_VFCT			1
-#define PR_WFCT			2
-#define PR_EFCT			3
-#define PR_NOTFCT		4
-#define PR_USEDIRC		5
-#define PR_USE_NOTFCT 	6
-#define PR_PROGBAR 		7
-#define PR_USE_PROGBAR 	8
-#define PR_RWACCESS 	9
+#define PR_VFCT 1
+#define PR_WFCT 2
+#define PR_EFCT 3
+#define PR_NOTFCT 4
+#define PR_USEDIRC 5
+#define PR_USE_NOTFCT 6
+#define PR_PROGBAR 7
+#define PR_USE_PROGBAR 8
+#define PR_RWACCESS 9
 #define PR_USE_RWACCESS 10
 
-struct Env{
-    void (*vFct)(char*);       /* verbose callback function */
-    void (*wFct)(char*);       /* warning callback function */
-    void (*eFct)(char*);       /* error callback function */
+struct Env
+{
+    void (*vFct)(char*); /* verbose callback function */
+    void (*wFct)(char*); /* warning callback function */
+    void (*eFct)(char*); /* error callback function */
 
     void (*notifyFct)(SECTNUM, int);
     BOOL useNotify;
 
-    void (*rwhAccess)(SECTNUM,SECTNUM,BOOL);
+    void (*rwhAccess)(SECTNUM, SECTNUM, BOOL);
     BOOL useRWAccess;
 
     void (*progressBar)(int);
     BOOL useProgressBar;
 
     BOOL useDirCache;
-	
-    void *nativeFct;
+
+    void* nativeFct;
 };
 
-
-
-struct List{         /* generic linked tree */
-    void *content;
+struct List
+{ /* generic linked tree */
+    void* content;
     struct List* subdir;
     struct List* next;
 };
 
-struct GenBlock{
+struct GenBlock
+{
     SECTNUM sect;
     SECTNUM parent;
     int type;
     int secType;
-    char *name;	/* if (type == 2 and (secType==2 or secType==-3)) */
+    char* name; /* if (type == 2 and (secType==2 or secType==-3)) */
 };
 
-struct FileBlocks{
+struct FileBlocks
+{
     SECTNUM header;
     int32_t nbExtens;
     SECTNUM* extens;
@@ -200,36 +203,35 @@ struct FileBlocks{
     SECTNUM* data;
 };
 
-struct bEntryBlock {
-/*000*/	int32_t	type;		/* T_HEADER == 2 */
-/*004*/	int32_t	headerKey;	/* current block number */
-        int32_t	r1[3];
-/*014*/	uint32_t	checkSum;
-/*018*/	int32_t	hashTable[HT_SIZE];
-        int32_t	r2[2];
-/*140*/	int32_t	access;	/* bit0=del, 1=modif, 2=write, 3=read */
-/*144*/	int32_t	byteSize;
-/*148*/	char	commLen;
-/*149*/	char	comment[MAXCMMTLEN+1];
-        char	r3[91-(MAXCMMTLEN+1)];
-/*1a4*/	int32_t	days;
-/*1a8*/	int32_t	mins;
-/*1ac*/	int32_t	ticks;
-/*1b0*/	char	nameLen;
-/*1b1*/	char	name[MAXNAMELEN+1];
-        int32_t	r4;
-/*1d4*/	int32_t	realEntry;
-/*1d8*/	int32_t	nextLink;
-        int32_t	r5[5];
-/*1f0*/	int32_t	nextSameHash;
-/*1f4*/	int32_t	parent;
-/*1f8*/	int32_t	extension;
-/*1fc*/	int32_t	secType;
-	};
-
+struct bEntryBlock
+{
+    /*000*/ int32_t type;      /* T_HEADER == 2 */
+    /*004*/ int32_t headerKey; /* current block number */
+    int32_t r1[3];
+    /*014*/ uint32_t checkSum;
+    /*018*/ int32_t hashTable[HT_SIZE];
+    int32_t r2[2];
+    /*140*/ int32_t access; /* bit0=del, 1=modif, 2=write, 3=read */
+    /*144*/ int32_t byteSize;
+    /*148*/ char commLen;
+    /*149*/ char comment[MAXCMMTLEN + 1];
+    char r3[91 - (MAXCMMTLEN + 1)];
+    /*1a4*/ int32_t days;
+    /*1a8*/ int32_t mins;
+    /*1ac*/ int32_t ticks;
+    /*1b0*/ char nameLen;
+    /*1b1*/ char name[MAXNAMELEN + 1];
+    int32_t r4;
+    /*1d4*/ int32_t realEntry;
+    /*1d8*/ int32_t nextLink;
+    int32_t r5[5];
+    /*1f0*/ int32_t nextSameHash;
+    /*1f4*/ int32_t parent;
+    /*1f8*/ int32_t extension;
+    /*1fc*/ int32_t secType;
+};
 
 #define ENV_DECLARATION struct Env adfEnv
 
-
 #endif /* _ADF_STR_H */
 /*##########################################################################*/

dep/adflib/src/adf_util.h

@@ -26,25 +26,22 @@
  *
  */
 
-#include"prefix.h"
+#include "prefix.h"
 
 #include "adf_str.h"
 
-
 void swLong(uint8_t* buf, uint32_t val);
 void swShort(uint8_t* buf, uint16_t val);
 
 PREFIX struct List* newCell(struct List* list, void* content);
 PREFIX void freeList(struct List* list);
-void adfDays2Date(int32_t days, int *yy, int *mm, int *dd);
+void adfDays2Date(int32_t days, int* yy, int* mm, int* dd);
 BOOL adfIsLeap(int y);
-    void
-adfTime2AmigaTime(struct DateTime dt, int32_t *day, int32_t *min, int32_t *ticks );
-    struct DateTime
-adfGiveCurrentTime( void );
+void adfTime2AmigaTime(
+    struct DateTime dt, int32_t* day, int32_t* min, int32_t* ticks);
+struct DateTime adfGiveCurrentTime(void);
 
-void dumpBlock(uint8_t *buf);
+void dumpBlock(uint8_t* buf);
 
 /*##########################################################################*/
 #endif /* _ADF_UTIL_H */
-

dep/adflib/src/adflib.h

@@ -29,96 +29,107 @@
  */
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif /* __cplusplus */
 
-
-/* Visual C++ DLL specific, define  WIN32DLL or not in the makefile */
+    /* Visual C++ DLL specific, define  WIN32DLL or not in the makefile */
 
 #ifdef WIN32DLL
 #define PREFIX __declspec(dllimport)
 #else
-#define PREFIX 
+#define PREFIX
 #endif /* WIN32DLL */
 
 #include "adf_defs.h"
 #include "adf_str.h"
 
-/* util */
-PREFIX struct List* newCell(struct List* list, void* content);
-PREFIX void freeList(struct List* list);
+    /* util */
+    PREFIX struct List* newCell(struct List* list, void* content);
+    PREFIX void freeList(struct List* list);
 
-/* dir */
-PREFIX struct Entry* adfFindEntry(struct Volume *vol, char* name);
-PREFIX RETCODE adfToRootDir(struct Volume *vol);
-PREFIX RETCODE adfCreateDir(struct Volume* vol, SECTNUM parent, char* name);
-PREFIX RETCODE adfChangeDir(struct Volume* vol, char *name);
-PREFIX RETCODE adfParentDir(struct Volume* vol);
-PREFIX RETCODE adfRemoveEntry(struct Volume *vol, SECTNUM pSect, char *name);
-PREFIX struct List* adfGetDirEnt(struct Volume* vol, SECTNUM nSect );
-PREFIX struct List* adfGetRDirEnt(struct Volume* vol, SECTNUM nSect, BOOL recurs );
-PREFIX void printEntry(struct Entry* entry);
-PREFIX void adfFreeDirList(struct List* list);
-PREFIX void adfFreeEntry(struct Entry *);
-PREFIX RETCODE adfRenameEntry(struct Volume *vol, SECTNUM, char *old,SECTNUM,char *pNew);	/* BV */
-PREFIX RETCODE adfSetEntryAccess(struct Volume*, SECTNUM, char*, int32_t);
-PREFIX RETCODE adfSetEntryComment(struct Volume*, SECTNUM, char*, char*);
+    /* dir */
+    PREFIX struct Entry* adfFindEntry(struct Volume* vol, char* name);
+    PREFIX RETCODE adfToRootDir(struct Volume* vol);
+    PREFIX RETCODE adfCreateDir(struct Volume* vol, SECTNUM parent, char* name);
+    PREFIX RETCODE adfChangeDir(struct Volume* vol, char* name);
+    PREFIX RETCODE adfParentDir(struct Volume* vol);
+    PREFIX RETCODE adfRemoveEntry(
+        struct Volume* vol, SECTNUM pSect, char* name);
+    PREFIX struct List* adfGetDirEnt(struct Volume* vol, SECTNUM nSect);
+    PREFIX struct List* adfGetRDirEnt(
+        struct Volume* vol, SECTNUM nSect, BOOL recurs);
+    PREFIX void printEntry(struct Entry* entry);
+    PREFIX void adfFreeDirList(struct List* list);
+    PREFIX void adfFreeEntry(struct Entry*);
+    PREFIX RETCODE adfRenameEntry(
+        struct Volume* vol, SECTNUM, char* old, SECTNUM, char* pNew); /* BV */
+    PREFIX RETCODE adfSetEntryAccess(struct Volume*, SECTNUM, char*, int32_t);
+    PREFIX RETCODE adfSetEntryComment(struct Volume*, SECTNUM, char*, char*);
 
-/* file */
-PREFIX int32_t adfFileRealSize(uint32_t size, int blockSize, int32_t *dataN, int32_t *extN);
-PREFIX struct File* adfOpenFile(struct Volume *vol, char* name, char *mode);
-PREFIX void adfCloseFile(struct File *file);
-PREFIX int32_t adfReadFile(struct File* file, int32_t n, uint8_t *buffer);
-PREFIX BOOL adfEndOfFile(struct File* file);
-PREFIX int32_t adfWriteFile(struct File *file, int32_t n, uint8_t *buffer);
-PREFIX void adfFlushFile(struct File *file);
-PREFIX void adfFileSeek(struct File *file, uint32_t pos);
+    /* file */
+    PREFIX int32_t adfFileRealSize(
+        uint32_t size, int blockSize, int32_t* dataN, int32_t* extN);
+    PREFIX struct File* adfOpenFile(struct Volume* vol, char* name, char* mode);
+    PREFIX void adfCloseFile(struct File* file);
+    PREFIX int32_t adfReadFile(struct File* file, int32_t n, uint8_t* buffer);
+    PREFIX BOOL adfEndOfFile(struct File* file);
+    PREFIX int32_t adfWriteFile(struct File* file, int32_t n, uint8_t* buffer);
+    PREFIX void adfFlushFile(struct File* file);
+    PREFIX void adfFileSeek(struct File* file, uint32_t pos);
 
-/* volume */
-PREFIX RETCODE adfInstallBootBlock(struct Volume *vol,uint8_t*);
-PREFIX struct Volume* adfMount( struct Device *dev, int nPart, BOOL readOnly );
-PREFIX void adfUnMount(struct Volume *vol);
-PREFIX void adfVolumeInfo(struct Volume *vol);
+    /* volume */
+    PREFIX RETCODE adfInstallBootBlock(struct Volume* vol, uint8_t*);
+    PREFIX struct Volume* adfMount(
+        struct Device* dev, int nPart, BOOL readOnly);
+    PREFIX void adfUnMount(struct Volume* vol);
+    PREFIX void adfVolumeInfo(struct Volume* vol);
 
-/* device */
-PREFIX void adfDeviceInfo(struct Device *dev);
-PREFIX struct Device* adfMountDev( char* filename,BOOL ro);
-PREFIX void adfUnMountDev( struct Device* dev);
-PREFIX RETCODE adfCreateHd(struct Device* dev, int n, struct Partition** partList );
-PREFIX RETCODE adfCreateFlop(struct Device* dev, char* volName, int volType );
-PREFIX RETCODE adfCreateHdFile(struct Device* dev, char* volName, int volType);
+    /* device */
+    PREFIX void adfDeviceInfo(struct Device* dev);
+    PREFIX struct Device* adfMountDev(char* filename, BOOL ro);
+    PREFIX void adfUnMountDev(struct Device* dev);
+    PREFIX RETCODE adfCreateHd(
+        struct Device* dev, int n, struct Partition** partList);
+    PREFIX RETCODE adfCreateFlop(
+        struct Device* dev, char* volName, int volType);
+    PREFIX RETCODE adfCreateHdFile(
+        struct Device* dev, char* volName, int volType);
 
-/* dump device */
-PREFIX struct Device* adfCreateDumpDevice(char* filename, int32_t cyl, int32_t heads, int32_t sec);
+    /* dump device */
+    PREFIX struct Device* adfCreateDumpDevice(
+        char* filename, int32_t cyl, int32_t heads, int32_t sec);
 
-/* env */
-PREFIX void adfEnvInitDefault();
-PREFIX void adfEnvCleanUp();
-PREFIX void adfChgEnvProp(int prop, void *pNew);											/* BV */
-PREFIX char* adfGetVersionNumber();
-PREFIX char* adfGetVersionDate();
-/* obsolete */
-PREFIX void adfSetEnvFct( void(*e)(char*), void(*w)(char*), void(*v)(char*) );
+    /* env */
+    PREFIX void adfEnvInitDefault();
+    PREFIX void adfEnvCleanUp();
+    PREFIX void adfChgEnvProp(int prop, void* pNew); /* BV */
+    PREFIX char* adfGetVersionNumber();
+    PREFIX char* adfGetVersionDate();
+    /* obsolete */
+    PREFIX void adfSetEnvFct(
+        void (*e)(char*), void (*w)(char*), void (*v)(char*));
 
-/* link */
-PREFIX RETCODE adfBlockPtr2EntryName(struct Volume *, SECTNUM, SECTNUM,char **, int32_t *);
+    /* link */
+    PREFIX RETCODE adfBlockPtr2EntryName(
+        struct Volume*, SECTNUM, SECTNUM, char**, int32_t*);
 
-/* salv */
-PREFIX struct List* adfGetDelEnt(struct Volume *vol);
-PREFIX RETCODE adfUndelEntry(struct Volume* vol, SECTNUM parent, SECTNUM nSect);
-PREFIX void adfFreeDelList(struct List* list);
-PREFIX RETCODE adfCheckEntry(struct Volume* vol, SECTNUM nSect, int level);
+    /* salv */
+    PREFIX struct List* adfGetDelEnt(struct Volume* vol);
+    PREFIX RETCODE adfUndelEntry(
+        struct Volume* vol, SECTNUM parent, SECTNUM nSect);
+    PREFIX void adfFreeDelList(struct List* list);
+    PREFIX RETCODE adfCheckEntry(struct Volume* vol, SECTNUM nSect, int level);
 
-/* middle level API */
+    /* middle level API */
 
-PREFIX BOOL isSectNumValid(struct Volume *vol, SECTNUM nSect);
+    PREFIX BOOL isSectNumValid(struct Volume* vol, SECTNUM nSect);
 
-/* low level API */
-
-PREFIX RETCODE adfReadBlock(struct Volume* , int32_t nSect, uint8_t* buf);
-PREFIX RETCODE adfWriteBlock(struct Volume* , int32_t nSect, uint8_t* buf);
-PREFIX int32_t adfCountFreeBlocks(struct Volume* vol);
+    /* low level API */
 
+    PREFIX RETCODE adfReadBlock(struct Volume*, int32_t nSect, uint8_t* buf);
+    PREFIX RETCODE adfWriteBlock(struct Volume*, int32_t nSect, uint8_t* buf);
+    PREFIX int32_t adfCountFreeBlocks(struct Volume* vol);
 
 #ifdef __cplusplus
 }

dep/adflib/src/defendian.h

@@ -1,13 +1,11 @@
 #include "config.h"
 
 #ifndef LITT_ENDIAN
- #if defined(__hppa__) || \
-     defined(__m68k__) || defined(mc68000) || defined(_M_M68K) || \
-     (defined(__MIPS__) && defined(__MISPEB__)) || \
-     defined(__ppc__) || defined(__POWERPC__) || defined(_M_PPC) || \
-     defined(__sparc__)
- #else
-  #define LITT_ENDIAN 1
- #endif
+#if defined(__hppa__) || defined(__m68k__) || defined(mc68000) ||     \
+    defined(_M_M68K) || (defined(__MIPS__) && defined(__MISPEB__)) || \
+    defined(__ppc__) || defined(__POWERPC__) || defined(_M_PPC) ||    \
+    defined(__sparc__)
+#else
+#define LITT_ENDIAN 1
+#endif
 #endif
-

dep/adflib/src/hd_blk.h

@@ -25,7 +25,6 @@
  *
  */
 
-
 #ifndef _HD_BLK_H
 #define _HD_BLK_H 1
 
@@ -33,135 +32,134 @@
 
 /* ------- RDSK ---------*/
 
-struct bRDSKblock {
-/*000*/	char	id[4];		/* RDSK */
-/*004*/	int32_t 	size; 		/* 64 int32_ts */
-/*008*/	ULONG	checksum;
-/*00c*/	int32_t	hostID; 	/* 7 */
-/*010*/ 	int32_t 	blockSize; 	/* 512 bytes */
-/*014*/ 	int32_t 	flags; 		/* 0x17 */
-/*018*/ 	int32_t 	badBlockList;
-/*01c*/ 	int32_t 	partitionList;
-/*020*/ 	int32_t 	fileSysHdrList;
-/*024*/ 	int32_t 	driveInit;
-/*028*/ 	int32_t 	r1[6];		/* -1 */
-/*040*/ 	int32_t 	cylinders;
-/*044*/ 	int32_t 	sectors;
-/*048*/ 	int32_t 	heads;
-/*04c*/ 	int32_t 	interleave;
-/*050*/ 	int32_t 	parkingZone;
-/*054*/	int32_t 	r2[3]; 	 	/* 0 */
-/*060*/	int32_t 	writePreComp;
-/*064*/	int32_t 	reducedWrite;
-/*068*/	int32_t 	stepRate;
-/*06c*/	int32_t 	r3[5]; 		/* 0 */
-/*080*/	int32_t 	rdbBlockLo;
-/*084*/ 	int32_t 	rdbBlockHi;
-/*088*/ 	int32_t 	loCylinder;
-/*08c*/ 	int32_t 	hiCylinder;
-/*090*/ 	int32_t 	cylBlocks;
-/*094*/ 	int32_t 	autoParkSeconds;
-/*098*/ 	int32_t 	highRDSKBlock;
-/*09c*/ 	int32_t 	r4; 		/* 0 */
-/*0a0*/ 	char 	diskVendor[8];
-/*0a8*/ 	char 	diskProduct[16];
-/*0b8*/ 	char 	diskRevision[4];
-/*0bc*/	char 	controllerVendor[8];
-/*0c4*/ 	char 	controllerProduct[16];
-/*0d4*/	char 	controllerRevision[4];
-/*0d8*/ 	int32_t 	r5[10]; 	/* 0 */
-/*100*/
+struct bRDSKblock
+{
+    /*000*/ char id[4];   /* RDSK */
+    /*004*/ int32_t size; /* 64 int32_ts */
+    /*008*/ ULONG checksum;
+    /*00c*/ int32_t hostID;    /* 7 */
+    /*010*/ int32_t blockSize; /* 512 bytes */
+    /*014*/ int32_t flags;     /* 0x17 */
+    /*018*/ int32_t badBlockList;
+    /*01c*/ int32_t partitionList;
+    /*020*/ int32_t fileSysHdrList;
+    /*024*/ int32_t driveInit;
+    /*028*/ int32_t r1[6]; /* -1 */
+    /*040*/ int32_t cylinders;
+    /*044*/ int32_t sectors;
+    /*048*/ int32_t heads;
+    /*04c*/ int32_t interleave;
+    /*050*/ int32_t parkingZone;
+    /*054*/ int32_t r2[3]; /* 0 */
+    /*060*/ int32_t writePreComp;
+    /*064*/ int32_t reducedWrite;
+    /*068*/ int32_t stepRate;
+    /*06c*/ int32_t r3[5]; /* 0 */
+    /*080*/ int32_t rdbBlockLo;
+    /*084*/ int32_t rdbBlockHi;
+    /*088*/ int32_t loCylinder;
+    /*08c*/ int32_t hiCylinder;
+    /*090*/ int32_t cylBlocks;
+    /*094*/ int32_t autoParkSeconds;
+    /*098*/ int32_t highRDSKBlock;
+    /*09c*/ int32_t r4; /* 0 */
+    /*0a0*/ char diskVendor[8];
+    /*0a8*/ char diskProduct[16];
+    /*0b8*/ char diskRevision[4];
+    /*0bc*/ char controllerVendor[8];
+    /*0c4*/ char controllerProduct[16];
+    /*0d4*/ char controllerRevision[4];
+    /*0d8*/ int32_t r5[10]; /* 0 */
+    /*100*/
 };
 
-
-struct bBADBentry {
-/*000*/	int32_t 	badBlock;
-/*004*/	int32_t 	goodBlock;
+struct bBADBentry
+{
+    /*000*/ int32_t badBlock;
+    /*004*/ int32_t goodBlock;
 };
 
-
-struct bBADBblock {
-/*000*/	char	id[4]; 		/* BADB */
-/*004*/	int32_t 	size; 		/* 128 int32_ts */
-/*008*/	ULONG	checksum; 	
-/*00c*/	int32_t	hostID; 	/* 7 */
-/*010*/ 	int32_t 	next;
-/*014*/ 	int32_t 	r1;
-/*018*/ 	struct bBADBentry blockPairs[61];
+struct bBADBblock
+{
+    /*000*/ char id[4];   /* BADB */
+    /*004*/ int32_t size; /* 128 int32_ts */
+    /*008*/ ULONG checksum;
+    /*00c*/ int32_t hostID; /* 7 */
+    /*010*/ int32_t next;
+    /*014*/ int32_t r1;
+    /*018*/ struct bBADBentry blockPairs[61];
 };
 
+struct bPARTblock
+{
+    /*000*/ char id[4];   /* PART */
+    /*004*/ int32_t size; /* 64 int32_ts */
+    /*008*/ ULONG checksum;
+    /*00c*/ int32_t hostID; /* 7 */
+    /*010*/ int32_t next;
+    /*014*/ int32_t flags;
+    /*018*/ int32_t r1[2];
+    /*020*/ int32_t devFlags;
+    /*024*/ char nameLen;
+    /*025*/ char name[31];
+    /*044*/ int32_t r2[15];
 
-
-struct bPARTblock {
-/*000*/	char	id[4]; 		/* PART */
-/*004*/	int32_t 	size; 		/* 64 int32_ts */
-/*008*/	ULONG	checksum;
-/*00c*/	int32_t	hostID; 	/* 7 */
-/*010*/ 	int32_t 	next;
-/*014*/ 	int32_t 	flags;
-/*018*/ 	int32_t 	r1[2];
-/*020*/ 	int32_t 	devFlags;
-/*024*/ 	char 	nameLen;
-/*025*/ 	char 	name[31];
-/*044*/ 	int32_t 	r2[15];
-
-/*080*/ 	int32_t 	vectorSize; 	/* often 16 int32_ts */
-/*084*/ 	int32_t 	blockSize; 	/* 128 int32_ts */
-/*088*/ 	int32_t 	secOrg;
-/*08c*/ 	int32_t 	surfaces;
-/*090*/ 	int32_t 	sectorsPerBlock; /* == 1 */
-/*094*/ 	int32_t 	blocksPerTrack;
-/*098*/ 	int32_t 	dosReserved;
-/*09c*/ 	int32_t 	dosPreAlloc;
-/*0a0*/ 	int32_t 	interleave;
-/*0a4*/ 	int32_t 	lowCyl;
-/*0a8*/ 	int32_t 	highCyl;
-/*0ac*/	int32_t 	numBuffer;
-/*0b0*/ 	int32_t 	bufMemType;
-/*0b4*/ 	int32_t 	maxTransfer;
-/*0b8*/ 	int32_t 	mask;
-/*0bc*/ 	int32_t 	bootPri;
-/*0c0*/ 	char 	dosType[4];
-/*0c4*/ 	int32_t 	r3[15];
+    /*080*/ int32_t vectorSize; /* often 16 int32_ts */
+    /*084*/ int32_t blockSize;  /* 128 int32_ts */
+    /*088*/ int32_t secOrg;
+    /*08c*/ int32_t surfaces;
+    /*090*/ int32_t sectorsPerBlock; /* == 1 */
+    /*094*/ int32_t blocksPerTrack;
+    /*098*/ int32_t dosReserved;
+    /*09c*/ int32_t dosPreAlloc;
+    /*0a0*/ int32_t interleave;
+    /*0a4*/ int32_t lowCyl;
+    /*0a8*/ int32_t highCyl;
+    /*0ac*/ int32_t numBuffer;
+    /*0b0*/ int32_t bufMemType;
+    /*0b4*/ int32_t maxTransfer;
+    /*0b8*/ int32_t mask;
+    /*0bc*/ int32_t bootPri;
+    /*0c0*/ char dosType[4];
+    /*0c4*/ int32_t r3[15];
 };
 
-
-struct bLSEGblock {
-/*000*/	char	id[4]; 		/* LSEG */
-/*004*/	int32_t 	size; 		/* 128 int32_ts */
-/*008*/	ULONG	checksum;
-/*00c*/	int32_t	hostID; 	/* 7 */
-/*010*/ 	int32_t 	next;
-/*014*/ 	char 	loadData[123*4];
+struct bLSEGblock
+{
+    /*000*/ char id[4];   /* LSEG */
+    /*004*/ int32_t size; /* 128 int32_ts */
+    /*008*/ ULONG checksum;
+    /*00c*/ int32_t hostID; /* 7 */
+    /*010*/ int32_t next;
+    /*014*/ char loadData[123 * 4];
 };
 
+struct bFSHDblock
+{
+    /*000*/ char id[4];   /* FSHD */
+    /*004*/ int32_t size; /* 64 */
+    /*008*/ ULONG checksum;
+    /*00c*/ int32_t hostID; /* 7 */
+    /*010*/ int32_t next;
+    /*014*/ int32_t flags;
+    /*018*/ int32_t r1[2];
+    /*020*/ char dosType[4];
+    /*024*/ short majVersion;
+    /*026*/ short minVersion;
+    /*028*/ int32_t patchFlags;
 
-struct bFSHDblock {
-/*000*/	char	id[4]; 		/* FSHD */
-/*004*/	int32_t 	size; 		/* 64 */
-/*008*/	ULONG	checksum;
-/*00c*/	int32_t	hostID; 	/* 7 */
-/*010*/ 	int32_t 	next;
-/*014*/ 	int32_t 	flags;
-/*018*/ 	int32_t 	r1[2];
-/*020*/ 	char 	dosType[4];
-/*024*/ 	short 	majVersion;
-/*026*/ 	short 	minVersion;
-/*028*/ 	int32_t 	patchFlags;
-
-/*02c*/ 	int32_t 	type;
-/*030*/ 	int32_t 	task;
-/*034*/ 	int32_t 	lock;
-/*038*/ 	int32_t 	handler;
-/*03c*/ 	int32_t 	stackSize;
-/*040*/ 	int32_t 	priority;
-/*044*/ 	int32_t 	startup;
-/*048*/ 	int32_t 	segListBlock;
-/*04c*/ 	int32_t 	globalVec;
-/*050*/ 	int32_t 	r2[23];
-/*0ac*/ 	int32_t 	r3[21];
+    /*02c*/ int32_t type;
+    /*030*/ int32_t task;
+    /*034*/ int32_t lock;
+    /*038*/ int32_t handler;
+    /*03c*/ int32_t stackSize;
+    /*040*/ int32_t priority;
+    /*044*/ int32_t startup;
+    /*048*/ int32_t segListBlock;
+    /*04c*/ int32_t globalVec;
+    /*050*/ int32_t r2[23];
+    /*0ac*/ int32_t r3[21];
 };
 
-
 #endif /* _HD_BLK_H */
 /*##########################################################################*/

dep/adflib/src/prefix.h

@@ -25,12 +25,12 @@
  *  along with Foobar; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
- */ 
+ */
 
 #ifdef WIN32DLL
 #define PREFIX __declspec(dllexport)
 #else
-#define PREFIX 
+#define PREFIX
 #endif /* WIN32DLL */
 
 #endif /* _PREFIX_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",
+    },
+)