Merge from master.

.github/workflows/ccpp.yml

@@ -10,11 +10,11 @@ jobs:
   build-linux:
     runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v2
       with:
         repository: 'davidgiven/fluxengine'
         path: 'fluxengine'
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v2
       with:
         repository: 'davidgiven/fluxengine-testdata'
         path: 'fluxengine-testdata'
@@ -24,101 +24,83 @@ jobs:
     - name: make
       run: CXXFLAGS="-Wp,-D_GLIBCXX_ASSERTIONS" make -j`nproc` -C fluxengine
 
-  build-linux-debian-11:
-    runs-on: ubuntu-22.04
-    container: debian:11
-    steps:
-    - uses: actions/checkout@v4
-      with:
-        repository: 'davidgiven/fluxengine'
-        path: 'fluxengine'
-    - uses: actions/checkout@v4
-      with:
-        repository: 'davidgiven/fluxengine-testdata'
-        path: 'fluxengine-testdata'
-    - name: apt update
-      run: apt update
-    - name: apt
-      run: >
-        apt install -y python3 make xz-utils python3 python3-hamcrest
-        protobuf-compiler libprotobuf-dev libsqlite3-dev
-        libfmt-dev libprotobuf-dev wx-common pkg-config
-        libudev-dev g++ libwxgtk3.0-gtk3-dev
-    - name: make
-      run: make -C fluxengine
-      
   build-macos-current:
-    strategy:
-      matrix:
-        runs-on: [macos-13, macos-latest]
-    runs-on: ${{ matrix.runs-on }}
+    runs-on: macos-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v2
       with:
         repository: 'davidgiven/fluxengine'
         path: 'fluxengine'
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v2
       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 -C fluxengine -j2
+      run: gmake -j`nproc` -C fluxengine
+
     - name: Upload build artifacts
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v2
       with:
-        name: ${{ github.event.repository.name }}.${{ github.sha }}.fluxengine.${{ runner.arch }}.pkg
+        name: ${{ github.event.repository.name }}.${{ github.sha }}
         path: fluxengine/FluxEngine.pkg
 
   build-windows:
     runs-on: windows-latest
-
+    defaults:
+      run:
+        shell: msys2 {0}
     steps:
-    - name: setup WSL
+    - uses: msys2/setup-msys2@v2
+      with:
+        update: true
+        msystem: MINGW32
+        install: >-
+          diffutils
+          make
+          mingw-w64-i686-binutils
+          mingw-w64-i686-fmt
+          mingw-w64-i686-gcc
+          mingw-w64-i686-libusb
+          mingw-w64-i686-nsis
+          mingw-w64-i686-pkg-config
+          mingw-w64-i686-protobuf
+          mingw-w64-i686-python
+          mingw-w64-i686-sqlite3
+          mingw-w64-i686-wxWidgets
+          mingw-w64-i686-zlib
+          mingw-w64-i686-imagemagick
+          vim
+          zip
+    - name: update-protobuf
       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-40-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 qt-devel mingw32-png2ico'
-
-    - name: fix line endings
-      run: |
-        git config --global core.autocrlf false
-        git config --global core.eol lf
-        
-    - uses: actions/checkout@v4
+         pacman -U --noconfirm https://repo.msys2.org/mingw/mingw32/mingw-w64-i686-protobuf-21.9-1-any.pkg.tar.zst
+    - uses: actions/checkout@v2
       with:
         repository: 'davidgiven/fluxengine'
         path: 'fluxengine'
-
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v2
       with:
         repository: 'davidgiven/fluxengine-testdata'
         path: 'fluxengine-testdata'
-
-    - name: run
-      run: |
-        wsl sh -c 'make -C fluxengine BUILDTYPE=windows -j$(nproc)'
+    - name: build
+      run: MAGICK_TIME_LIMIT=100 make -j`nproc` -C fluxengine
 
     - name: nsis
       run: |
-        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'
+        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
 
     - name: zip
       run: |
-        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'
+        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@v4
+      uses: actions/upload-artifact@v2
       with:
-        name: ${{ github.event.repository.name }}.${{ github.sha }}.windows.zip
+        name: ${{ github.event.repository.name }}.${{ github.sha }}
         path: fluxengine/fluxengine-windows.zip

.github/workflows/release.yml

@@ -12,43 +12,50 @@ on:
 jobs:
   dev-release:
     runs-on: windows-latest
-
+    defaults:
+      run:
+        shell: msys2 {0}
     steps:
-    - 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-40-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
+    - uses: msys2/setup-msys2@v2
       with:
-        repository: 'davidgiven/fluxengine'
-        path: 'fluxengine'
+        update: true
+        msystem: MINGW32
+        install: >-
+          diffutils
+          make
+          mingw-w64-i686-binutils
+          mingw-w64-i686-fmt
+          mingw-w64-i686-gcc
+          mingw-w64-i686-libusb
+          mingw-w64-i686-nsis
+          mingw-w64-i686-pkg-config
+          mingw-w64-i686-protobuf
+          mingw-w64-i686-python
+          mingw-w64-i686-sqlite3
+          mingw-w64-i686-wxWidgets
+          mingw-w64-i686-zlib
+          mingw-w64-i686-imagemagick
+          vim
+          zip
+    - uses: actions/checkout@v3
 
-    - name: run
+    - name: update-protobuf
       run: |
-        wsl sh -c 'cd fluxengine && make BUILDTYPE=windows -j$(nproc)'
+         pacman -U --noconfirm https://repo.msys2.org/mingw/mingw32/mingw-w64-i686-protobuf-21.9-1-any.pkg.tar.zst
+
+    - name: build
+      run: |
+        MAGICK_TIME_LIMIT=100 make -j`nproc`
 
     - name: nsis
       run: |
-        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'
+        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
 
     - name: zip
       run: |
-        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'
+        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
 
     - name: date
       run: |
@@ -77,27 +84,20 @@ jobs:
       with:
         name: Development build ${{ env.RELEASE_DATE }}
         files: |
-          fluxengine/fluxengine.zip
-          fluxengine/fluxengine-installer.exe
+          fluxengine.zip
+          fluxengine-installer.exe
         tag_name: dev
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
   build-macos:
-    strategy:
-      matrix:
-        runs-on: [macos-13, macos-latest]
-    runs-on: ${{ matrix.runs-on }}
+    runs-on: macos-latest
     steps:
-    - uses: actions/checkout@v4
-
+    - uses: actions/checkout@v2
     - name: brew
-      run: brew install sqlite pkg-config libusb protobuf wxwidgets fmt make coreutils dylibbundler libjpeg qt@5
-
+      run: brew install sqlite pkg-config libusb protobuf wxwidgets fmt make coreutils dylibbundler libjpeg
     - name: make
-      run: |
-        gmake -j2
-        mv FluxEngine.pkg FluxEngine-${{ runner.arch }}.pkg
+      run: gmake
 
     - name: tag
       uses: EndBug/latest-tag@latest
@@ -113,7 +113,7 @@ jobs:
         token: ${{ github.token }}
         tag: dev
         assets: | 
-          FluxEngine-${{ runner.arch }}.pkg
+          FluxEngine.pkg
         fail-if-no-assets: false
 
     - name: release
@@ -121,7 +121,7 @@ jobs:
       with:
         name: Development build ${{ env.RELEASE_DATE }}
         files: |
-          FluxEngine-${{ runner.arch }}.pkg
+          FluxEngine.pkg
         tag_name: dev
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

Makefile

@@ -1,53 +1,9 @@
-ifeq ($(BUILDTYPE),)
-    buildtype_Darwin = osx
-    buildtype_Haiku = haiku
-    BUILDTYPE := $(buildtype_$(shell uname -s ))
-        ifeq ($(BUILDTYPE),)
-                BUILDTYPE := unix
-        endif
-endif
-export BUILDTYPE
+CC = gcc
+CXX = g++ -std=c++17
+CFLAGS = -g -O3
+LDFLAGS =
 
-ifeq ($(BUILDTYPE),windows)
-	MINGW = i686-w64-mingw32-
-	CC = $(MINGW)gcc
-	CXX = $(MINGW)g++ -std=c++17
-	CFLAGS += -g -O3
-	CXXFLAGS += \
-		-fext-numeric-literals \
-		-Wno-deprecated-enum-float-conversion \
-		-Wno-deprecated-enum-enum-conversion
-	LDFLAGS += -static
-	AR = $(MINGW)ar
-	PKG_CONFIG = $(MINGW)pkg-config -static
-	WINDRES = $(MINGW)windres
-	WX_CONFIG = /usr/i686-w64-mingw32/sys-root/mingw/bin/wx-config-3.0 --static=yes
-	EXT = .exe
-else
-	CC = gcc
-	CXX = g++ -std=c++17
-	CFLAGS = -g -O3
-	LDFLAGS =
-	AR = ar
-	PKG_CONFIG = pkg-config
-	ifeq ($(BUILDTYPE),osx)
-	else
-		LDFLAGS += -pthread -Wl,--no-as-needed
-	endif
-
-endif
-
-HOSTCC = gcc
-HOSTCXX = g++ -std=c++17
-HOSTCFLAGS = -g -Os
-HOSTLDFLAGS =
-
-QTBINS = $(shell $(PKG_CONFIG) Qt5Core --variable=host_bins)
-UIC = $(QTBINS)/uic
-RCC = $(QTBINS)/rcc
-
-REALOBJ = .obj
-OBJ = $(REALOBJ)/$(BUILDTYPE)
+OBJ = .obj
 DESTDIR ?=
 PREFIX ?= /usr/local
 BINDIR ?= $(PREFIX)/bin
@@ -69,9 +25,6 @@ ifeq ($(OS), Windows_NT)
 		-Wno-deprecated-enum-float-conversion \
 		-Wno-deprecated-enum-enum-conversion
 
-	# For static qt5.
-	#export PKG_CONFIG_PATH = $(MINGWBIN)/../qt5-static/lib/pkgconfig
-
 	# Required to get the gcc run - time libraries on the path.
 	export PATH := $(PATH):$(MINGWBIN)
 endif
@@ -79,8 +32,6 @@ endif
 # Special OSX settings.
 
 ifeq ($(shell uname),Darwin)
-	export PKG_CONFIG_PATH = /usr/local/opt/qt@5/lib/pkgconfig
-
 	LDFLAGS += \
 		-framework IOKit \
 		-framework Foundation 
@@ -93,8 +44,8 @@ all: +all README.md
 binaries: all
 tests: all
 	
-README.md: $(OBJ)/scripts/+mkdocindex/mkdocindex$(EXT)
-	@echo $(PROGRESSINFO) MKDOC $@
+README.md: $(OBJ)/scripts+mkdocindex/scripts+mkdocindex$(EXT)
+	@echo MKDOC $@
 	@csplit -s -f$(OBJ)/README. README.md '/<!-- FORMATSSTART -->/' '%<!-- FORMATSEND -->%'
 	@(cat $(OBJ)/README.00 && $< && cat $(OBJ)/README.01) > README.md
 
@@ -103,9 +54,6 @@ README.md: $(OBJ)/scripts/+mkdocindex/mkdocindex$(EXT)
 .PHONY: install install-bin
 install:: all install-bin
 
-clean::
-	$(hide) rm -rf $(REALOBJ)
-
 install-bin:
 	@echo "INSTALL"
 	$(hide) install -D -v "$(OBJ)/src+fluxengine/src+fluxengine" "$(DESTDIR)$(BINDIR)/fluxengine"
@@ -115,15 +63,3 @@ install-bin:
 	$(hide) install -D -v "$(OBJ)/tools+upgrade-flux-file/tools+upgrade-flux-file" "$(DESTDIR)$(BINDIR)/upgrade-flux-file"
 
 include build/ab.mk
-
-DOCKERFILES = \
-	debian11 \
-    debian12 \
-    fedora40 \
-    fedora41
-
-docker-%: tests/docker/Dockerfile.%
-	docker build -t $* -f $< .
-
-.PHONY: dockertests
-dockertests: $(foreach f,$(DOCKERFILES), docker-$(strip $f) .WAIT)

README.md

@@ -4,8 +4,11 @@ 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 2024-10-01, the FluxEngine client software works
-(to a point) with [Applesauce](doc/applesauce.md) hardware.
+**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.
 
 <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>
@@ -32,14 +35,12 @@ Don't believe me? Watch the demo reel!
 </div>
 
 **New!** The FluxEngine client software now works with
-[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.
+[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.
 
 Where?
 ------
@@ -135,7 +136,6 @@ choices because they can store multiple types of file system.
 | [`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 | 🦖 | 🦖 |  |
@@ -257,10 +257,6 @@ package, written by Robert Leslie et al, taken from
 https://www.mars.org/home/rob/proj/hfs. It is GPL 2.0 licensed. Please see the
 contents of the directory for the full text.
 
-As an exception, `dep/verdigris` contains a partial copy of the verdigris
-package, taken from https://github.com/woboq/verdigris. It is dual LGPL/GPLv2
-licensed. Please see the contents of the directory for the full text.
-
 __Important:__ Because of all these exceptions, if you distribute the
 FluxEngine package as a whole, you must comply with the terms of _all_ of the
 licensing terms. This means that __effectively the FluxEngine package is

arch/aeslanier/decoder.cc

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

arch/agat/agat.cc

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

arch/agat/agat.proto

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

arch/agat/decoder.cc

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

arch/agat/encoder.cc

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

arch/amiga/amiga.cc

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

arch/amiga/amiga.proto

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

arch/amiga/decoder.cc

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

arch/amiga/encoder.cc

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

arch/apple2/apple2.proto

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

arch/apple2/decoder.cc

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

arch/apple2/encoder.cc

@@ -1,14 +1,14 @@
-#include "lib/core/globals.h"
-#include "lib/core/utils.h"
+#include "lib/globals.h"
 #include "arch/apple2/apple2.h"
 #include "lib/decoders/decoders.h"
 #include "lib/encoders/encoders.h"
-#include "lib/data/sector.h"
-#include "lib/data/image.h"
+#include "lib/sector.h"
+#include "lib/readerwriter.h"
+#include "lib/image.h"
 #include "fmt/format.h"
 #include "lib/encoders/encoders.pb.h"
 #include <ctype.h>
-#include "lib/core/bytes.h"
+#include "lib/bytes.h"
 
 static int encode_data_gcr(uint8_t data)
 {

arch/arch.cc

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

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

arch/brother/encoder.cc

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

arch/build.py

@@ -2,7 +2,7 @@ from build.c import cxxlibrary
 from build.protobuf import proto, protocc
 
 proto(
-    name="proto",
+    name="arch_proto",
     srcs=[
         "./aeslanier/aeslanier.proto",
         "./agat/agat.proto",
@@ -19,86 +19,8 @@ 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 "lib/core/globals.h"
+#include "lib/globals.h"
 #include "c64.h"
 
 /*

arch/c64/c64.proto

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

arch/c64/decoder.cc

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

arch/c64/encoder.cc

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

arch/f85/decoder.cc

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

arch/fb100/decoder.cc

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

arch/ibm/decoder.cc

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

arch/ibm/encoder.cc

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

arch/ibm/ibm.proto

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

arch/macintosh/decoder.cc

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

arch/macintosh/encoder.cc

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

arch/macintosh/macintosh.proto

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

arch/micropolis/decoder.cc

@@ -1,11 +1,10 @@
-#include "lib/core/globals.h"
-#include "lib/data/fluxmap.h"
-#include "lib/data/fluxmapreader.h"
-#include "lib/data/fluxpattern.h"
+#include "lib/globals.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
 #include "lib/decoders/decoders.h"
-#include "lib/data/sector.h"
+#include "lib/sector.h"
 #include "micropolis.h"
-#include "lib/core/bytes.h"
+#include "lib/bytes.h"
 #include "fmt/format.h"
 #include "lib/decoders/decoders.pb.h"
 

arch/micropolis/encoder.cc

@@ -1,9 +1,9 @@
-#include "lib/core/globals.h"
+#include "lib/globals.h"
 #include "micropolis.h"
-#include "lib/data/sector.h"
+#include "lib/sector.h"
 #include "lib/decoders/decoders.h"
 #include "lib/encoders/encoders.h"
-#include "lib/data/image.h"
+#include "lib/image.h"
 #include "lib/encoders/encoders.pb.h"
 
 static void write_sector(std::vector<bool>& bits,

arch/micropolis/micropolis.proto

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

arch/mx/decoder.cc

@@ -1,11 +1,10 @@
-#include "lib/core/globals.h"
+#include "lib/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 "lib/crc.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
+#include "lib/sector.h"
 #include <string.h>
 
 const int SECTOR_SIZE = 256;

arch/northstar/decoder.cc

@@ -11,14 +11,13 @@
  * sure that the hardSectorId is correct.
  */
 
-#include "lib/core/globals.h"
-#include "lib/data/fluxmap.h"
-#include "lib/data/fluxmapreader.h"
-#include "lib/data/fluxpattern.h"
+#include "lib/globals.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
 #include "lib/decoders/decoders.h"
-#include "lib/data/sector.h"
+#include "lib/sector.h"
 #include "northstar.h"
-#include "lib/core/bytes.h"
+#include "lib/bytes.h"
 #include "lib/decoders/decoders.pb.h"
 #include "fmt/format.h"
 

arch/northstar/encoder.cc

@@ -1,10 +1,10 @@
-#include "lib/core/globals.h"
+#include "lib/globals.h"
 #include "northstar.h"
-#include "lib/data/sector.h"
-#include "lib/core/bytes.h"
+#include "lib/sector.h"
+#include "lib/bytes.h"
 #include "lib/decoders/decoders.h"
 #include "lib/encoders/encoders.h"
-#include "lib/data/image.h"
+#include "lib/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/config/common.proto";
+import "lib/common.proto";
 
 message NorthstarDecoderProto {}
 

arch/rolandd20/decoder.cc

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

arch/smaky6/decoder.cc

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

arch/smaky6/smaky6.proto

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

arch/tartu/decoder.cc

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

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

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

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

arch/tids990/tids990.proto

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

arch/victor9k/decoder.cc

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

arch/victor9k/encoder.cc

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

arch/victor9k/victor9k.proto

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

arch/zilogmcz/decoder.cc

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

build.lua

@@ -0,0 +1,194 @@
+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

@@ -9,17 +9,221 @@ 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="fmt_lib", package="fmt")
 package(name="sqlite3_lib", package="sqlite3")
 
 clibrary(name="protocol", hdrs={"protocol.h": "./protocol.h"})
 
+proto(name="fl2_proto", srcs=["lib/fl2.proto"])
+protocc(name="fl2_proto_lib", srcs=["+fl2_proto"])
+
+cxxlibrary(
+    name="lib",
+    srcs=[
+        "./lib/bitmap.cc",
+        "./lib/bytes.cc",
+        "./lib/config.cc",
+        "./lib/crc.cc",
+        "./lib/csvreader.cc",
+        "./lib/decoders/decoders.cc",
+        "./lib/decoders/fluxdecoder.cc",
+        "./lib/decoders/fluxmapreader.cc",
+        "./lib/decoders/fmmfm.cc",
+        "./lib/encoders/encoders.cc",
+        "./lib/fl2.cc",
+        "./lib/flags.cc",
+        "./lib/fluxmap.cc",
+        "./lib/fluxsink/a2rfluxsink.cc",
+        "./lib/fluxsink/aufluxsink.cc",
+        "./lib/fluxsink/fl2fluxsink.cc",
+        "./lib/fluxsink/fluxsink.cc",
+        "./lib/fluxsink/hardwarefluxsink.cc",
+        "./lib/fluxsink/scpfluxsink.cc",
+        "./lib/fluxsink/vcdfluxsink.cc",
+        "./lib/fluxsource/a2rfluxsource.cc",
+        "./lib/fluxsource/cwffluxsource.cc",
+        "./lib/fluxsource/erasefluxsource.cc",
+        "./lib/fluxsource/fl2fluxsource.cc",
+        "./lib/fluxsource/fluxsource.cc",
+        "./lib/fluxsource/flx.cc",
+        "./lib/fluxsource/flxfluxsource.cc",
+        "./lib/fluxsource/hardwarefluxsource.cc",
+        "./lib/fluxsource/kryoflux.cc",
+        "./lib/fluxsource/kryofluxfluxsource.cc",
+        "./lib/fluxsource/memoryfluxsource.cc",
+        "./lib/fluxsource/scpfluxsource.cc",
+        "./lib/fluxsource/testpatternfluxsource.cc",
+        "./lib/globals.cc",
+        "./lib/hexdump.cc",
+        "./lib/image.cc",
+        "./lib/imagereader/d64imagereader.cc",
+        "./lib/imagereader/d88imagereader.cc",
+        "./lib/imagereader/dimimagereader.cc",
+        "./lib/imagereader/diskcopyimagereader.cc",
+        "./lib/imagereader/fdiimagereader.cc",
+        "./lib/imagereader/imagereader.cc",
+        "./lib/imagereader/imdimagereader.cc",
+        "./lib/imagereader/imgimagereader.cc",
+        "./lib/imagereader/jv3imagereader.cc",
+        "./lib/imagereader/nfdimagereader.cc",
+        "./lib/imagereader/nsiimagereader.cc",
+        "./lib/imagereader/td0imagereader.cc",
+        "./lib/imagewriter/d64imagewriter.cc",
+        "./lib/imagewriter/d88imagewriter.cc",
+        "./lib/imagewriter/diskcopyimagewriter.cc",
+        "./lib/imagewriter/imagewriter.cc",
+        "./lib/imagewriter/imdimagewriter.cc",
+        "./lib/imagewriter/imgimagewriter.cc",
+        "./lib/imagewriter/ldbsimagewriter.cc",
+        "./lib/imagewriter/nsiimagewriter.cc",
+        "./lib/imagewriter/rawimagewriter.cc",
+        "./lib/layout.cc",
+        "./lib/ldbs.cc",
+        "./lib/logger.cc",
+        "./lib/proto.cc",
+        "./lib/readerwriter.cc",
+        "./lib/sector.cc",
+        "./lib/usb/fluxengineusb.cc",
+        "./lib/usb/greaseweazle.cc",
+        "./lib/usb/greaseweazleusb.cc",
+        "./lib/usb/serial.cc",
+        "./lib/usb/usb.cc",
+        "./lib/usb/usbfinder.cc",
+        "./lib/utils.cc",
+        "./lib/vfs/acorndfs.cc",
+        "./lib/vfs/amigaffs.cc",
+        "./lib/vfs/appledos.cc",
+        "./lib/vfs/applesingle.cc",
+        "./lib/vfs/brother120fs.cc",
+        "./lib/vfs/cbmfs.cc",
+        "./lib/vfs/cpmfs.cc",
+        "./lib/vfs/fatfs.cc",
+        "./lib/vfs/fluxsectorinterface.cc",
+        "./lib/vfs/imagesectorinterface.cc",
+        "./lib/vfs/lif.cc",
+        "./lib/vfs/machfs.cc",
+        "./lib/vfs/microdos.cc",
+        "./lib/vfs/philefs.cc",
+        "./lib/vfs/prodos.cc",
+        "./lib/vfs/roland.cc",
+        "./lib/vfs/smaky6fs.cc",
+        "./lib/vfs/vfs.cc",
+        "./lib/vfs/zdos.cc",
+        "./arch/aeslanier/decoder.cc",
+        "./arch/agat/agat.cc",
+        "./arch/agat/decoder.cc",
+        "./arch/agat/encoder.cc",
+        "./arch/amiga/amiga.cc",
+        "./arch/amiga/decoder.cc",
+        "./arch/amiga/encoder.cc",
+        "./arch/apple2/decoder.cc",
+        "./arch/apple2/encoder.cc",
+        "./arch/brother/decoder.cc",
+        "./arch/brother/encoder.cc",
+        "./arch/c64/c64.cc",
+        "./arch/c64/decoder.cc",
+        "./arch/c64/encoder.cc",
+        "./arch/f85/decoder.cc",
+        "./arch/fb100/decoder.cc",
+        "./arch/ibm/decoder.cc",
+        "./arch/ibm/encoder.cc",
+        "./arch/macintosh/decoder.cc",
+        "./arch/macintosh/encoder.cc",
+        "./arch/micropolis/decoder.cc",
+        "./arch/micropolis/encoder.cc",
+        "./arch/mx/decoder.cc",
+        "./arch/northstar/decoder.cc",
+        "./arch/northstar/encoder.cc",
+        "./arch/rolandd20/decoder.cc",
+        "./arch/smaky6/decoder.cc",
+        "./arch/tids990/decoder.cc",
+        "./arch/tids990/encoder.cc",
+        "./arch/victor9k/decoder.cc",
+        "./arch/victor9k/encoder.cc",
+        "./arch/zilogmcz/decoder.cc",
+    ],
+    hdrs={
+        "arch/ibm/ibm.h": "./arch/ibm/ibm.h",
+        "arch/apple2/data_gcr.h": "./arch/apple2/data_gcr.h",
+        "arch/apple2/apple2.h": "./arch/apple2/apple2.h",
+        "arch/smaky6/smaky6.h": "./arch/smaky6/smaky6.h",
+        "arch/tids990/tids990.h": "./arch/tids990/tids990.h",
+        "arch/zilogmcz/zilogmcz.h": "./arch/zilogmcz/zilogmcz.h",
+        "arch/amiga/amiga.h": "./arch/amiga/amiga.h",
+        "arch/f85/data_gcr.h": "./arch/f85/data_gcr.h",
+        "arch/f85/f85.h": "./arch/f85/f85.h",
+        "arch/mx/mx.h": "./arch/mx/mx.h",
+        "arch/aeslanier/aeslanier.h": "./arch/aeslanier/aeslanier.h",
+        "arch/northstar/northstar.h": "./arch/northstar/northstar.h",
+        "arch/brother/data_gcr.h": "./arch/brother/data_gcr.h",
+        "arch/brother/brother.h": "./arch/brother/brother.h",
+        "arch/brother/header_gcr.h": "./arch/brother/header_gcr.h",
+        "arch/macintosh/data_gcr.h": "./arch/macintosh/data_gcr.h",
+        "arch/macintosh/macintosh.h": "./arch/macintosh/macintosh.h",
+        "arch/agat/agat.h": "./arch/agat/agat.h",
+        "arch/fb100/fb100.h": "./arch/fb100/fb100.h",
+        "arch/victor9k/data_gcr.h": "./arch/victor9k/data_gcr.h",
+        "arch/victor9k/victor9k.h": "./arch/victor9k/victor9k.h",
+        "arch/rolandd20/rolandd20.h": "./arch/rolandd20/rolandd20.h",
+        "arch/micropolis/micropolis.h": "./arch/micropolis/micropolis.h",
+        "arch/c64/data_gcr.h": "./arch/c64/data_gcr.h",
+        "arch/c64/c64.h": "./arch/c64/c64.h",
+        "lib/a2r.h": "./lib/a2r.h",
+        "lib/bitmap.h": "./lib/bitmap.h",
+        "lib/bytes.h": "./lib/bytes.h",
+        "lib/config.h": "./lib/config.h",
+        "lib/crc.h": "./lib/crc.h",
+        "lib/csvreader.h": "./lib/csvreader.h",
+        "lib/decoders/decoders.h": "./lib/decoders/decoders.h",
+        "lib/decoders/fluxdecoder.h": "./lib/decoders/fluxdecoder.h",
+        "lib/decoders/fluxmapreader.h": "./lib/decoders/fluxmapreader.h",
+        "lib/decoders/rawbits.h": "./lib/decoders/rawbits.h",
+        "lib/encoders/encoders.h": "./lib/encoders/encoders.h",
+        "lib/scp.h": "./lib/scp.h",
+        "lib/fl2.h": "./lib/fl2.h",
+        "lib/flags.h": "./lib/flags.h",
+        "lib/flux.h": "./lib/flux.h",
+        "lib/fluxmap.h": "./lib/fluxmap.h",
+        "lib/fluxsink/fluxsink.h": "./lib/fluxsink/fluxsink.h",
+        "lib/fluxsource/fluxsource.h": "lib/fluxsource/fluxsource.h",
+        "lib/fluxsource/flx.h": "lib/fluxsource/flx.h",
+        "lib/fluxsource/kryoflux.h": "lib/fluxsource/kryoflux.h",
+        "lib/globals.h": "./lib/globals.h",
+        "lib/image.h": "./lib/image.h",
+        "lib/imagereader/imagereader.h": "./lib/imagereader/imagereader.h",
+        "lib/imagewriter/imagewriter.h": "./lib/imagewriter/imagewriter.h",
+        "lib/layout.h": "./lib/layout.h",
+        "lib/ldbs.h": "./lib/ldbs.h",
+        "lib/logger.h": "./lib/logger.h",
+        "lib/proto.h": "./lib/proto.h",
+        "lib/readerwriter.h": "./lib/readerwriter.h",
+        "lib/sector.h": "./lib/sector.h",
+        "lib/usb/greaseweazle.h": "./lib/usb/greaseweazle.h",
+        "lib/usb/usb.h": "./lib/usb/usb.h",
+        "lib/usb/usbfinder.h": "./lib/usb/usbfinder.h",
+        "lib/utils.h": "./lib/utils.h",
+        "lib/vfs/applesingle.h": "./lib/vfs/applesingle.h",
+        "lib/vfs/sectorinterface.h": "./lib/vfs/sectorinterface.h",
+        "lib/vfs/vfs.h": "./lib/vfs/vfs.h",
+    },
+    deps=[
+        "+fl2_proto_lib",
+        "+protocol",
+        "lib+config_proto_lib",
+        "dep/adflib",
+        "dep/agg",
+        "dep/fatfs",
+        "dep/hfsutils",
+        "dep/libusbp",
+        "dep/stb",
+    ],
+)
+
 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"),
@@ -64,8 +268,6 @@ else:
         ("mac", "scripts/mac800_test.textpb", "--800"),
         ("n88basic", "", ""),
         ("rx50", "", ""),
-        ("tartu", "", "--390 40track_drive"),
-        ("tartu", "", "--780"),
         ("tids990", "", ""),
         ("victor9k", "", "--612"),
         ("victor9k", "", "--1224"),
@@ -99,8 +301,6 @@ export(
     items={
         "fluxengine$(EXT)": "src+fluxengine",
         "fluxengine-gui$(EXT)": "src/gui",
-        "fluxengine-imager$(EXT)": "src/gui2+imager",
-        "fluxengine-filer$(EXT)": "src/gui2+filer",
         "brother120tool$(EXT)": "tools+brother120tool",
         "brother240tool$(EXT)": "tools+brother240tool",
         "upgrade-flux-file$(EXT)": "tools+upgrade-flux-file",

build/ab.mk

@@ -1,8 +1,4 @@
-MAKENOT4 := $(if $(findstring 3.9999, $(lastword $(sort 3.9999 $(MAKE_VERSION)))),yes,no)
-MAKE4.3 := $(if $(findstring 4.3, $(firstword $(sort 4.3 $(MAKE_VERSION)))),yes,no)
-MAKE4.1 := $(if $(findstring no_no,$(MAKENOT4)_$(MAKE4.3)),yes,no)
-
-ifeq ($(MAKENOT3),yes)
+ifeq ($(findstring 4.,$(MAKE_VERSION)),)
 $(error You need GNU Make 4.x for this (if you're on OSX, use gmake).)
 endif
 
@@ -13,67 +9,17 @@ CXX ?= g++
 AR ?= ar
 CFLAGS ?= -g -Og
 LDFLAGS ?= -g
+hide = @
 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." \
@@ -84,12 +30,13 @@ update-ab:
 .PHONY: clean
 clean::
 	@echo CLEAN
-	$(hide) rm -rf $(OBJ)
+	$(hide) rm -rf $(OBJ) bin
 
 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
+build-files = $(shell find . -name 'build.py') build/*.py config.py
+$(OBJ)/build.mk: Makefile $(build-files)
 	@echo "AB"
 	@mkdir -p $(OBJ)
-	$(hide) $(PYTHON) -X pycache_prefix=$(OBJ)/__pycache__ build/ab.py -o $@ build.py \
-		|| rm -f $@
+	$(hide) $(PYTHON) -X pycache_prefix=$(OBJ) build/ab.py -t +all -o $@ \
+		build.py || rm -f $@
+

build/ab.py

@@ -1,83 +1,136 @@
+from collections.abc import Iterable, Sequence
 from os.path import *
-from pathlib import Path
-from typing import Iterable
+from types import SimpleNamespace
 import argparse
-import builtins
-from copy import 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 re
 import sys
-import hashlib
+import types
+import pathlib
+import builtins
+import os
 
-verbose = False
-quiet = False
-cwdStack = [""]
-targets = {}
-unmaterialisedTargets = {}  # dict, not set, to get consistent ordering
-materialisingStack = []
 defaultGlobals = {}
+targets = {}
+unmaterialisedTargets = set()
+materialisingStack = []
+outputFp = None
+cwdStack = [""]
 
 sys.path += ["."]
 old_import = builtins.__import__
 
 
-class PathFinderImpl(PathFinder):
-    def find_spec(self, fullname, path, target=None):
-        # The second test here is needed for Python 3.9.
-        if not path or not path[0]:
-            path = ["."]
-        if len(path) != 1:
-            return None
+def new_import(name, *args, **kwargs):
+    if name not in sys.modules:
+        path = name.replace(".", "/") + ".py"
+        if isfile(path):
+            sys.stderr.write(f"loading {path}\n")
+            loader = importlib.machinery.SourceFileLoader(name, path)
 
-        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=[],
+            spec = importlib.util.spec_from_loader(
+                name, loader, origin="built-in"
             )
-            return spec
-        if isdir(realpath):
-            return ModuleSpec(fullname, None, origin=realpath, is_package=True)
-        return None
+            module = importlib.util.module_from_spec(spec)
+            sys.modules[name] = module
+            cwdStack.append(dirname(path))
+            spec.loader.exec_module(module)
+            cwdStack.pop()
+
+    return old_import(name, *args, **kwargs)
 
 
-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())
+builtins.__import__ = new_import
 
 
 class ABException(BaseException):
     pass
 
 
-def error(message):
-    raise ABException(message)
+class ParameterList(Sequence):
+    def __init__(self, parent=[]):
+        self.data = parent
+
+    def __getitem__(self, i):
+        return self.data[i]
+
+    def __len__(self):
+        return len(self.data)
+
+    def __str__(self):
+        return " ".join(self.data)
+
+    def __add__(self, other):
+        newdata = self.data.copy() + other
+        return ParameterList(newdata)
+
+    def __repr__(self):
+        return f"<PList: {self.data}>"
+
+
+class Invocation:
+    name = None
+    callback = None
+    types = None
+    ins = None
+    outs = None
+    binding = None
+
+    def materialise(self, replacing=False):
+        if self in unmaterialisedTargets:
+            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:
+                self.args = {}
+                for k, v in self.binding.arguments.items():
+                    if k != "kwargs":
+                        t = self.types.get(k, None)
+                        if t:
+                            v = t(v).convert(self)
+                        self.args[k] = v
+                    else:
+                        for kk, vv in v.items():
+                            t = self.types.get(kk, None)
+                            if t:
+                                vv = t(vv).convert(self)
+                            self.args[kk] = vv
+
+                # Actually call the callback.
+
+                cwdStack.append(self.cwd)
+                self.callback(**self.args)
+                cwdStack.pop()
+            except BaseException as e:
+                print(
+                    f"Error materialising {self} ({id(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:
+                unmaterialisedTargets.remove(self)
+
+            materialisingStack.pop()
+
+    def __repr__(self):
+        return "<Invocation %s>" % self.name
 
 
 def Rule(func):
@@ -86,370 +139,218 @@ def Rule(func):
     @functools.wraps(func)
     def wrapper(*, name=None, replaces=None, **kwargs):
         cwd = None
-        if "cwd" in kwargs:
-            cwd = kwargs["cwd"]
-            del kwargs["cwd"]
-
+        if name:
+            if ("+" in name) and not name.startswith("+"):
+                (cwd, _) = name.split("+", 1)
         if not cwd:
-            if replaces:
-                cwd = replaces.cwd
-            else:
-                cwd = cwdStack[-1]
+            cwd = cwdStack[-1]
 
         if name:
-            if name[0] != "+":
-                name = "+" + name
-            t = Target(cwd, join(cwd, name))
+            i = Invocation()
+            if name.startswith("./"):
+                name = join(cwd, name)
+            elif "+" not in name:
+                name = cwd + "+" + name
 
-            assert (
-                t.name not in targets
-            ), f"target {t.name} has already been defined"
-            targets[t.name] = t
+            i.name = name
+            i.localname = name.split("+")[-1]
+
+            if name in targets:
+                raise ABException(f"target {i.name} has already been defined")
+            targets[name] = i
         elif replaces:
-            t = replaces
+            i = replaces
+            name = i.name
         else:
-            raise ABException("you must supply either 'name' or 'replaces'")
+            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"]
+        i.cwd = cwd
+        i.types = func.__annotations__
+        i.callback = func
+        setattr(i, func.__name__, SimpleNamespace())
 
-        t.binding = sig.bind(name=name, self=t, **kwargs)
-        t.binding.apply_defaults()
+        i.binding = sig.bind(name=name, self=i, **kwargs)
+        i.binding.apply_defaults()
 
-        unmaterialisedTargets[t] = None
+        unmaterialisedTargets.add(i)
         if replaces:
-            t.materialise(replacing=True)
-        return t
+            i.materialise(replacing=True)
+        return i
 
     defaultGlobals[func.__name__] = wrapper
     return wrapper
 
 
-def _isiterable(xs):
-    return isinstance(xs, Iterable) and not isinstance(
-        xs, (str, bytes, bytearray)
-    )
+class Type:
+    def __init__(self, value):
+        self.value = value
 
 
-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 = {}
+class Targets(Type):
+    def convert(self, invocation):
+        value = self.value
+        if type(value) is str:
+            value = [value]
+        if type(value) is list:
+            value = targetsof(value, cwd=invocation.cwd)
+        return value
 
-    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):
+class Target(Type):
+    def convert(self, invocation):
+        value = self.value
         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)
+        return targetof(value, cwd=invocation.cwd)
 
 
-def _filetarget(value, cwd):
-    if value in targets:
-        return targets[value]
-
-    t = Target(cwd, value)
-    t.outs = [value]
-    targets[value] = t
-    return t
+class TargetsMap(Type):
+    def convert(self, invocation):
+        value = self.value
+        if type(value) is dict:
+            return {
+                k: targetof(v, cwd=invocation.cwd) for k, v in value.items()
+            }
+        raise ABException(f"wanted a dict of targets, got a {type(value)}")
 
 
-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):
+def flatten(*xs):
+    def recurse(xs):
         for x in xs:
-            if _isiterable(x):
-                yield from generate(x)
+            if isinstance(x, Iterable) and not isinstance(x, (str, bytes)):
+                yield from recurse(x)
             else:
                 yield x
 
-    return list(generate(items))
+    return list(recurse(xs))
 
 
-def targetnamesof(items):
-    assert _isiterable(items), "argument of filenamesof is not a collection"
-
-    return [t.name for t in items]
+def fileinvocation(s):
+    i = Invocation()
+    i.name = s
+    i.outs = [s]
+    targets[s] = i
+    return i
 
 
-def filenamesof(items):
-    assert _isiterable(items), "argument of filenamesof is not a collection"
+def targetof(s, cwd):
+    if isinstance(s, Invocation):
+        s.materialise()
+        return s
 
-    def generate(xs):
-        for x in xs:
-            if isinstance(x, Target):
-                yield from generate(x.outs)
-            else:
-                yield x
+    if s in targets:
+        t = targets[s]
+        t.materialise()
+        return t
 
-    return list(generate(items))
+    if s.startswith(".+"):
+        s = cwd + s[1:]
+    elif s.startswith("./"):
+        s = normpath(join(cwd, s))
+    elif s.endswith("/"):
+        return fileinvocation(s)
+    elif s.startswith("$"):
+        return fileinvocation(s)
+
+    if "+" not in s:
+        if isdir(s):
+            s = s + "+" + basename(s)
+        else:
+            return fileinvocation(s)
+
+    (path, target) = s.split("+", 2)
+    loadbuildfile(join(path, "build.py"))
+    if not s in targets:
+        raise ABException(f"build file at {path} doesn't contain +{target}")
+    i = targets[s]
+    i.materialise()
+    return i
+
+
+def targetsof(*xs, cwd):
+    return flatten([targetof(x, cwd) for x in flatten(xs)])
+
+
+def filenamesof(*xs):
+    s = []
+    for t in flatten(xs):
+        if type(t) == str:
+            t = normpath(t)
+            s += [t]
+        else:
+            s += [f for f in [normpath(f) for f in filenamesof(t.outs)]]
+    return s
+
+
+def targetnamesof(*xs):
+    s = []
+    for x in flatten(xs):
+        if type(x) == str:
+            x = normpath(x)
+            if x not in s:
+                s += [x]
+        else:
+            if x.name not in s:
+                s += [x.name]
+    return s
 
 
 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}"
+    xs = filenamesof(x)
+    if len(xs) != 1:
+        raise ABException("expected a single item")
     return xs[0]
 
 
-def emit(*args, into=None):
-    s = " ".join(args) + "\n"
-    if into is not None:
-        into += [s]
-    else:
-        outputFp.write(s)
+def stripext(path):
+    return splitext(path)[0]
 
 
-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)")]
+def emit(*args):
+    outputFp.write(" ".join(flatten(args)))
+    outputFp.write("\n")
 
+
+def templateexpand(s, invocation):
+    class Converter:
+        def __getitem__(self, key):
+            if key == "self":
+                return invocation
+            f = filenamesof(invocation.args[key])
+            if isinstance(f, Sequence):
+                f = ParameterList(f)
+            return f
+
+    return eval("f%r" % s, invocation.callback.__globals__, Converter())
+
+
+def emitter_rule(name, ins, outs, deps=[]):
     emit("")
-
-    lines = []
-    if nonobjs:
-        emit("clean::", into=lines)
-        emit("\t$(hide) rm -f", *nonobjs, into=lines)
-
-    emit(".PHONY:", name, into=lines)
+    emit(".PHONY:", name)
     if outs:
-        emit(name, ":", *fouts, into=lines)
-        if len(fouts) == 1:
-            emit(*fouts, ":", *fins, "\x01", into=lines)
-        else:
-            emit("ifeq ($(MAKE4.3),yes)", into=lines)
-            emit(*fouts, "&:", *fins, "\x01", into=lines)
-            emit("else", into=lines)
-            emit(*(fouts[1:]), ":", fouts[0], into=lines)
-            emit(fouts[0], ":", *fins, "\x01", into=lines)
-            emit("endif", into=lines)
-
-        if label:
-            emit("\t$(hide)", "$(ECHO) $(PROGRESSINFO)", label, into=lines)
-        for c in cmds:
-            emit("\t$(hide)", c, into=lines)
+        emit(name, ":", filenamesof(outs), ";")
+        emit(filenamesof(outs), "&:", filenamesof(ins), filenamesof(deps))
     else:
-        assert len(cmds) == 0, "rules with no outputs cannot have commands"
-        emit(name, ":", *fins, into=lines)
+        emit(name, "&:", filenamesof(ins), filenamesof(deps))
 
-    cmd = "".join(lines)
-    hash = hashlib.sha1(bytes(cmd, "utf-8")).hexdigest()
 
-    outputFp.write(cmd.replace("\x01", f"$(OBJ)/.hashes/{hash}"))
+def emitter_endrule(name):
+    pass
 
-    if outs:
-        emit(f"$(OBJ)/.hashes/{hash}:")
-        emit(
-            f"\t$(hide) mkdir -p $(OBJ)/.hashes && touch $(OBJ)/.hashes/{hash}"
-        )
-    emit("")
+
+def emitter_label(s):
+    emit("\t$(hide)", "$(ECHO)", s)
+
+
+def emitter_exec(cs):
+    for c in cs:
+        emit("\t$(hide)", c)
+
+
+def unmake(*ss):
+    return [
+        re.sub(r"\$\(([^)]*)\)", r"$\1", s) for s in flatten(filenamesof(ss))
+    ]
 
 
 @Rule
@@ -457,88 +358,115 @@ def simplerule(
     self,
     name,
     ins: Targets = [],
-    outs: Targets = [],
+    outs=[],
     deps: Targets = [],
     commands=[],
     label="RULE",
+    **kwargs,
 ):
     self.ins = ins
     self.outs = outs
     self.deps = deps
+    emitter_rule(self.name, ins + deps, outs)
+    emitter_label(templateexpand("{label} {name}", self))
 
     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)]
+        cs += [templateexpand(c, self)]
+    emitter_exec(cs)
+    emitter_endrule(self.name)
 
-    emit_rule(
-        name=self.name,
-        ins=ins + deps,
-        outs=outs,
-        label=self.templateexpand("{label} {name}") if label else None,
-        cmds=cs,
+
+@Rule
+def normalrule(
+    self,
+    name=None,
+    ins: Targets = [],
+    deps: Targets = [],
+    outs=[],
+    label="RULE",
+    objdir=None,
+    commands=[],
+    **kwargs,
+):
+    objdir = objdir or join("$(OBJ)", name)
+
+    self.normalrule.objdir = objdir
+    simplerule(
+        replaces=self,
+        ins=ins,
+        deps=deps,
+        outs=[join(objdir, f) for f in outs],
+        label=label,
+        commands=commands,
+        **kwargs,
     )
 
 
 @Rule
 def export(self, name=None, items: TargetsMap = {}, deps: Targets = []):
-    ins = []
-    outs = []
+    cs = []
+    self.ins = items.values()
+    self.outs = []
     for dest, src in items.items():
-        dest = self.targetof(dest)
-        outs += [dest]
-
         destf = filenameof(dest)
+        dir = dirname(destf)
+        if dir:
+            cs += ["mkdir -p " + dir]
 
-        srcs = filenamesof([src])
-        assert (
-            len(srcs) == 1
-        ), "a dependency of an exported file must have exactly one output file"
+        srcs = filenamesof(src)
+        if len(srcs) != 1:
+            raise ABException(
+                "a dependency of an export 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()
+        cs += ["cp %s %s" % (srcs[0], destf)]
+        self.outs += [destf]
 
-    simplerule(
-        replaces=self,
-        ins=outs + deps,
-        outs=["=sentinel"],
-        commands=["touch {outs[0]}"],
-        label="EXPORT",
-    )
+    emitter_rule(self.name, items.values(), self.outs, deps)
+    emitter_label(f"EXPORT {self.name}")
+
+    emitter_exec(cs)
+
+    if self.outs:
+        emit("clean::")
+        emit("\t$(hide) rm -f " + (" ".join(filenamesof(self.outs))))
+    self.outs += deps
+
+    emitter_endrule(self.name)
+
+
+def loadbuildfile(filename):
+    filename = filename.replace("/", ".").removesuffix(".py")
+    builtins.__import__(filename)
+
+
+def load(filename):
+    loadbuildfile(filename)
+    callerglobals = inspect.stack()[1][0].f_globals
+    for k, v in defaultGlobals.items():
+        callerglobals[k] = v
 
 
 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="+")
+    parser.add_argument("-t", "--targets", action="append")
     args = parser.parse_args()
-
-    global verbose
-    verbose = args.verbose
-
-    global quiet
-    quiet = args.quiet
+    if not args.targets:
+        raise ABException("no targets supplied")
 
     global outputFp
     outputFp = open(args.output, "wt")
 
-    for k in ["Rule"]:
+    for k in ("Rule", "Targets", "load", "filenamesof", "stripext"):
         defaultGlobals[k] = globals()[k]
 
     global __name__
@@ -548,9 +476,10 @@ def main():
     for f in args.files:
         loadbuildfile(f)
 
-    while unmaterialisedTargets:
-        t = next(iter(unmaterialisedTargets))
-        t.materialise()
+    for t in flatten([a.split(",") for a in args.targets]):
+        if t not in targets:
+            raise ABException("target %s is not defined" % t)
+        targets[t].materialise()
     emit("AB_LOADED = 1\n")
 
 

build/build.lua

@@ -0,0 +1,251 @@
+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

@@ -1,55 +1,30 @@
+from os.path import basename, join
 from build.ab import (
+    ABException,
     Rule,
     Targets,
     TargetsMap,
     filenameof,
-    filenamesof,
     flatten,
-    simplerule,
-    emit,
+    filenamesof,
+    normalrule,
+    stripext,
 )
-from build.utils import filenamesmatchingof, stripext, collectattrs
 from os.path import *
-
-emit(
-    """
-ifeq ($(OSX),no)
-STARTGROUP ?= -Wl,--start-group
-ENDGROUP ?= -Wl,--end-group
-endif
-"""
-)
-
-def _combine(list1, list2):
-    r = list(list1)
-    for i in list2:
-        if i not in r:
-            r.append(i)
-    return r
-
-def _indirect(deps, name):
-    r = []
-    for d in deps:
-        r = _combine(r, d.args.get(name, [d]))
-    return r
+from types import SimpleNamespace
 
 
-def cfileimpl(self, name, srcs, deps, suffix, commands, label, cflags):
-    outleaf = "=" + stripext(basename(filenameof(srcs[0]))) + suffix
+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(
+    normalrule(
         replaces=self,
         ins=srcs,
-        deps=sorted(_indirect(hdr_deps, "cheader_files")),
+        deps=deps,
         outs=[outleaf],
         label=label,
         commands=commands,
-        args={"cflags": cflags},
+        cflags=cflags,
     )
 
 
@@ -57,35 +32,33 @@ def cfileimpl(self, name, srcs, deps, suffix, commands, label, cflags):
 def cfile(
     self,
     name,
-    srcs: Targets = None,
-    deps: Targets = None,
+    srcs: Targets = [],
+    deps: Targets = [],
     cflags=[],
     suffix=".o",
     commands=["$(CC) -c -o {outs[0]} {ins[0]} $(CFLAGS) {cflags}"],
     label="CC",
 ):
-    cfileimpl(self, name, srcs, deps, suffix, commands, label, cflags)
+    cfileimpl(self, name, srcs, deps, suffix, commands, label, "cfile", cflags)
 
 
 @Rule
 def cxxfile(
     self,
     name,
-    srcs: Targets = None,
-    deps: Targets = None,
+    srcs: Targets = [],
+    deps: Targets = [],
     cflags=[],
     suffix=".o",
     commands=["$(CXX) -c -o {outs[0]} {ins[0]} $(CFLAGS) {cflags}"],
     label="CXX",
 ):
-    cfileimpl(self, name, srcs, deps, suffix, commands, label, cflags)
+    cfileimpl(
+        self, name, srcs, deps, suffix, commands, label, "cxxfile", cflags
+    )
 
 
-def findsources(name, srcs, deps, cflags, filerule, cwd):
-    for f in filenamesof(srcs):
-        if f.endswith(".h") or f.endswith(".hh"):
-            cflags = cflags + [f"-I{dirname(f)}"]
-
+def findsources(name, srcs, deps, cflags, filerule):
     objs = []
     for s in flatten(srcs):
         objs += [
@@ -93,124 +66,111 @@ def findsources(name, srcs, deps, cflags, filerule, cwd):
                 name=join(name, f.removeprefix("$(OBJ)/")),
                 srcs=[f],
                 deps=deps,
-                cflags=sorted(set(cflags)),
-                cwd=cwd,
+                cflags=cflags,
             )
-            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")
+            for f in filenamesof(s)
+            if f.endswith(".c") or f.endswith(".cc") or f.endswith(".cpp")
         ]
-        if any(f.endswith(".o") for f in filenamesof([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,
-    commands,
-    label,
-    filerule,
+    self, name, srcs, deps, hdrs, cflags, ldflags, commands, label, kind
 ):
-    hdr_deps = _combine(_indirect(deps, "cheader_deps"), [self])
-    lib_deps = _combine(_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",
+    if not srcs and not hdrs:
+        raise ABException(
+            "clibrary contains no sources and no exported headers"
         )
-        hr.materialise()
-        hf = [f"-I{hr.dir}"]
 
+    libraries = [d for d in deps if hasattr(d, "clibrary")]
+    for library in libraries:
+        if library.clibrary.cflags:
+            cflags += library.clibrary.cflags
+        if library.clibrary.ldflags:
+            ldflags += library.clibrary.ldflags
+
+    for f in filenamesof(srcs):
+        if f.endswith(".h"):
+            deps += [f]
+
+    hdrcs = []
+    hdrins = list(hdrs.values())
+    hdrouts = []
+    i = 0
+    for dest, src in hdrs.items():
+        s = filenamesof(src)
+        if len(s) != 1:
+            raise ABException(
+                "a dependency of an export must have exactly one output file"
+            )
+
+        hdrcs += ["cp {ins[" + str(i) + "]} {outs[" + str(i) + "]}"]
+        hdrouts += [dest]
+        i = i + 1
+
+    if not hasattr(self, "clibrary"):
+        self.clibrary = SimpleNamespace()
     if srcs:
-        objs = findsources(
-            self.localname,
+        hr = None
+        if hdrcs:
+            hr = normalrule(
+                name=f"{name}_hdrs",
+                ins=hdrins,
+                outs=hdrouts,
+                label="HEADERS",
+                commands=hdrcs,
+            )
+            hr.materialise()
+
+        actualsrcs = findsources(
+            name,
             srcs,
-            deps + ([hr] if hr else []),
-            cflags + hf,
-            filerule,
-            self.cwd,
+            deps + ([f"{name}_hdrs"] if hr else []),
+            cflags + ([f"-I{hr.normalrule.objdir}"] if hr else []),
+            kind,
         )
 
-        ar = simplerule(
-            name=f"{self.localname}_lib",
-            ins=objs,
-            outs=[f"={self.localname}.a"],
+        normalrule(
+            replaces=self,
+            ins=actualsrcs,
+            outs=[basename(name) + ".a"],
             label=label,
-            commands=commands,
+            commands=commands if actualsrcs else [],
         )
-        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
+        self.clibrary.ldflags = ldflags
+        self.clibrary.cflags = ["-I" + hr.normalrule.objdir] if hr else []
+    else:
+        r = normalrule(
+            replaces=self,
+            ins=hdrins,
+            outs=hdrouts,
+            label="HEADERS",
+            commands=hdrcs,
+        )
+        r.materialise()
+
+        self.clibrary.ldflags = ldflags
+        self.clibrary.cflags = ["-I" + r.normalrule.objdir]
 
 
 @Rule
 def clibrary(
     self,
     name,
-    srcs: Targets = None,
-    deps: Targets = None,
-    hdrs: TargetsMap = None,
-    caller_cflags=[],
-    caller_ldflags=[],
+    srcs: Targets = [],
+    deps: Targets = [],
+    hdrs: TargetsMap = {},
     cflags=[],
     ldflags=[],
-    commands=["rm -f {outs[0]} && $(AR) cqs {outs[0]} {ins}"],
+    commands=["$(AR) cqs {outs[0]} {ins}"],
     label="LIB",
-    cfilerule=cfile,
 ):
-    libraryimpl(
-        self,
-        name,
-        srcs,
-        deps,
-        hdrs,
-        caller_cflags,
-        caller_ldflags,
-        cflags,
-        ldflags,
-        commands,
-        label,
-        cfilerule,
+    return libraryimpl(
+        self, name, srcs, deps, hdrs, cflags, ldflags, commands, label, cfile
     )
 
 
@@ -218,66 +178,40 @@ def clibrary(
 def cxxlibrary(
     self,
     name,
-    srcs: Targets = None,
-    deps: Targets = None,
-    hdrs: TargetsMap = None,
-    caller_cflags=[],
-    caller_ldflags=[],
+    srcs: Targets = [],
+    deps: Targets = [],
+    hdrs: TargetsMap = {},
     cflags=[],
     ldflags=[],
-    commands=["rm -f {outs[0]} && $(AR) cqs {outs[0]} {ins}"],
-    label="CXXLIB",
-    cxxfilerule=cxxfile,
+    commands=["$(AR) cqs {outs[0]} {ins}"],
+    label="LIB",
 ):
-    libraryimpl(
-        self,
-        name,
-        srcs,
-        deps,
-        hdrs,
-        caller_cflags,
-        caller_ldflags,
-        cflags,
-        ldflags,
-        commands,
-        label,
-        cxxfilerule,
+    return libraryimpl(
+        self, name, srcs, deps, hdrs, cflags, ldflags, commands, label, cxxfile
     )
 
 
 def programimpl(
-    self,
-    name,
-    srcs,
-    deps,
-    cflags,
-    ldflags,
-    commands,
-    label,
-    filerule,
+    self, name, srcs, deps, cflags, ldflags, commands, label, filerule, kind
 ):
-    cfiles = findsources(self.localname, srcs, deps, cflags, filerule, self.cwd)
+    libraries = [d for d in deps if hasattr(d, "clibrary")]
+    for library in libraries:
+        if library.clibrary.cflags:
+            cflags += library.clibrary.cflags
+        if library.clibrary.ldflags:
+            ldflags += library.clibrary.ldflags
 
-    lib_deps = []
-    for d in deps:
-        lib_deps = _combine(lib_deps, d.args.get("clibrary_deps", {d}))
-    libs = filenamesmatchingof(lib_deps, "*.a")
-    ldflags = collectattrs(
-        targets=lib_deps, name="caller_ldflags", initial=ldflags
-    )
+    deps += [f for f in filenamesof(srcs) if f.endswith(".h")]
 
-    simplerule(
+    ars = [f for f in filenamesof(libraries) if f.endswith(".a")]
+    normalrule(
         replaces=self,
-        ins=cfiles + libs,
-        outs=[f"={self.localname}$(EXT)"],
-        deps=_indirect(lib_deps, "clibrary_files"),
+        ins=(findsources(name, srcs, deps, cflags, filerule) + ars + ars),
+        outs=[basename(name) + "$(EXT)"],
+        deps=deps,
         label=label,
         commands=commands,
-        args={
-            "ldflags": collectattrs(
-                targets=lib_deps, name="caller_ldflags", initial=ldflags
-            )
-        },
+        ldflags=ldflags,
     )
 
 
@@ -285,15 +219,12 @@ def programimpl(
 def cprogram(
     self,
     name,
-    srcs: Targets = None,
-    deps: Targets = None,
+    srcs: Targets = [],
+    deps: Targets = [],
     cflags=[],
     ldflags=[],
-    commands=[
-        "$(CC) -o {outs[0]} $(STARTGROUP) {ins} {ldflags} $(LDFLAGS) $(ENDGROUP)"
-    ],
+    commands=["$(CC) -o {outs[0]} {ins} {ldflags} $(LDFLAGS)"],
     label="CLINK",
-    cfilerule=cfile,
 ):
     programimpl(
         self,
@@ -304,7 +235,8 @@ def cprogram(
         ldflags,
         commands,
         label,
-        cfilerule,
+        cfile,
+        "cprogram",
     )
 
 
@@ -312,15 +244,12 @@ def cprogram(
 def cxxprogram(
     self,
     name,
-    srcs: Targets = None,
-    deps: Targets = None,
+    srcs: Targets = [],
+    deps: Targets = [],
     cflags=[],
     ldflags=[],
-    commands=[
-        "$(CXX) -o {outs[0]} $(STARTGROUP) {ins} {ldflags} $(LDFLAGS) $(ENDGROUP)"
-    ],
+    commands=["$(CXX) -o {outs[0]} {ins} {ldflags} $(LDFLAGS)"],
     label="CXXLINK",
-    cxxfilerule=cxxfile,
 ):
     programimpl(
         self,
@@ -331,5 +260,6 @@ def cxxprogram(
         ldflags,
         commands,
         label,
-        cxxfilerule,
+        cxxfile,
+        "cxxprogram",
     )

build/pkg.py

@@ -1,71 +1,38 @@
-from build.ab import Rule, emit, Target, filenamesof
+from build.ab import Rule, emit, Target
 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"))
-
-
-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
+emit(
+    """
+PKG_CONFIG ?= pkg-config
+PACKAGES := $(shell $(PKG_CONFIG) --list-all | cut -d' ' -f1)
+"""
+)
 
 
 @Rule
 def package(self, name, package=None, fallback: Target = None):
-    _package(self, name, package, fallback, TargetPkgConfig)
+    emit("ifeq ($(filter %s, $(PACKAGES)),)" % package)
+    if fallback:
+        emit(f"PACKAGE_CFLAGS_{package} :=", fallback.clibrary.cflags)
+        emit(f"PACKAGE_LDFLAGS_{package} := ", fallback.clibrary.ldflags)
+        emit(f"PACKAGE_DEP_{package} := ", fallback.name)
+    else:
+        emit(f"$(error Required package '{package}' not installed.)")
+    emit("else")
+    emit(
+        f"PACKAGE_CFLAGS_{package} := $(shell $(PKG_CONFIG) --cflags {package})"
+    )
+    emit(
+        f"PACKAGE_LDFLAGS_{package} := $(shell $(PKG_CONFIG) --libs {package})"
+    )
+    emit(f"PACKAGE_DEP_{package} := ")
+    emit("endif")
+
+    self.clibrary = SimpleNamespace()
+    self.clibrary.cflags = [f"$(PACKAGE_CFLAGS_{package})"]
+    self.clibrary.ldflags = [f"$(PACKAGE_LDFLAGS_{package})"]
+
+    self.ins = []
+    self.outs = [f"$(PACKAGE_DEP_{package})"]

build/protobuf.py

@@ -1,70 +1,33 @@
-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
+from os.path import join
+from build.ab import Rule, Targets, emit, normalrule, filenamesof, flatten
+from build.c import cxxlibrary
+import build.pkg
+from types import SimpleNamespace
 
 emit(
     """
 PROTOC ?= protoc
+ifeq ($(filter protobuf, $(PACKAGES)),)
+$(error Required package 'protobuf' not installed.)"
+endif
 """
 )
 
-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(
+    normalrule(
         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}"]
-                    )
-                )
-            ]
-        ),
+        outs=[f"{name}.descriptor"],
+        deps=deps,
+        commands=[
+            "$(PROTOC) --include_source_info --descriptor_set_out={outs[0]} {ins}"
+        ],
         label="PROTO",
-        args={
-            "protosrcs": filenamesof(srcs),
-            "protodeps": set(protodeps) | {self},
-        },
+    )
+    self.proto.srcs = filenamesof(srcs) + flatten(
+        [s.proto.srcs for s in flatten(deps)]
     )
 
 
@@ -72,102 +35,31 @@ def proto(self, name, srcs: Targets = [], deps: Targets = []):
 def protocc(self, name, srcs: Targets = [], deps: Targets = []):
     outs = []
     protos = []
+    for f in flatten([s.proto.srcs for s in flatten(srcs + deps)]):
+        if f.endswith(".proto"):
+            cc = f.replace(".proto", ".pb.cc")
+            h = f.replace(".proto", ".pb.h")
+            protos += [f]
+            srcs += [f]
+            outs += [cc, h]
 
-    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,
+    r = normalrule(
+        name=f"{name}_srcs",
+        ins=protos,
         outs=outs,
-        deps=protodeps,
-        commands=[
-            "cd {dir} && "
-            + (
-                " ".join(
-                    [
-                        "$(PROTOC)",
-                        "--proto_path=.",
-                        "--cpp_out=.",
-                        f"--descriptor_set_in={descriptorlist}",
-                    ]
-                    + protos
-                )
-            )
-        ],
+        deps=deps,
+        commands=["$(PROTOC) --cpp_out={self.normalrule.objdir} {ins}"],
         label="PROTOCC",
     )
 
-    headers = {f[1:]: join(r.dir, f[1:]) for f in outs if f.endswith(".pb.h")}
-
-    from build.c import cxxlibrary
+    r.materialise()
+    headers = {
+        f: join(r.normalrule.objdir, f) for f in outs if f.endswith(".pb.h")
+    }
 
     cxxlibrary(
         replaces=self,
-        srcs=[r],
-        deps=deps,
+        srcs=[f"{name}_srcs"],
         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,
+        cflags=[f"-I{r.normalrule.objdir}"],
     )

build/tests.lua

@@ -0,0 +1,18 @@
+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

@@ -1,63 +1,13 @@
-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
+from build.ab import Rule, normalrule, Target, filenameof, Targets
+from os.path import basename
 
 
 @Rule
 def objectify(self, name, src: Target, symbol):
-    simplerule(
+    normalrule(
         replaces=self,
         ins=["build/_objectify.py", src],
-        outs=[f"={basename(filenameof(src))}.h"],
+        outs=[basename(filenameof(src)) + ".h"],
         commands=["$(PYTHON) {ins[0]} {ins[1]} " + symbol + " > {outs}"],
         label="OBJECTIFY",
     )
@@ -69,24 +19,24 @@ def test(
     name,
     command: Target = None,
     commands=None,
-    ins: Targets = None,
-    deps: Targets = None,
+    ins: Targets = [],
+    deps: Targets = [],
     label="TEST",
 ):
     if command:
-        simplerule(
+        normalrule(
             replaces=self,
             ins=[command],
-            outs=["=sentinel"],
+            outs=["sentinel"],
             commands=["{ins[0]}", "touch {outs}"],
             deps=deps,
             label=label,
         )
     else:
-        simplerule(
+        normalrule(
             replaces=self,
             ins=ins,
-            outs=["=sentinel"],
+            outs=["sentinel"],
             commands=commands + ["touch {outs}"],
             deps=deps,
             label=label,

build/zip.py

@@ -1,37 +0,0 @@
-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

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

dep/adflib/adf_nativ.h

@@ -2,34 +2,33 @@
 #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/config.h

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

dep/adflib/src/adf_bitm.h

@@ -27,28 +27,25 @@
  *
  */
 
-#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,255 +25,264 @@
  *
  */
 
+
 #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 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 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 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 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 HT_SIZE		72
+#define BM_SIZE     25
+#define MAX_DATABLK	72
+
+#define MAXNAMELEN	30
+#define MAXCMMTLEN	79
 
-#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 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 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,28 +27,20 @@
  *
  */
 
+
 #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,6 +24,7 @@
  *
  */
 
+
 #ifndef _ADF_DEFS_H
 #define _ADF_DEFS_H 1
 
@@ -33,33 +34,38 @@
 #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,54 +26,45 @@
  *
  */
 
-#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,13 +26,14 @@
  *
  */
 
-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,15 +26,13 @@
  *
  */
 
-#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,36 +26,39 @@
  *
  */
 
-#define hasRC(rc, c) ((rc) & (c))
 
-#define RC_OK 0
-#define RC_ERROR -1
+#define hasRC(rc,c) ((rc)&(c))
 
-#define RC_MALLOC 1
-#define RC_VOLFULL 2
+#define RC_OK				0
+#define RC_ERROR			-1
 
-#define RC_FOPEN 1 << 10
-#define RC_NULLPTR 1 << 12
+#define RC_MALLOC           1
+#define RC_VOLFULL			2
+
+
+#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 */
@@ -63,16 +66,17 @@
 
 /* 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,40 +26,35 @@
  *
  */
 
-#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,48 +28,38 @@
  *
  */
 
-#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);
+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);
 
-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,13 +26,11 @@
  *
  */
 
-#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,40 +30,38 @@
 
 #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,16 +26,17 @@
  *
  */
 
-#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,43 +28,41 @@
  *
  */
 
-#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;
@@ -73,36 +71,35 @@ 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;
@@ -112,12 +109,12 @@ struct File
     int posInDataBlk;
     int posInExtBlk;
     BOOL eof, writeMode;
-};
+    };
+
 
 /* ----- ENTRY ---- */
 
-struct Entry
-{
+struct Entry{
     int type;
     char* name;
     SECTNUM sector;
@@ -130,72 +127,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;
@@ -203,35 +200,36 @@ 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,22 +26,25 @@
  *
  */
 
-#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,107 +29,96 @@
  */
 
 #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 */
+/* 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);
 
-    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,11 +1,13 @@
 #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,6 +25,7 @@
  *
  */
 
+
 #ifndef _HD_BLK_H
 #define _HD_BLK_H 1
 
@@ -32,134 +33,135 @@
 
 /* ------- 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];
 
-    /*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 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];
 };
 
-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;
 
-    /*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];
+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];
 };
 
+
 #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/include/agg2d.h

@@ -23,7 +23,7 @@
 #define AGG2D_INCLUDED
 
 // With this define uncommented you can use floating-point pixel format
-// #define AGG2D_USE_FLOAT_FORMAT
+//#define AGG2D_USE_FLOAT_FORMAT
 
 #include "agg_basics.h"
 #include "agg_trans_affine.h"
@@ -56,50 +56,37 @@ class Agg2D
 #ifdef AGG2D_USE_FLOAT_FORMAT
     typedef agg::rgba32 ColorType;
 #else
-    typedef agg::rgba8 ColorType;
+    typedef agg::rgba8  ColorType;
 #endif
     typedef agg::order_bgra ComponentOrder; // Platform dependent!
-    typedef agg::blender_rgba<ColorType, ComponentOrder> Blender;
-    typedef agg::comp_op_adaptor_rgba<ColorType, ComponentOrder> BlenderComp;
-    typedef agg::blender_rgba_pre<ColorType, ComponentOrder> BlenderPre;
-    typedef agg::comp_op_adaptor_rgba_pre<ColorType, ComponentOrder>
-        BlenderCompPre;
+    typedef agg::blender_rgba<ColorType, ComponentOrder>             Blender;
+    typedef agg::comp_op_adaptor_rgba<ColorType, ComponentOrder>     BlenderComp;
+    typedef agg::blender_rgba_pre<ColorType, ComponentOrder>         BlenderPre;
+    typedef agg::comp_op_adaptor_rgba_pre<ColorType, ComponentOrder> BlenderCompPre;
 
-    typedef agg::pixfmt_alpha_blend_rgba<Blender, agg::rendering_buffer>
-        PixFormat;
-    typedef agg::pixfmt_custom_blend_rgba<BlenderComp, agg::rendering_buffer>
-        PixFormatComp;
-    typedef agg::pixfmt_alpha_blend_rgba<BlenderPre, agg::rendering_buffer>
-        PixFormatPre;
-    typedef agg::pixfmt_custom_blend_rgba<BlenderCompPre, agg::rendering_buffer>
-        PixFormatCompPre;
+    typedef agg::pixfmt_alpha_blend_rgba<Blender, agg::rendering_buffer>         PixFormat;
+    typedef agg::pixfmt_custom_blend_rgba<BlenderComp, agg::rendering_buffer>    PixFormatComp;
+    typedef agg::pixfmt_alpha_blend_rgba<BlenderPre, agg::rendering_buffer>      PixFormatPre;
+    typedef agg::pixfmt_custom_blend_rgba<BlenderCompPre, agg::rendering_buffer> PixFormatCompPre;
 
-    typedef agg::renderer_base<PixFormat> RendererBase;
-    typedef agg::renderer_base<PixFormatComp> RendererBaseComp;
-    typedef agg::renderer_base<PixFormatPre> RendererBasePre;
+    typedef agg::renderer_base<PixFormat>        RendererBase;
+    typedef agg::renderer_base<PixFormatComp>    RendererBaseComp;
+    typedef agg::renderer_base<PixFormatPre>     RendererBasePre;
     typedef agg::renderer_base<PixFormatCompPre> RendererBaseCompPre;
 
-    typedef agg::renderer_scanline_aa_solid<RendererBase> RendererSolid;
+    typedef agg::renderer_scanline_aa_solid<RendererBase>     RendererSolid;
     typedef agg::renderer_scanline_aa_solid<RendererBaseComp> RendererSolidComp;
 
     typedef agg::span_allocator<ColorType> SpanAllocator;
     typedef agg::pod_auto_array<ColorType, 256> GradientArray;
 
-    typedef agg::span_gradient<ColorType,
-        agg::span_interpolator_linear<>,
-        agg::gradient_x,
-        GradientArray>
-        LinearGradientSpan;
-    typedef agg::span_gradient<ColorType,
-        agg::span_interpolator_linear<>,
-        agg::gradient_circle,
-        GradientArray>
-        RadialGradientSpan;
+    typedef agg::span_gradient<ColorType, agg::span_interpolator_linear<>, agg::gradient_x,      GradientArray> LinearGradientSpan;
+    typedef agg::span_gradient<ColorType, agg::span_interpolator_linear<>, agg::gradient_circle, GradientArray> RadialGradientSpan;
 
-    typedef agg::conv_curve<agg::path_storage> ConvCurve;
-    typedef agg::conv_stroke<ConvCurve> ConvStroke;
-    typedef agg::conv_transform<ConvCurve> PathTransform;
-    typedef agg::conv_transform<ConvStroke> StrokeTransform;
+    typedef agg::conv_curve<agg::path_storage>    ConvCurve;
+    typedef agg::conv_stroke<ConvCurve>           ConvStroke;
+    typedef agg::conv_transform<ConvCurve>        PathTransform;
+    typedef agg::conv_transform<ConvStroke>       StrokeTransform;
 
     enum Gradient
     {
@@ -111,12 +98,12 @@ class Agg2D
 public:
     friend class Agg2DRenderer;
 
-    // Use srgba8 as the "user" color type, even though the underlying color
-    // type might be something else, such as rgba32. This allows code based on
+    // Use srgba8 as the "user" color type, even though the underlying color type 
+    // might be something else, such as rgba32. This allows code based on 
     // 8-bit sRGB values to carry on working as before.
-    typedef agg::srgba8 Color;
-    typedef agg::rect_i Rect;
-    typedef agg::rect_d RectD;
+    typedef agg::srgba8       Color;
+    typedef agg::rect_i       Rect;
+    typedef agg::rect_d       RectD;
     typedef agg::trans_affine Affine;
 
     enum LineJoin
@@ -128,9 +115,9 @@ public:
 
     enum LineCap
     {
-        CapButt = agg::butt_cap,
+        CapButt   = agg::butt_cap,
         CapSquare = agg::square_cap,
-        CapRound = agg::round_cap
+        CapRound  = agg::round_cap
     };
 
     enum TextAlignment
@@ -140,6 +127,7 @@ public:
         AlignCenter,
     };
 
+
     enum DrawPathFlag
     {
         FillOnly,
@@ -167,28 +155,20 @@ public:
         double affineMatrix[6];
     };
 
+
     struct Image
     {
         agg::rendering_buffer renBuf;
 
         Image() {}
-        Image(unsigned char* buf, unsigned width, unsigned height, int stride):
-            renBuf(buf, width, height, stride)
-        {
-        }
-        void attach(
-            unsigned char* buf, unsigned width, unsigned height, int stride)
+        Image(unsigned char* buf, unsigned width, unsigned height, int stride) :
+            renBuf(buf, width, height, stride) {}
+        void attach(unsigned char* buf, unsigned width, unsigned height, int stride)
         {
             renBuf.attach(buf, width, height, stride);
         }
-        int width() const
-        {
-            return renBuf.width();
-        }
-        int height() const
-        {
-            return renBuf.height();
-        }
+        int width()  const { return renBuf.width(); }
+        int height() const { return renBuf.height(); }
         void premultiply();
         void demultiply();
     };
@@ -222,37 +202,36 @@ public:
 
     enum BlendMode
     {
-        BlendAlpha = agg::end_of_comp_op_e,
-        BlendClear = agg::comp_op_clear,
-        BlendSrc = agg::comp_op_src,
-        BlendDst = agg::comp_op_dst,
-        BlendSrcOver = agg::comp_op_src_over,
-        BlendDstOver = agg::comp_op_dst_over,
-        BlendSrcIn = agg::comp_op_src_in,
-        BlendDstIn = agg::comp_op_dst_in,
-        BlendSrcOut = agg::comp_op_src_out,
-        BlendDstOut = agg::comp_op_dst_out,
-        BlendSrcAtop = agg::comp_op_src_atop,
-        BlendDstAtop = agg::comp_op_dst_atop,
-        BlendXor = agg::comp_op_xor,
-        BlendAdd = agg::comp_op_plus,
-        BlendMultiply = agg::comp_op_multiply,
-        BlendScreen = agg::comp_op_screen,
-        BlendOverlay = agg::comp_op_overlay,
-        BlendDarken = agg::comp_op_darken,
-        BlendLighten = agg::comp_op_lighten,
+        BlendAlpha      = agg::end_of_comp_op_e,
+        BlendClear      = agg::comp_op_clear,
+        BlendSrc        = agg::comp_op_src,
+        BlendDst        = agg::comp_op_dst,
+        BlendSrcOver    = agg::comp_op_src_over,
+        BlendDstOver    = agg::comp_op_dst_over,
+        BlendSrcIn      = agg::comp_op_src_in,
+        BlendDstIn      = agg::comp_op_dst_in,
+        BlendSrcOut     = agg::comp_op_src_out,
+        BlendDstOut     = agg::comp_op_dst_out,
+        BlendSrcAtop    = agg::comp_op_src_atop,
+        BlendDstAtop    = agg::comp_op_dst_atop,
+        BlendXor        = agg::comp_op_xor,
+        BlendAdd        = agg::comp_op_plus,
+        BlendMultiply   = agg::comp_op_multiply,
+        BlendScreen     = agg::comp_op_screen,
+        BlendOverlay    = agg::comp_op_overlay,
+        BlendDarken     = agg::comp_op_darken,
+        BlendLighten    = agg::comp_op_lighten,
         BlendColorDodge = agg::comp_op_color_dodge,
-        BlendColorBurn = agg::comp_op_color_burn,
-        BlendHardLight = agg::comp_op_hard_light,
-        BlendSoftLight = agg::comp_op_soft_light,
+        BlendColorBurn  = agg::comp_op_color_burn,
+        BlendHardLight  = agg::comp_op_hard_light,
+        BlendSoftLight  = agg::comp_op_soft_light,
         BlendDifference = agg::comp_op_difference,
-        BlendExclusion = agg::comp_op_exclusion,
+        BlendExclusion  = agg::comp_op_exclusion,
     };
 
     enum Direction
     {
-        CW,
-        CCW
+        CW, CCW
     };
 
     ~Agg2D();
@@ -260,27 +239,26 @@ public:
 
     // Setup
     //-----------------------
-    void attach(
-        unsigned char* buf, unsigned width, unsigned height, int stride);
-    void attach(Image& img);
+    void  attach(unsigned char* buf, unsigned width, unsigned height, int stride);
+    void  attach(Image& img);
 
-    void clipBox(double x1, double y1, double x2, double y2);
+    void  clipBox(double x1, double y1, double x2, double y2);
     RectD clipBox() const;
 
-    void clearAll(Color c);
-    void clearAll(unsigned r, unsigned g, unsigned b, unsigned a = 255);
+    void  clearAll(Color c);
+    void  clearAll(unsigned r, unsigned g, unsigned b, unsigned a = 255);
 
-    void clearClipBox(Color c);
-    void clearClipBox(unsigned r, unsigned g, unsigned b, unsigned a = 255);
+    void  clearClipBox(Color c);
+    void  clearClipBox(unsigned r, unsigned g, unsigned b, unsigned a = 255);
 
     // Conversions
     //-----------------------
-    void worldToScreen(double& x, double& y) const;
-    void screenToWorld(double& x, double& y) const;
+    void   worldToScreen(double& x, double& y) const;
+    void   screenToWorld(double& x, double& y) const;
     double worldToScreen(double scalar) const;
     double screenToWorld(double scalar) const;
-    void alignPoint(double& x, double& y) const;
-    bool inBox(double worldX, double worldY) const;
+    void   alignPoint(double& x, double& y) const;
+    bool   inBox(double worldX, double worldY) const;
 
     // General Attributes
     //-----------------------
@@ -311,30 +289,14 @@ public:
     Color fillColor() const;
     Color lineColor() const;
 
-    void fillLinearGradient(double x1,
-        double y1,
-        double x2,
-        double y2,
-        Color c1,
-        Color c2,
-        double profile = 1.0);
-    void lineLinearGradient(double x1,
-        double y1,
-        double x2,
-        double y2,
-        Color c1,
-        Color c2,
-        double profile = 1.0);
+    void fillLinearGradient(double x1, double y1, double x2, double y2, Color c1, Color c2, double profile=1.0);
+    void lineLinearGradient(double x1, double y1, double x2, double y2, Color c1, Color c2, double profile=1.0);
 
-    void fillRadialGradient(
-        double x, double y, double r, Color c1, Color c2, double profile = 1.0);
-    void lineRadialGradient(
-        double x, double y, double r, Color c1, Color c2, double profile = 1.0);
+    void fillRadialGradient(double x, double y, double r, Color c1, Color c2, double profile=1.0);
+    void lineRadialGradient(double x, double y, double r, Color c1, Color c2, double profile=1.0);
 
-    void fillRadialGradient(
-        double x, double y, double r, Color c1, Color c2, Color c3);
-    void lineRadialGradient(
-        double x, double y, double r, Color c1, Color c2, Color c3);
+    void fillRadialGradient(double x, double y, double r, Color c1, Color c2, Color c3);
+    void lineRadialGradient(double x, double y, double r, Color c1, Color c2, Color c3);
 
     void fillRadialGradient(double x, double y, double r);
     void lineRadialGradient(double x, double y, double r);
@@ -351,12 +313,9 @@ public:
     void fillEvenOdd(bool evenOddFlag);
     bool fillEvenOdd() const;
 
-    void textAlignment(TextAlignment alignment);
-    void textSize(double sizeX, double sizeY);
-    inline void textSize(double size)
-    {
-        textSize(size, size);
-    }
+	void textAlignment(TextAlignment alignment);
+	void textSize(double sizeX, double sizeY);
+	inline void textSize(double size) { textSize(size, size); }
 
     // Transformations
     //-----------------------
@@ -369,54 +328,26 @@ public:
     void scale(double sx, double sy);
     void skew(double sx, double sy);
     void translate(double x, double y);
-    void parallelogram(
-        double x1, double y1, double x2, double y2, const double* para);
-    void viewport(double worldX1,
-        double worldY1,
-        double worldX2,
-        double worldY2,
-        double screenX1,
-        double screenY1,
-        double screenX2,
-        double screenY2,
-        ViewportOption opt = XMidYMid);
+    void parallelogram(double x1, double y1, double x2, double y2, const double* para);
+    void viewport(double worldX1,  double worldY1,  double worldX2,  double worldY2,
+                  double screenX1, double screenY1, double screenX2, double screenY2,
+                  ViewportOption opt=XMidYMid);
 
     // Basic Shapes
     //-----------------------
     void line(double x1, double y1, double x2, double y2);
-    void triangle(
-        double x1, double y1, double x2, double y2, double x3, double y3);
+    void triangle(double x1, double y1, double x2, double y2, double x3, double y3);
     void rectangle(double x1, double y1, double x2, double y2);
     void roundedRect(double x1, double y1, double x2, double y2, double r);
-    void roundedRect(
-        double x1, double y1, double x2, double y2, double rx, double ry);
-    void roundedRect(double x1,
-        double y1,
-        double x2,
-        double y2,
-        double rxBottom,
-        double ryBottom,
-        double rxTop,
-        double ryTop);
+    void roundedRect(double x1, double y1, double x2, double y2, double rx, double ry);
+    void roundedRect(double x1, double y1, double x2, double y2,
+                     double rxBottom, double ryBottom,
+                     double rxTop,    double ryTop);
     void ellipse(double cx, double cy, double rx, double ry);
-    void arc(
-        double cx, double cy, double rx, double ry, double start, double sweep);
-    void star(double cx,
-        double cy,
-        double r1,
-        double r2,
-        double startAngle,
-        int numRays);
-    void curve(
-        double x1, double y1, double x2, double y2, double x3, double y3);
-    void curve(double x1,
-        double y1,
-        double x2,
-        double y2,
-        double x3,
-        double y3,
-        double x4,
-        double y4);
+    void arc(double cx, double cy, double rx, double ry, double start, double sweep);
+    void star(double cx, double cy, double r1, double r2, double startAngle, int numRays);
+    void curve(double x1, double y1, double x2, double y2, double x3, double y3);
+    void curve(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4);
     void polygon(double* xy, int numPoints);
     void polyline(double* xy, int numPoints);
 
@@ -436,53 +367,47 @@ public:
     void verLineTo(double y);
     void verLineRel(double dy);
 
-    void arcTo(double rx,
-        double ry,
-        double angle,
-        bool largeArcFlag,
-        bool sweepFlag,
-        double x,
-        double y);
+    void arcTo(double rx, double ry,
+               double angle,
+               bool largeArcFlag,
+               bool sweepFlag,
+               double x, double y);
 
-    void arcRel(double rx,
-        double ry,
-        double angle,
-        bool largeArcFlag,
-        bool sweepFlag,
-        double dx,
-        double dy);
+    void arcRel(double rx, double ry,
+                double angle,
+                bool largeArcFlag,
+                bool sweepFlag,
+                double dx, double dy);
 
-    void quadricCurveTo(double xCtrl, double yCtrl, double xTo, double yTo);
-    void quadricCurveRel(
-        double dxCtrl, double dyCtrl, double dxTo, double dyTo);
+    void quadricCurveTo(double xCtrl, double yCtrl,
+                         double xTo,   double yTo);
+    void quadricCurveRel(double dxCtrl, double dyCtrl,
+                         double dxTo,   double dyTo);
     void quadricCurveTo(double xTo, double yTo);
     void quadricCurveRel(double dxTo, double dyTo);
 
-    void cubicCurveTo(double xCtrl1,
-        double yCtrl1,
-        double xCtrl2,
-        double yCtrl2,
-        double xTo,
-        double yTo);
+    void cubicCurveTo(double xCtrl1, double yCtrl1,
+                      double xCtrl2, double yCtrl2,
+                      double xTo,    double yTo);
 
-    void cubicCurveRel(double dxCtrl1,
-        double dyCtrl1,
-        double dxCtrl2,
-        double dyCtrl2,
-        double dxTo,
-        double dyTo);
+    void cubicCurveRel(double dxCtrl1, double dyCtrl1,
+                       double dxCtrl2, double dyCtrl2,
+                       double dxTo,    double dyTo);
 
-    void cubicCurveTo(double xCtrl2, double yCtrl2, double xTo, double yTo);
+    void cubicCurveTo(double xCtrl2, double yCtrl2,
+                      double xTo,    double yTo);
 
-    void cubicCurveRel(double xCtrl2, double yCtrl2, double xTo, double yTo);
+    void cubicCurveRel(double xCtrl2, double yCtrl2,
+                       double xTo,    double yTo);
 
     void addEllipse(double cx, double cy, double rx, double ry, Direction dir);
-    void text(double x, double y, const std::string& text);
+	void text(double x, double y, const std::string& text);
     void closePolygon();
 
     void drawPath(DrawPathFlag flag = FillAndStroke);
     void drawPathNoTransform(DrawPathFlag flag = FillAndStroke);
 
+
     // Image Transformations
     //-----------------------
     void imageFilter(ImageFilter f);
@@ -492,90 +417,52 @@ public:
     ImageResample imageResample() const;
 
     void transformImage(const Image& img,
-        int imgX1,
-        int imgY1,
-        int imgX2,
-        int imgY2,
-        double dstX1,
-        double dstY1,
-        double dstX2,
-        double dstY2);
+                           int imgX1,    int imgY1,    int imgX2,    int imgY2,
+                        double dstX1, double dstY1, double dstX2, double dstY2);
 
     void transformImage(const Image& img,
-        double dstX1,
-        double dstY1,
-        double dstX2,
-        double dstY2);
+                        double dstX1, double dstY1, double dstX2, double dstY2);
 
     void transformImage(const Image& img,
-        int imgX1,
-        int imgY1,
-        int imgX2,
-        int imgY2,
-        const double* parallelogram);
+                        int imgX1, int imgY1, int imgX2, int imgY2,
+                        const double* parallelogram);
 
     void transformImage(const Image& img, const double* parallelogram);
 
-    void transformImagePath(const Image& img,
-        int imgX1,
-        int imgY1,
-        int imgX2,
-        int imgY2,
-        double dstX1,
-        double dstY1,
-        double dstX2,
-        double dstY2);
 
     void transformImagePath(const Image& img,
-        double dstX1,
-        double dstY1,
-        double dstX2,
-        double dstY2);
+                               int imgX1,    int imgY1,    int imgX2,    int imgY2,
+                            double dstX1, double dstY1, double dstX2, double dstY2);
 
     void transformImagePath(const Image& img,
-        int imgX1,
-        int imgY1,
-        int imgX2,
-        int imgY2,
-        const double* parallelogram);
+                            double dstX1, double dstY1, double dstX2, double dstY2);
+
+    void transformImagePath(const Image& img,
+                            int imgX1, int imgY1, int imgX2, int imgY2,
+                            const double* parallelogram);
 
     void transformImagePath(const Image& img, const double* parallelogram);
 
+
     // Image Blending (no transformations available)
     void blendImage(Image& img,
-        int imgX1,
-        int imgY1,
-        int imgX2,
-        int imgY2,
-        double dstX,
-        double dstY,
-        unsigned alpha = 255);
-    void blendImage(Image& img, double dstX, double dstY, unsigned alpha = 255);
+                    int imgX1, int imgY1, int imgX2, int imgY2,
+                    double dstX, double dstY, unsigned alpha=255);
+    void blendImage(Image& img, double dstX, double dstY, unsigned alpha=255);
+
 
     // Copy image directly, together with alpha-channel
     void copyImage(Image& img,
-        int imgX1,
-        int imgY1,
-        int imgX2,
-        int imgY2,
-        double dstX,
-        double dstY);
+                   int imgX1, int imgY1, int imgX2, int imgY2,
+                   double dstX, double dstY);
     void copyImage(Image& img, double dstX, double dstY);
 
+
     // Auxiliary
     //-----------------------
-    static double pi()
-    {
-        return agg::pi;
-    }
-    static double deg2Rad(double v)
-    {
-        return v * agg::pi / 180.0;
-    }
-    static double rad2Deg(double v)
-    {
-        return v * 180.0 / agg::pi;
-    }
+    static double pi() { return agg::pi; }
+    static double deg2Rad(double v) { return v * agg::pi / 180.0; }
+    static double rad2Deg(double v) { return v * 180.0 / agg::pi; }
 
 private:
     void render(bool fillColor);
@@ -585,94 +472,97 @@ private:
 
     void addLine(double x1, double y1, double x2, double y2);
     void updateRasterizerGamma();
-    void renderImage(
-        const Image& img, int x1, int y1, int x2, int y2, const double* parl);
+    void renderImage(const Image& img, int x1, int y1, int x2, int y2, const double* parl);
 
-    agg::rendering_buffer m_rbuf;
-    PixFormat m_pixFormat;
-    PixFormatComp m_pixFormatComp;
-    PixFormatPre m_pixFormatPre;
-    PixFormatCompPre m_pixFormatCompPre;
-    RendererBase m_renBase;
-    RendererBaseComp m_renBaseComp;
-    RendererBasePre m_renBasePre;
-    RendererBaseCompPre m_renBaseCompPre;
-    RendererSolid m_renSolid;
-    RendererSolidComp m_renSolidComp;
+    agg::rendering_buffer           m_rbuf;
+    PixFormat                       m_pixFormat;
+    PixFormatComp                   m_pixFormatComp;
+    PixFormatPre                    m_pixFormatPre;
+    PixFormatCompPre                m_pixFormatCompPre;
+    RendererBase                    m_renBase;
+    RendererBaseComp                m_renBaseComp;
+    RendererBasePre                 m_renBasePre;
+    RendererBaseCompPre             m_renBaseCompPre;
+    RendererSolid                   m_renSolid;
+    RendererSolidComp               m_renSolidComp;
 
-    SpanAllocator m_allocator;
-    RectD m_clipBox;
+    SpanAllocator                   m_allocator;
+    RectD                           m_clipBox;
 
-    BlendMode m_blendMode;
-    BlendMode m_imageBlendMode;
-    Color m_imageBlendColor;
+    BlendMode                       m_blendMode;
+    BlendMode                       m_imageBlendMode;
+    Color                           m_imageBlendColor;
 
-    agg::scanline_u8 m_scanline;
-    agg::rasterizer_scanline_aa<> m_rasterizer;
+    agg::scanline_u8                m_scanline;
+    agg::rasterizer_scanline_aa<>   m_rasterizer;
 
-    double m_masterAlpha;
-    double m_antiAliasGamma;
+    double                          m_masterAlpha;
+    double                          m_antiAliasGamma;
 
-    Color m_fillColor;
-    Color m_lineColor;
-    GradientArray m_fillGradient;
-    GradientArray m_lineGradient;
+    Color                           m_fillColor;
+    Color                           m_lineColor;
+    GradientArray                   m_fillGradient;
+    GradientArray                   m_lineGradient;
 
-    LineCap m_lineCap;
-    LineJoin m_lineJoin;
+    LineCap                         m_lineCap;
+    LineJoin                        m_lineJoin;
 
-    Gradient m_fillGradientFlag;
-    Gradient m_lineGradientFlag;
-    agg::trans_affine m_fillGradientMatrix;
-    agg::trans_affine m_lineGradientMatrix;
-    double m_fillGradientD1;
-    double m_lineGradientD1;
-    double m_fillGradientD2;
-    double m_lineGradientD2;
+    Gradient                        m_fillGradientFlag;
+    Gradient                        m_lineGradientFlag;
+    agg::trans_affine               m_fillGradientMatrix;
+    agg::trans_affine               m_lineGradientMatrix;
+    double                          m_fillGradientD1;
+    double                          m_lineGradientD1;
+    double                          m_fillGradientD2;
+    double                          m_lineGradientD2;
 
-    TextAlignment m_textAlignment;
-    double m_textSizeX;
-    double m_textSizeY;
+    TextAlignment                   m_textAlignment;
+    double                          m_textSizeX;
+    double                          m_textSizeY;
 
-    ImageFilter m_imageFilter;
-    ImageResample m_imageResample;
-    agg::image_filter_lut m_imageFilterLut;
+    ImageFilter                     m_imageFilter;
+    ImageResample                   m_imageResample;
+    agg::image_filter_lut           m_imageFilterLut;
 
     agg::span_interpolator_linear<> m_fillGradientInterpolator;
     agg::span_interpolator_linear<> m_lineGradientInterpolator;
 
-    agg::gradient_x m_linearGradientFunction;
-    agg::gradient_circle m_radialGradientFunction;
+    agg::gradient_x                 m_linearGradientFunction;
+    agg::gradient_circle            m_radialGradientFunction;
 
-    double m_lineWidth;
-    bool m_evenOddFlag;
+    double                          m_lineWidth;
+    bool                            m_evenOddFlag;
 
-    agg::path_storage m_path;
-    agg::trans_affine m_transform;
+    agg::path_storage               m_path;
+    agg::trans_affine               m_transform;
 
-    ConvCurve m_convCurve;
-    ConvStroke m_convStroke;
+    ConvCurve                       m_convCurve;
+    ConvStroke                      m_convStroke;
 
-    PathTransform m_pathTransform;
-    StrokeTransform m_strokeTransform;
+    PathTransform                   m_pathTransform;
+    StrokeTransform                 m_strokeTransform;
 
 #ifdef AGG_USE_FONTS
 #ifndef AGG2D_USE_FREETYPE
-    HDC m_fontDC;
+    HDC                             m_fontDC;
 #endif
-    FontEngine m_fontEngine;
-    FontCacheManager m_fontCacheManager;
+    FontEngine                      m_fontEngine;
+    FontCacheManager                m_fontCacheManager;
 #endif
 };
 
-inline bool operator==(const Agg2D::Color& c1, const Agg2D::Color& c2)
+
+inline bool operator == (const Agg2D::Color& c1, const Agg2D::Color& c2)
 {
-    return c1.r == c2.r && c1.g == c2.g && c1.b == c2.b && c1.a == c2.a;
+   return c1.r == c2.r && c1.g == c2.g && c1.b == c2.b && c1.a == c2.a;
 }
 
-inline bool operator!=(const Agg2D::Color& c1, const Agg2D::Color& c2)
+inline bool operator != (const Agg2D::Color& c1, const Agg2D::Color& c2)
 {
-    return !(c1 == c2);
+   return !(c1 == c2);
 }
 
+
 #endif
+
+

dep/agg/include/agg_alpha_mask_u8.h

@@ -2,8 +2,8 @@
 // Anti-Grain Geometry - Version 2.4
 // Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
 //
-// Permission to copy, use, modify, sell and distribute this software
-// is granted provided this copyright notice appears in all copies.
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
 // This software is provided "as is" without express or implied
 // warranty, and with no claim as to its suitability for any purpose.
 //
@@ -28,63 +28,52 @@ namespace agg
     //===================================================one_component_mask_u8
     struct one_component_mask_u8
     {
-        static unsigned calculate(const int8u* p)
-        {
-            return *p;
-        }
+        static unsigned calculate(const int8u* p) { return *p; }
     };
+    
 
     //=====================================================rgb_to_gray_mask_u8
-    template <unsigned R, unsigned G, unsigned B>
+    template<unsigned R, unsigned G, unsigned B>
     struct rgb_to_gray_mask_u8
     {
-        static unsigned calculate(const int8u* p)
-        {
-            return (p[R] * 77 + p[G] * 150 + p[B] * 29) >> 8;
+        static unsigned calculate(const int8u* p) 
+        { 
+            return (p[R]*77 + p[G]*150 + p[B]*29) >> 8; 
         }
     };
 
     //==========================================================alpha_mask_u8
-    template <unsigned Step = 1,
-        unsigned Offset = 0,
-        class MaskF = one_component_mask_u8>
+    template<unsigned Step=1, unsigned Offset=0, class MaskF=one_component_mask_u8>
     class alpha_mask_u8
     {
     public:
         typedef int8u cover_type;
         typedef alpha_mask_u8<Step, Offset, MaskF> self_type;
         enum cover_scale_e
-        {
+        { 
             cover_shift = 8,
-            cover_none = 0,
-            cover_full = 255
+            cover_none  = 0,
+            cover_full  = 255
         };
 
-        alpha_mask_u8(): m_rbuf(0) {}
-        explicit alpha_mask_u8(rendering_buffer& rbuf): m_rbuf(&rbuf) {}
+        alpha_mask_u8() : m_rbuf(0) {}
+        explicit alpha_mask_u8(rendering_buffer& rbuf) : m_rbuf(&rbuf) {}
 
-        void attach(rendering_buffer& rbuf)
-        {
-            m_rbuf = &rbuf;
-        }
+        void attach(rendering_buffer& rbuf) { m_rbuf = &rbuf; }
 
-        MaskF& mask_function()
-        {
-            return m_mask_function;
-        }
-        const MaskF& mask_function() const
-        {
-            return m_mask_function;
-        }
+        MaskF& mask_function() { return m_mask_function; }
+        const MaskF& mask_function() const { return m_mask_function; }
 
+        
         //--------------------------------------------------------------------
         cover_type pixel(int x, int y) const
         {
-            if (x >= 0 && y >= 0 && x < (int)m_rbuf->width() &&
-                y < (int)m_rbuf->height())
+            if(x >= 0 && y >= 0 && 
+               x < (int)m_rbuf->width() && 
+               y < (int)m_rbuf->height())
             {
                 return (cover_type)m_mask_function.calculate(
-                    m_rbuf->row_ptr(y) + x * Step + Offset);
+                                        m_rbuf->row_ptr(y) + x * Step + Offset);
             }
             return 0;
         }
@@ -92,18 +81,19 @@ namespace agg
         //--------------------------------------------------------------------
         cover_type combine_pixel(int x, int y, cover_type val) const
         {
-            if (x >= 0 && y >= 0 && x < (int)m_rbuf->width() &&
-                y < (int)m_rbuf->height())
+            if(x >= 0 && y >= 0 && 
+               x < (int)m_rbuf->width() && 
+               y < (int)m_rbuf->height())
             {
-                return (
-                    cover_type)((cover_full + val * m_mask_function.calculate(
-                                                        m_rbuf->row_ptr(y) +
-                                                        x * Step + Offset)) >>
-                                cover_shift);
+                return (cover_type)((cover_full + val * 
+                                     m_mask_function.calculate(
+                                        m_rbuf->row_ptr(y) + x * Step + Offset)) >> 
+                                     cover_shift);
             }
             return 0;
         }
 
+
         //--------------------------------------------------------------------
         void fill_hspan(int x, int y, cover_type* dst, int num_pix) const
         {
@@ -113,16 +103,16 @@ namespace agg
             int count = num_pix;
             cover_type* covers = dst;
 
-            if (y < 0 || y > ymax)
+            if(y < 0 || y > ymax)
             {
                 std::memset(dst, 0, num_pix * sizeof(cover_type));
                 return;
             }
 
-            if (x < 0)
+            if(x < 0)
             {
                 count += x;
-                if (count <= 0)
+                if(count <= 0) 
                 {
                     std::memset(dst, 0, num_pix * sizeof(cover_type));
                     return;
@@ -132,11 +122,11 @@ namespace agg
                 x = 0;
             }
 
-            if (x + count > xmax)
+            if(x + count > xmax)
             {
                 int rest = x + count - xmax - 1;
                 count -= rest;
-                if (count <= 0)
+                if(count <= 0) 
                 {
                     std::memset(dst, 0, num_pix * sizeof(cover_type));
                     return;
@@ -149,9 +139,11 @@ namespace agg
             {
                 *covers++ = (cover_type)m_mask_function.calculate(mask);
                 mask += Step;
-            } while (--count);
+            }
+            while(--count);
         }
 
+
         //--------------------------------------------------------------------
         void combine_hspan(int x, int y, cover_type* dst, int num_pix) const
         {
@@ -161,16 +153,16 @@ namespace agg
             int count = num_pix;
             cover_type* covers = dst;
 
-            if (y < 0 || y > ymax)
+            if(y < 0 || y > ymax)
             {
                 std::memset(dst, 0, num_pix * sizeof(cover_type));
                 return;
             }
 
-            if (x < 0)
+            if(x < 0)
             {
                 count += x;
-                if (count <= 0)
+                if(count <= 0) 
                 {
                     std::memset(dst, 0, num_pix * sizeof(cover_type));
                     return;
@@ -180,11 +172,11 @@ namespace agg
                 x = 0;
             }
 
-            if (x + count > xmax)
+            if(x + count > xmax)
             {
                 int rest = x + count - xmax - 1;
                 count -= rest;
-                if (count <= 0)
+                if(count <= 0) 
                 {
                     std::memset(dst, 0, num_pix * sizeof(cover_type));
                     return;
@@ -195,14 +187,13 @@ namespace agg
             const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
             do
             {
-                *covers =
-                    (cover_type)((cover_full +
-                                     (*covers) *
-                                         m_mask_function.calculate(mask)) >>
-                                 cover_shift);
+                *covers = (cover_type)((cover_full + (*covers) * 
+                                       m_mask_function.calculate(mask)) >> 
+                                       cover_shift);
                 ++covers;
                 mask += Step;
-            } while (--count);
+            }
+            while(--count);
         }
 
         //--------------------------------------------------------------------
@@ -214,16 +205,16 @@ namespace agg
             int count = num_pix;
             cover_type* covers = dst;
 
-            if (x < 0 || x > xmax)
+            if(x < 0 || x > xmax)
             {
                 std::memset(dst, 0, num_pix * sizeof(cover_type));
                 return;
             }
 
-            if (y < 0)
+            if(y < 0)
             {
                 count += y;
-                if (count <= 0)
+                if(count <= 0) 
                 {
                     std::memset(dst, 0, num_pix * sizeof(cover_type));
                     return;
@@ -233,11 +224,11 @@ namespace agg
                 y = 0;
             }
 
-            if (y + count > ymax)
+            if(y + count > ymax)
             {
                 int rest = y + count - ymax - 1;
                 count -= rest;
-                if (count <= 0)
+                if(count <= 0) 
                 {
                     std::memset(dst, 0, num_pix * sizeof(cover_type));
                     return;
@@ -250,7 +241,8 @@ namespace agg
             {
                 *covers++ = (cover_type)m_mask_function.calculate(mask);
                 mask += m_rbuf->stride();
-            } while (--count);
+            }
+            while(--count);
         }
 
         //--------------------------------------------------------------------
@@ -262,16 +254,16 @@ namespace agg
             int count = num_pix;
             cover_type* covers = dst;
 
-            if (x < 0 || x > xmax)
+            if(x < 0 || x > xmax)
             {
                 std::memset(dst, 0, num_pix * sizeof(cover_type));
                 return;
             }
 
-            if (y < 0)
+            if(y < 0)
             {
                 count += y;
-                if (count <= 0)
+                if(count <= 0) 
                 {
                     std::memset(dst, 0, num_pix * sizeof(cover_type));
                     return;
@@ -281,11 +273,11 @@ namespace agg
                 y = 0;
             }
 
-            if (y + count > ymax)
+            if(y + count > ymax)
             {
                 int rest = y + count - ymax - 1;
                 count -= rest;
-                if (count <= 0)
+                if(count <= 0) 
                 {
                     std::memset(dst, 0, num_pix * sizeof(cover_type));
                     return;
@@ -296,33 +288,34 @@ namespace agg
             const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
             do
             {
-                *covers =
-                    (cover_type)((cover_full +
-                                     (*covers) *
-                                         m_mask_function.calculate(mask)) >>
-                                 cover_shift);
+                *covers = (cover_type)((cover_full + (*covers) * 
+                                       m_mask_function.calculate(mask)) >> 
+                                       cover_shift);
                 ++covers;
                 mask += m_rbuf->stride();
-            } while (--count);
+            }
+            while(--count);
         }
 
+
     private:
         alpha_mask_u8(const self_type&);
-        const self_type& operator=(const self_type&);
+        const self_type& operator = (const self_type&);
 
         rendering_buffer* m_rbuf;
-        MaskF m_mask_function;
+        MaskF             m_mask_function;
     };
+    
 
-    typedef alpha_mask_u8<1, 0> alpha_mask_gray8; //----alpha_mask_gray8
+    typedef alpha_mask_u8<1, 0> alpha_mask_gray8;   //----alpha_mask_gray8
 
-    typedef alpha_mask_u8<3, 0> alpha_mask_rgb24r; //----alpha_mask_rgb24r
-    typedef alpha_mask_u8<3, 1> alpha_mask_rgb24g; //----alpha_mask_rgb24g
-    typedef alpha_mask_u8<3, 2> alpha_mask_rgb24b; //----alpha_mask_rgb24b
+    typedef alpha_mask_u8<3, 0> alpha_mask_rgb24r;  //----alpha_mask_rgb24r
+    typedef alpha_mask_u8<3, 1> alpha_mask_rgb24g;  //----alpha_mask_rgb24g
+    typedef alpha_mask_u8<3, 2> alpha_mask_rgb24b;  //----alpha_mask_rgb24b
 
-    typedef alpha_mask_u8<3, 2> alpha_mask_bgr24r; //----alpha_mask_bgr24r
-    typedef alpha_mask_u8<3, 1> alpha_mask_bgr24g; //----alpha_mask_bgr24g
-    typedef alpha_mask_u8<3, 0> alpha_mask_bgr24b; //----alpha_mask_bgr24b
+    typedef alpha_mask_u8<3, 2> alpha_mask_bgr24r;  //----alpha_mask_bgr24r
+    typedef alpha_mask_u8<3, 1> alpha_mask_bgr24g;  //----alpha_mask_bgr24g
+    typedef alpha_mask_u8<3, 0> alpha_mask_bgr24b;  //----alpha_mask_bgr24b
 
     typedef alpha_mask_u8<4, 0> alpha_mask_rgba32r; //----alpha_mask_rgba32r
     typedef alpha_mask_u8<4, 1> alpha_mask_rgba32g; //----alpha_mask_rgba32g
@@ -344,68 +337,56 @@ namespace agg
     typedef alpha_mask_u8<4, 1> alpha_mask_abgr32b; //----alpha_mask_abgr32b
     typedef alpha_mask_u8<4, 0> alpha_mask_abgr32a; //----alpha_mask_abgr32a
 
-    typedef alpha_mask_u8<3, 0, rgb_to_gray_mask_u8<0, 1, 2>>
-        alpha_mask_rgb24gray; //----alpha_mask_rgb24gray
-    typedef alpha_mask_u8<3, 0, rgb_to_gray_mask_u8<2, 1, 0>>
-        alpha_mask_bgr24gray; //----alpha_mask_bgr24gray
-    typedef alpha_mask_u8<4, 0, rgb_to_gray_mask_u8<0, 1, 2>>
-        alpha_mask_rgba32gray; //----alpha_mask_rgba32gray
-    typedef alpha_mask_u8<4, 1, rgb_to_gray_mask_u8<0, 1, 2>>
-        alpha_mask_argb32gray; //----alpha_mask_argb32gray
-    typedef alpha_mask_u8<4, 0, rgb_to_gray_mask_u8<2, 1, 0>>
-        alpha_mask_bgra32gray; //----alpha_mask_bgra32gray
-    typedef alpha_mask_u8<4, 1, rgb_to_gray_mask_u8<2, 1, 0>>
-        alpha_mask_abgr32gray; //----alpha_mask_abgr32gray
+    typedef alpha_mask_u8<3, 0, rgb_to_gray_mask_u8<0, 1, 2> > alpha_mask_rgb24gray;  //----alpha_mask_rgb24gray
+    typedef alpha_mask_u8<3, 0, rgb_to_gray_mask_u8<2, 1, 0> > alpha_mask_bgr24gray;  //----alpha_mask_bgr24gray
+    typedef alpha_mask_u8<4, 0, rgb_to_gray_mask_u8<0, 1, 2> > alpha_mask_rgba32gray; //----alpha_mask_rgba32gray
+    typedef alpha_mask_u8<4, 1, rgb_to_gray_mask_u8<0, 1, 2> > alpha_mask_argb32gray; //----alpha_mask_argb32gray
+    typedef alpha_mask_u8<4, 0, rgb_to_gray_mask_u8<2, 1, 0> > alpha_mask_bgra32gray; //----alpha_mask_bgra32gray
+    typedef alpha_mask_u8<4, 1, rgb_to_gray_mask_u8<2, 1, 0> > alpha_mask_abgr32gray; //----alpha_mask_abgr32gray
+
+
 
     //==========================================================amask_no_clip_u8
-    template <unsigned Step = 1,
-        unsigned Offset = 0,
-        class MaskF = one_component_mask_u8>
+    template<unsigned Step=1, unsigned Offset=0, class MaskF=one_component_mask_u8>
     class amask_no_clip_u8
     {
     public:
         typedef int8u cover_type;
         typedef amask_no_clip_u8<Step, Offset, MaskF> self_type;
         enum cover_scale_e
-        {
+        { 
             cover_shift = 8,
-            cover_none = 0,
-            cover_full = 255
+            cover_none  = 0,
+            cover_full  = 255
         };
 
-        amask_no_clip_u8(): m_rbuf(0) {}
-        explicit amask_no_clip_u8(rendering_buffer& rbuf): m_rbuf(&rbuf) {}
+        amask_no_clip_u8() : m_rbuf(0) {}
+        explicit amask_no_clip_u8(rendering_buffer& rbuf) : m_rbuf(&rbuf) {}
 
-        void attach(rendering_buffer& rbuf)
-        {
-            m_rbuf = &rbuf;
-        }
+        void attach(rendering_buffer& rbuf) { m_rbuf = &rbuf; }
+
+        MaskF& mask_function() { return m_mask_function; }
+        const MaskF& mask_function() const { return m_mask_function; }
 
-        MaskF& mask_function()
-        {
-            return m_mask_function;
-        }
-        const MaskF& mask_function() const
-        {
-            return m_mask_function;
-        }
 
         //--------------------------------------------------------------------
         cover_type pixel(int x, int y) const
         {
             return (cover_type)m_mask_function.calculate(
-                m_rbuf->row_ptr(y) + x * Step + Offset);
+                                   m_rbuf->row_ptr(y) + x * Step + Offset);
         }
 
+        
         //--------------------------------------------------------------------
         cover_type combine_pixel(int x, int y, cover_type val) const
         {
-            return (cover_type)((cover_full + val * m_mask_function.calculate(
-                                                        m_rbuf->row_ptr(y) +
-                                                        x * Step + Offset)) >>
-                                cover_shift);
+            return (cover_type)((cover_full + val * 
+                                 m_mask_function.calculate(
+                                    m_rbuf->row_ptr(y) + x * Step + Offset)) >> 
+                                 cover_shift);
         }
 
+
         //--------------------------------------------------------------------
         void fill_hspan(int x, int y, cover_type* dst, int num_pix) const
         {
@@ -414,24 +395,28 @@ namespace agg
             {
                 *dst++ = (cover_type)m_mask_function.calculate(mask);
                 mask += Step;
-            } while (--num_pix);
+            }
+            while(--num_pix);
         }
 
+
+
         //--------------------------------------------------------------------
         void combine_hspan(int x, int y, cover_type* dst, int num_pix) const
         {
             const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
             do
             {
-                *dst = (cover_type)((cover_full +
-                                        (*dst) *
-                                            m_mask_function.calculate(mask)) >>
+                *dst = (cover_type)((cover_full + (*dst) * 
+                                    m_mask_function.calculate(mask)) >> 
                                     cover_shift);
                 ++dst;
                 mask += Step;
-            } while (--num_pix);
+            }
+            while(--num_pix);
         }
 
+
         //--------------------------------------------------------------------
         void fill_vspan(int x, int y, cover_type* dst, int num_pix) const
         {
@@ -440,98 +425,75 @@ namespace agg
             {
                 *dst++ = (cover_type)m_mask_function.calculate(mask);
                 mask += m_rbuf->stride();
-            } while (--num_pix);
+            }
+            while(--num_pix);
         }
 
+
         //--------------------------------------------------------------------
         void combine_vspan(int x, int y, cover_type* dst, int num_pix) const
         {
             const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
             do
             {
-                *dst = (cover_type)((cover_full +
-                                        (*dst) *
-                                            m_mask_function.calculate(mask)) >>
+                *dst = (cover_type)((cover_full + (*dst) * 
+                                    m_mask_function.calculate(mask)) >> 
                                     cover_shift);
                 ++dst;
                 mask += m_rbuf->stride();
-            } while (--num_pix);
+            }
+            while(--num_pix);
         }
 
     private:
         amask_no_clip_u8(const self_type&);
-        const self_type& operator=(const self_type&);
+        const self_type& operator = (const self_type&);
 
         rendering_buffer* m_rbuf;
-        MaskF m_mask_function;
+        MaskF             m_mask_function;
     };
+    
 
-    typedef amask_no_clip_u8<1, 0>
-        amask_no_clip_gray8; //----amask_no_clip_gray8
+    typedef amask_no_clip_u8<1, 0> amask_no_clip_gray8;   //----amask_no_clip_gray8
 
-    typedef amask_no_clip_u8<3, 0>
-        amask_no_clip_rgb24r; //----amask_no_clip_rgb24r
-    typedef amask_no_clip_u8<3, 1>
-        amask_no_clip_rgb24g; //----amask_no_clip_rgb24g
-    typedef amask_no_clip_u8<3, 2>
-        amask_no_clip_rgb24b; //----amask_no_clip_rgb24b
+    typedef amask_no_clip_u8<3, 0> amask_no_clip_rgb24r;  //----amask_no_clip_rgb24r
+    typedef amask_no_clip_u8<3, 1> amask_no_clip_rgb24g;  //----amask_no_clip_rgb24g
+    typedef amask_no_clip_u8<3, 2> amask_no_clip_rgb24b;  //----amask_no_clip_rgb24b
 
-    typedef amask_no_clip_u8<3, 2>
-        amask_no_clip_bgr24r; //----amask_no_clip_bgr24r
-    typedef amask_no_clip_u8<3, 1>
-        amask_no_clip_bgr24g; //----amask_no_clip_bgr24g
-    typedef amask_no_clip_u8<3, 0>
-        amask_no_clip_bgr24b; //----amask_no_clip_bgr24b
+    typedef amask_no_clip_u8<3, 2> amask_no_clip_bgr24r;  //----amask_no_clip_bgr24r
+    typedef amask_no_clip_u8<3, 1> amask_no_clip_bgr24g;  //----amask_no_clip_bgr24g
+    typedef amask_no_clip_u8<3, 0> amask_no_clip_bgr24b;  //----amask_no_clip_bgr24b
 
-    typedef amask_no_clip_u8<4, 0>
-        amask_no_clip_rgba32r; //----amask_no_clip_rgba32r
-    typedef amask_no_clip_u8<4, 1>
-        amask_no_clip_rgba32g; //----amask_no_clip_rgba32g
-    typedef amask_no_clip_u8<4, 2>
-        amask_no_clip_rgba32b; //----amask_no_clip_rgba32b
-    typedef amask_no_clip_u8<4, 3>
-        amask_no_clip_rgba32a; //----amask_no_clip_rgba32a
+    typedef amask_no_clip_u8<4, 0> amask_no_clip_rgba32r; //----amask_no_clip_rgba32r
+    typedef amask_no_clip_u8<4, 1> amask_no_clip_rgba32g; //----amask_no_clip_rgba32g
+    typedef amask_no_clip_u8<4, 2> amask_no_clip_rgba32b; //----amask_no_clip_rgba32b
+    typedef amask_no_clip_u8<4, 3> amask_no_clip_rgba32a; //----amask_no_clip_rgba32a
 
-    typedef amask_no_clip_u8<4, 1>
-        amask_no_clip_argb32r; //----amask_no_clip_argb32r
-    typedef amask_no_clip_u8<4, 2>
-        amask_no_clip_argb32g; //----amask_no_clip_argb32g
-    typedef amask_no_clip_u8<4, 3>
-        amask_no_clip_argb32b; //----amask_no_clip_argb32b
-    typedef amask_no_clip_u8<4, 0>
-        amask_no_clip_argb32a; //----amask_no_clip_argb32a
+    typedef amask_no_clip_u8<4, 1> amask_no_clip_argb32r; //----amask_no_clip_argb32r
+    typedef amask_no_clip_u8<4, 2> amask_no_clip_argb32g; //----amask_no_clip_argb32g
+    typedef amask_no_clip_u8<4, 3> amask_no_clip_argb32b; //----amask_no_clip_argb32b
+    typedef amask_no_clip_u8<4, 0> amask_no_clip_argb32a; //----amask_no_clip_argb32a
 
-    typedef amask_no_clip_u8<4, 2>
-        amask_no_clip_bgra32r; //----amask_no_clip_bgra32r
-    typedef amask_no_clip_u8<4, 1>
-        amask_no_clip_bgra32g; //----amask_no_clip_bgra32g
-    typedef amask_no_clip_u8<4, 0>
-        amask_no_clip_bgra32b; //----amask_no_clip_bgra32b
-    typedef amask_no_clip_u8<4, 3>
-        amask_no_clip_bgra32a; //----amask_no_clip_bgra32a
+    typedef amask_no_clip_u8<4, 2> amask_no_clip_bgra32r; //----amask_no_clip_bgra32r
+    typedef amask_no_clip_u8<4, 1> amask_no_clip_bgra32g; //----amask_no_clip_bgra32g
+    typedef amask_no_clip_u8<4, 0> amask_no_clip_bgra32b; //----amask_no_clip_bgra32b
+    typedef amask_no_clip_u8<4, 3> amask_no_clip_bgra32a; //----amask_no_clip_bgra32a
 
-    typedef amask_no_clip_u8<4, 3>
-        amask_no_clip_abgr32r; //----amask_no_clip_abgr32r
-    typedef amask_no_clip_u8<4, 2>
-        amask_no_clip_abgr32g; //----amask_no_clip_abgr32g
-    typedef amask_no_clip_u8<4, 1>
-        amask_no_clip_abgr32b; //----amask_no_clip_abgr32b
-    typedef amask_no_clip_u8<4, 0>
-        amask_no_clip_abgr32a; //----amask_no_clip_abgr32a
+    typedef amask_no_clip_u8<4, 3> amask_no_clip_abgr32r; //----amask_no_clip_abgr32r
+    typedef amask_no_clip_u8<4, 2> amask_no_clip_abgr32g; //----amask_no_clip_abgr32g
+    typedef amask_no_clip_u8<4, 1> amask_no_clip_abgr32b; //----amask_no_clip_abgr32b
+    typedef amask_no_clip_u8<4, 0> amask_no_clip_abgr32a; //----amask_no_clip_abgr32a
+
+    typedef amask_no_clip_u8<3, 0, rgb_to_gray_mask_u8<0, 1, 2> > amask_no_clip_rgb24gray;  //----amask_no_clip_rgb24gray
+    typedef amask_no_clip_u8<3, 0, rgb_to_gray_mask_u8<2, 1, 0> > amask_no_clip_bgr24gray;  //----amask_no_clip_bgr24gray
+    typedef amask_no_clip_u8<4, 0, rgb_to_gray_mask_u8<0, 1, 2> > amask_no_clip_rgba32gray; //----amask_no_clip_rgba32gray
+    typedef amask_no_clip_u8<4, 1, rgb_to_gray_mask_u8<0, 1, 2> > amask_no_clip_argb32gray; //----amask_no_clip_argb32gray
+    typedef amask_no_clip_u8<4, 0, rgb_to_gray_mask_u8<2, 1, 0> > amask_no_clip_bgra32gray; //----amask_no_clip_bgra32gray
+    typedef amask_no_clip_u8<4, 1, rgb_to_gray_mask_u8<2, 1, 0> > amask_no_clip_abgr32gray; //----amask_no_clip_abgr32gray
 
-    typedef amask_no_clip_u8<3, 0, rgb_to_gray_mask_u8<0, 1, 2>>
-        amask_no_clip_rgb24gray; //----amask_no_clip_rgb24gray
-    typedef amask_no_clip_u8<3, 0, rgb_to_gray_mask_u8<2, 1, 0>>
-        amask_no_clip_bgr24gray; //----amask_no_clip_bgr24gray
-    typedef amask_no_clip_u8<4, 0, rgb_to_gray_mask_u8<0, 1, 2>>
-        amask_no_clip_rgba32gray; //----amask_no_clip_rgba32gray
-    typedef amask_no_clip_u8<4, 1, rgb_to_gray_mask_u8<0, 1, 2>>
-        amask_no_clip_argb32gray; //----amask_no_clip_argb32gray
-    typedef amask_no_clip_u8<4, 0, rgb_to_gray_mask_u8<2, 1, 0>>
-        amask_no_clip_bgra32gray; //----amask_no_clip_bgra32gray
-    typedef amask_no_clip_u8<4, 1, rgb_to_gray_mask_u8<2, 1, 0>>
-        amask_no_clip_abgr32gray; //----amask_no_clip_abgr32gray
 
 }
 
+
+
 #endif

dep/agg/include/agg_arc.h

@@ -2,8 +2,8 @@
 // Anti-Grain Geometry - Version 2.4
 // Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
 //
-// Permission to copy, use, modify, sell and distribute this software
-// is granted provided this copyright notice appears in all copies.
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
 // This software is provided "as is" without express or implied
 // warranty, and with no claim as to its suitability for any purpose.
 //
@@ -27,33 +27,24 @@ namespace agg
 
     //=====================================================================arc
     //
-    // See Implementation agg_arc.cpp
+    // See Implementation agg_arc.cpp 
     //
     class arc
     {
     public:
-        arc(): m_scale(1.0), m_initialized(false) {}
-        arc(double x,
-            double y,
-            double rx,
-            double ry,
-            double a1,
-            double a2,
-            bool ccw = true);
+        arc() : m_scale(1.0), m_initialized(false) {}
+        arc(double x,  double y, 
+            double rx, double ry, 
+            double a1, double a2, 
+            bool ccw=true);
 
-        void init(double x,
-            double y,
-            double rx,
-            double ry,
-            double a1,
-            double a2,
-            bool ccw = true);
+        void init(double x,  double y, 
+                  double rx, double ry, 
+                  double a1, double a2, 
+                  bool ccw=true);
 
         void approximation_scale(double s);
-        double approximation_scale() const
-        {
-            return m_scale;
-        }
+        double approximation_scale() const { return m_scale;  }
 
         void rewind(unsigned);
         unsigned vertex(double* x, double* y);
@@ -61,20 +52,22 @@ namespace agg
     private:
         void normalize(double a1, double a2, bool ccw);
 
-        double m_x;
-        double m_y;
-        double m_rx;
-        double m_ry;
-        double m_angle;
-        double m_start;
-        double m_end;
-        double m_scale;
-        double m_da;
-        bool m_ccw;
-        bool m_initialized;
+        double   m_x;
+        double   m_y;
+        double   m_rx;
+        double   m_ry;
+        double   m_angle;
+        double   m_start;
+        double   m_end;
+        double   m_scale;
+        double   m_da;
+        bool     m_ccw;
+        bool     m_initialized;
         unsigned m_path_cmd;
     };
 
+
 }
 
+
 #endif

dep/agg/include/agg_arrowhead.h

@@ -2,8 +2,8 @@
 // Anti-Grain Geometry - Version 2.4
 // Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
 //
-// Permission to copy, use, modify, sell and distribute this software
-// is granted provided this copyright notice appears in all copies.
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
 // This software is provided "as is" without express or implied
 // warranty, and with no claim as to its suitability for any purpose.
 //
@@ -13,7 +13,7 @@
 //          http://www.antigrain.com
 //----------------------------------------------------------------------------
 //
-// Simple arrowhead/arrowtail generator
+// Simple arrowhead/arrowtail generator 
 //
 //----------------------------------------------------------------------------
 #ifndef AGG_ARROWHEAD_INCLUDED
@@ -26,7 +26,7 @@ namespace agg
 
     //===============================================================arrowhead
     //
-    // See implementation agg_arrowhead.cpp
+    // See implementation agg_arrowhead.cpp 
     //
     class arrowhead
     {
@@ -42,14 +42,8 @@ namespace agg
             m_head_flag = true;
         }
 
-        void head()
-        {
-            m_head_flag = true;
-        }
-        void no_head()
-        {
-            m_head_flag = false;
-        }
+        void head()    { m_head_flag = true; }
+        void no_head() { m_head_flag = false; }
 
         void tail(double d1, double d2, double d3, double d4)
         {
@@ -60,30 +54,24 @@ namespace agg
             m_tail_flag = true;
         }
 
-        void tail()
-        {
-            m_tail_flag = true;
-        }
-        void no_tail()
-        {
-            m_tail_flag = false;
-        }
+        void tail()    { m_tail_flag = true;  }
+        void no_tail() { m_tail_flag = false; }
 
         void rewind(unsigned path_id);
         unsigned vertex(double* x, double* y);
 
     private:
-        double m_head_d1;
-        double m_head_d2;
-        double m_head_d3;
-        double m_head_d4;
-        double m_tail_d1;
-        double m_tail_d2;
-        double m_tail_d3;
-        double m_tail_d4;
-        bool m_head_flag;
-        bool m_tail_flag;
-        double m_coord[16];
+        double   m_head_d1;
+        double   m_head_d2;
+        double   m_head_d3;
+        double   m_head_d4;
+        double   m_tail_d1;
+        double   m_tail_d2;
+        double   m_tail_d3;
+        double   m_tail_d4;
+        bool     m_head_flag;
+        bool     m_tail_flag;
+        double   m_coord[16];
         unsigned m_cmd[8];
         unsigned m_curr_id;
         unsigned m_curr_coord;

dep/agg/include/agg_basics.h

@@ -2,8 +2,8 @@
 // Anti-Grain Geometry - Version 2.4
 // Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
 //
-// Permission to copy, use, modify, sell and distribute this software
-// is granted provided this copyright notice appears in all copies.
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
 // This software is provided "as is" without express or implied
 // warranty, and with no claim as to its suitability for any purpose.
 //
@@ -25,50 +25,37 @@
 #else
 namespace agg
 {
-    // The policy of all AGG containers and memory allocation strategy
+    // The policy of all AGG containers and memory allocation strategy 
     // in general is that no allocated data requires explicit construction.
     // It means that the allocator can be really simple; you can even
-    // replace new/delete to malloc/free. The constructors and destructors
-    // won't be called in this case, however everything will remain working.
-    // The second argument of deallocate() is the size of the allocated
+    // replace new/delete to malloc/free. The constructors and destructors 
+    // won't be called in this case, however everything will remain working. 
+    // The second argument of deallocate() is the size of the allocated 
     // block. You can use this information if you wish.
     //------------------------------------------------------------pod_allocator
-    template <class T>
-    struct pod_allocator
+    template<class T> struct pod_allocator
     {
-        static T* allocate(unsigned num)
-        {
-            return new T[num];
-        }
-        static void deallocate(T* ptr, unsigned)
-        {
-            delete[] ptr;
-        }
+        static T*   allocate(unsigned num)       { return new T [num]; }
+        static void deallocate(T* ptr, unsigned) { delete [] ptr;      }
     };
 
     // Single object allocator. It's also can be replaced with your custom
-    // allocator. The difference is that it can only allocate a single
-    // object and the constructor and destructor must be called.
+    // allocator. The difference is that it can only allocate a single 
+    // object and the constructor and destructor must be called. 
     // In AGG there is no need to allocate an array of objects with
     // calling their constructors (only single ones). So that, if you
     // replace these new/delete to malloc/free make sure that the in-place
     // new is called and take care of calling the destructor too.
     //------------------------------------------------------------obj_allocator
-    template <class T>
-    struct obj_allocator
+    template<class T> struct obj_allocator
     {
-        static T* allocate()
-        {
-            return new T;
-        }
-        static void deallocate(T* ptr)
-        {
-            delete ptr;
-        }
+        static T*   allocate()         { return new T; }
+        static void deallocate(T* ptr) { delete ptr;   }
     };
 }
 #endif
 
+
 //-------------------------------------------------------- Default basic types
 //
 // If the compiler has different capacity of the basic types you can redefine
@@ -117,7 +104,7 @@ namespace agg
 
 //------------------------------------------------ Some fixes for MS Visual C++
 #if defined(_MSC_VER)
-#pragma warning(disable : 4786) // Identifier was truncated...
+#pragma warning(disable:4786) // Identifier was truncated...
 #endif
 
 #if defined(_MSC_VER)
@@ -129,36 +116,38 @@ namespace agg
 namespace agg
 {
     //-------------------------------------------------------------------------
-    typedef AGG_INT8 int8;     //----int8
-    typedef AGG_INT8U int8u;   //----int8u
-    typedef AGG_INT16 int16;   //----int16
-    typedef AGG_INT16U int16u; //----int16u
-    typedef AGG_INT32 int32;   //----int32
-    typedef AGG_INT32U int32u; //----int32u
-    typedef AGG_INT64 int64;   //----int64
-    typedef AGG_INT64U int64u; //----int64u
+    typedef AGG_INT8   int8;         //----int8
+    typedef AGG_INT8U  int8u;        //----int8u
+    typedef AGG_INT16  int16;        //----int16
+    typedef AGG_INT16U int16u;       //----int16u
+    typedef AGG_INT32  int32;        //----int32
+    typedef AGG_INT32U int32u;       //----int32u
+    typedef AGG_INT64  int64;        //----int64
+    typedef AGG_INT64U int64u;       //----int64u
 
 #if defined(AGG_FISTP)
 #pragma warning(push)
-#pragma warning(disable : 4035)     // Disable warning "no return value"
-    AGG_INLINE int iround(double v) //-------iround
+#pragma warning(disable : 4035) //Disable warning "no return value"
+    AGG_INLINE int iround(double v)              //-------iround
     {
         int t;
-        __asm fld qword ptr[v] __asm fistp dword ptr[t] __asm mov eax,
-            dword ptr[t]
+        __asm fld   qword ptr [v]
+        __asm fistp dword ptr [t]
+        __asm mov eax, dword ptr [t]
     }
-    AGG_INLINE unsigned uround(double v) //-------uround
+    AGG_INLINE unsigned uround(double v)         //-------uround
     {
         unsigned t;
-        __asm fld qword ptr[v] __asm fistp dword ptr[t] __asm mov eax,
-            dword ptr[t]
+        __asm fld   qword ptr [v]
+        __asm fistp dword ptr [t]
+        __asm mov eax, dword ptr [t]
     }
 #pragma warning(pop)
     AGG_INLINE int ifloor(double v)
     {
         return int(floor(v));
     }
-    AGG_INLINE unsigned ufloor(double v) //-------ufloor
+    AGG_INLINE unsigned ufloor(double v)         //-------ufloor
     {
         return unsigned(floor(v));
     }
@@ -166,7 +155,7 @@ namespace agg
     {
         return int(ceil(v));
     }
-    AGG_INLINE unsigned uceil(double v) //--------uceil
+    AGG_INLINE unsigned uceil(double v)          //--------uceil
     {
         return unsigned(ceil(v));
     }
@@ -224,53 +213,48 @@ namespace agg
 #endif
 
     //---------------------------------------------------------------saturation
-    template <int Limit>
-    struct saturation
+    template<int Limit> struct saturation
     {
         AGG_INLINE static int iround(double v)
         {
-            if (v < double(-Limit))
-                return -Limit;
-            if (v > double(Limit))
-                return Limit;
+            if(v < double(-Limit)) return -Limit;
+            if(v > double( Limit)) return  Limit;
             return agg::iround(v);
         }
     };
 
     //------------------------------------------------------------------mul_one
-    template <unsigned Shift>
-    struct mul_one
+    template<unsigned Shift> struct mul_one
     {
         AGG_INLINE static unsigned mul(unsigned a, unsigned b)
         {
-            unsigned q = a * b + (1 << (Shift - 1));
+            unsigned q = a * b + (1 << (Shift-1));
             return (q + (q >> Shift)) >> Shift;
         }
     };
 
     //-------------------------------------------------------------------------
-    typedef unsigned char cover_type; //----cover_type
+    typedef unsigned char cover_type;    //----cover_type
     enum cover_scale_e
     {
-        cover_shift = 8,               //----cover_shift
-        cover_size = 1 << cover_shift, //----cover_size
-        cover_mask = cover_size - 1,   //----cover_mask
-        cover_none = 0,                //----cover_none
-        cover_full = cover_mask        //----cover_full
+        cover_shift = 8,                 //----cover_shift
+        cover_size  = 1 << cover_shift,  //----cover_size 
+        cover_mask  = cover_size - 1,    //----cover_mask 
+        cover_none  = 0,                 //----cover_none 
+        cover_full  = cover_mask         //----cover_full 
     };
 
     //----------------------------------------------------poly_subpixel_scale_e
-    // These constants determine the subpixel accuracy, to be more precise,
-    // the number of bits of the fractional part of the coordinates.
+    // These constants determine the subpixel accuracy, to be more precise, 
+    // the number of bits of the fractional part of the coordinates. 
     // The possible coordinate capacity in bits can be calculated by formula:
     // sizeof(int) * 8 - poly_subpixel_shift, i.e, for 32-bit integers and
     // 8-bits fractional part the capacity is 24 bits.
     enum poly_subpixel_scale_e
     {
-        poly_subpixel_shift = 8, //----poly_subpixel_shift
-        poly_subpixel_scale = 1
-                              << poly_subpixel_shift, //----poly_subpixel_scale
-        poly_subpixel_mask = poly_subpixel_scale - 1  //----poly_subpixel_mask
+        poly_subpixel_shift = 8,                      //----poly_subpixel_shift
+        poly_subpixel_scale = 1<<poly_subpixel_shift, //----poly_subpixel_scale 
+        poly_subpixel_mask  = poly_subpixel_scale-1   //----poly_subpixel_mask 
     };
 
     //----------------------------------------------------------filling_rule_e
@@ -294,60 +278,37 @@ namespace agg
     {
         return rad * 180.0 / pi;
     }
-
+ 
     //----------------------------------------------------------------rect_base
-    template <class T>
-    struct rect_base
+    template<class T> struct rect_base
     {
-        typedef T value_type;
+        typedef T            value_type;
         typedef rect_base<T> self_type;
         T x1, y1, x2, y2;
 
         rect_base() {}
-        rect_base(T x1_, T y1_, T x2_, T y2_):
-            x1(x1_),
-            y1(y1_),
-            x2(x2_),
-            y2(y2_)
-        {
-        }
+        rect_base(T x1_, T y1_, T x2_, T y2_) :
+            x1(x1_), y1(y1_), x2(x2_), y2(y2_) {}
 
-        void init(T x1_, T y1_, T x2_, T y2_)
+        void init(T x1_, T y1_, T x2_, T y2_) 
         {
-            x1 = x1_;
-            y1 = y1_;
-            x2 = x2_;
-            y2 = y2_;
+            x1 = x1_; y1 = y1_; x2 = x2_; y2 = y2_; 
         }
 
         const self_type& normalize()
         {
             T t;
-            if (x1 > x2)
-            {
-                t = x1;
-                x1 = x2;
-                x2 = t;
-            }
-            if (y1 > y2)
-            {
-                t = y1;
-                y1 = y2;
-                y2 = t;
-            }
+            if(x1 > x2) { t = x1; x1 = x2; x2 = t; }
+            if(y1 > y2) { t = y1; y1 = y2; y2 = t; }
             return *this;
         }
 
         bool clip(const self_type& r)
         {
-            if (x2 > r.x2)
-                x2 = r.x2;
-            if (y2 > r.y2)
-                y2 = r.y2;
-            if (x1 < r.x1)
-                x1 = r.x1;
-            if (y1 < r.y1)
-                y1 = r.y1;
+            if(x2 > r.x2) x2 = r.x2;
+            if(y2 > r.y2) y2 = r.y2;
+            if(x1 < r.x1) x1 = r.x1;
+            if(y1 < r.y1) y1 = r.y1;
             return x1 <= x2 && y1 <= y2;
         }
 
@@ -360,78 +321,72 @@ namespace agg
         {
             return (x >= x1 && x <= x2 && y >= y1 && y <= y2);
         }
-
+        
         bool overlaps(const self_type& r) const
         {
-            return !(r.x1 > x2 || r.x2 < x1 || r.y1 > y2 || r.y2 < y1);
+            return !(r.x1 > x2 || r.x2 < x1
+                  || r.y1 > y2 || r.y2 < y1);
         }
     };
 
     //-----------------------------------------------------intersect_rectangles
-    template <class Rect>
+    template<class Rect> 
     inline Rect intersect_rectangles(const Rect& r1, const Rect& r2)
     {
         Rect r = r1;
 
-        // First process x2,y2 because the other order
-        // results in Internal Compiler Error under
-        // Microsoft Visual C++ .NET 2003 69462-335-0000007-18038 in
+        // First process x2,y2 because the other order 
+        // results in Internal Compiler Error under 
+        // Microsoft Visual C++ .NET 2003 69462-335-0000007-18038 in 
         // case of "Maximize Speed" optimization option.
         //-----------------
-        if (r.x2 > r2.x2)
-            r.x2 = r2.x2;
-        if (r.y2 > r2.y2)
-            r.y2 = r2.y2;
-        if (r.x1 < r2.x1)
-            r.x1 = r2.x1;
-        if (r.y1 < r2.y1)
-            r.y1 = r2.y1;
+        if(r.x2 > r2.x2) r.x2 = r2.x2; 
+        if(r.y2 > r2.y2) r.y2 = r2.y2;
+        if(r.x1 < r2.x1) r.x1 = r2.x1;
+        if(r.y1 < r2.y1) r.y1 = r2.y1;
         return r;
     }
 
+
     //---------------------------------------------------------unite_rectangles
-    template <class Rect>
+    template<class Rect> 
     inline Rect unite_rectangles(const Rect& r1, const Rect& r2)
     {
         Rect r = r1;
-        if (r.x2 < r2.x2)
-            r.x2 = r2.x2;
-        if (r.y2 < r2.y2)
-            r.y2 = r2.y2;
-        if (r.x1 > r2.x1)
-            r.x1 = r2.x1;
-        if (r.y1 > r2.y1)
-            r.y1 = r2.y1;
+        if(r.x2 < r2.x2) r.x2 = r2.x2;
+        if(r.y2 < r2.y2) r.y2 = r2.y2;
+        if(r.x1 > r2.x1) r.x1 = r2.x1;
+        if(r.y1 > r2.y1) r.y1 = r2.y1;
         return r;
     }
 
-    typedef rect_base<int> rect_i;    //----rect_i
-    typedef rect_base<float> rect_f;  //----rect_f
+    typedef rect_base<int>    rect_i; //----rect_i
+    typedef rect_base<float>  rect_f; //----rect_f
     typedef rect_base<double> rect_d; //----rect_d
 
     //---------------------------------------------------------path_commands_e
     enum path_commands_e
     {
-        path_cmd_stop = 0,        //----path_cmd_stop
-        path_cmd_move_to = 1,     //----path_cmd_move_to
-        path_cmd_line_to = 2,     //----path_cmd_line_to
-        path_cmd_curve3 = 3,      //----path_cmd_curve3
-        path_cmd_curve4 = 4,      //----path_cmd_curve4
-        path_cmd_curveN = 5,      //----path_cmd_curveN
-        path_cmd_catrom = 6,      //----path_cmd_catrom
-        path_cmd_ubspline = 7,    //----path_cmd_ubspline
-        path_cmd_end_poly = 0x0F, //----path_cmd_end_poly
-        path_cmd_mask = 0x0F      //----path_cmd_mask
+        path_cmd_stop     = 0,        //----path_cmd_stop    
+        path_cmd_move_to  = 1,        //----path_cmd_move_to 
+        path_cmd_line_to  = 2,        //----path_cmd_line_to 
+        path_cmd_curve3   = 3,        //----path_cmd_curve3  
+        path_cmd_curve4   = 4,        //----path_cmd_curve4  
+        path_cmd_curveN   = 5,        //----path_cmd_curveN
+        path_cmd_catrom   = 6,        //----path_cmd_catrom
+        path_cmd_ubspline = 7,        //----path_cmd_ubspline
+        path_cmd_end_poly = 0x0F,     //----path_cmd_end_poly
+        path_cmd_mask     = 0x0F      //----path_cmd_mask    
     };
 
     //------------------------------------------------------------path_flags_e
     enum path_flags_e
     {
-        path_flags_none = 0,     //----path_flags_none
-        path_flags_ccw = 0x10,   //----path_flags_ccw
-        path_flags_cw = 0x20,    //----path_flags_cw
-        path_flags_close = 0x40, //----path_flags_close
-        path_flags_mask = 0xF0   //----path_flags_mask
+        path_flags_none  = 0,         //----path_flags_none 
+        path_flags_ccw   = 0x10,      //----path_flags_ccw  
+        path_flags_cw    = 0x20,      //----path_flags_cw   
+        path_flags_close = 0x40,      //----path_flags_close
+        path_flags_mask  = 0xF0       //----path_flags_mask 
     };
 
     //---------------------------------------------------------------is_vertex
@@ -448,7 +403,7 @@ namespace agg
 
     //-----------------------------------------------------------------is_stop
     inline bool is_stop(unsigned c)
-    {
+    { 
         return c == path_cmd_stop;
     }
 
@@ -492,7 +447,7 @@ namespace agg
     inline bool is_close(unsigned c)
     {
         return (c & ~(path_flags_cw | path_flags_ccw)) ==
-               (path_cmd_end_poly | path_flags_close);
+               (path_cmd_end_poly | path_flags_close); 
     }
 
     //------------------------------------------------------------is_next_poly
@@ -516,19 +471,19 @@ namespace agg
     //-------------------------------------------------------------is_oriented
     inline bool is_oriented(unsigned c)
     {
-        return (c & (path_flags_cw | path_flags_ccw)) != 0;
+        return (c & (path_flags_cw | path_flags_ccw)) != 0; 
     }
 
     //---------------------------------------------------------------is_closed
     inline bool is_closed(unsigned c)
     {
-        return (c & path_flags_close) != 0;
+        return (c & path_flags_close) != 0; 
     }
 
     //----------------------------------------------------------get_close_flag
     inline unsigned get_close_flag(unsigned c)
     {
-        return c & path_flags_close;
+        return c & path_flags_close; 
     }
 
     //-------------------------------------------------------clear_orientation
@@ -550,77 +505,70 @@ namespace agg
     }
 
     //--------------------------------------------------------------point_base
-    template <class T>
-    struct point_base
+    template<class T> struct point_base
     {
         typedef T value_type;
-        T x, y;
+        T x,y;
         point_base() {}
-        point_base(T x_, T y_): x(x_), y(y_) {}
+        point_base(T x_, T y_) : x(x_), y(y_) {}
     };
-    typedef point_base<int> point_i;    //-----point_i
-    typedef point_base<float> point_f;  //-----point_f
+    typedef point_base<int>    point_i; //-----point_i
+    typedef point_base<float>  point_f; //-----point_f
     typedef point_base<double> point_d; //-----point_d
 
     //-------------------------------------------------------------vertex_base
-    template <class T>
-    struct vertex_base
+    template<class T> struct vertex_base
     {
         typedef T value_type;
-        T x, y;
+        T x,y;
         unsigned cmd;
         vertex_base() {}
-        vertex_base(T x_, T y_, unsigned cmd_): x(x_), y(y_), cmd(cmd_) {}
+        vertex_base(T x_, T y_, unsigned cmd_) : x(x_), y(y_), cmd(cmd_) {}
     };
-    typedef vertex_base<int> vertex_i;    //-----vertex_i
-    typedef vertex_base<float> vertex_f;  //-----vertex_f
+    typedef vertex_base<int>    vertex_i; //-----vertex_i
+    typedef vertex_base<float>  vertex_f; //-----vertex_f
     typedef vertex_base<double> vertex_d; //-----vertex_d
 
     //----------------------------------------------------------------row_info
-    template <class T>
-    struct row_info
+    template<class T> struct row_info
     {
         int x1, x2;
         T* ptr;
         row_info() {}
-        row_info(int x1_, int x2_, T* ptr_): x1(x1_), x2(x2_), ptr(ptr_) {}
+        row_info(int x1_, int x2_, T* ptr_) : x1(x1_), x2(x2_), ptr(ptr_) {}
     };
 
     //----------------------------------------------------------const_row_info
-    template <class T>
-    struct const_row_info
+    template<class T> struct const_row_info
     {
         int x1, x2;
         const T* ptr;
         const_row_info() {}
-        const_row_info(int x1_, int x2_, const T* ptr_):
-            x1(x1_),
-            x2(x2_),
-            ptr(ptr_)
-        {
-        }
+        const_row_info(int x1_, int x2_, const T* ptr_) : 
+            x1(x1_), x2(x2_), ptr(ptr_) {}
     };
 
     //------------------------------------------------------------is_equal_eps
-    template <class T>
-    inline bool is_equal_eps(T v1, T v2, T epsilon)
+    template<class T> inline bool is_equal_eps(T v1, T v2, T epsilon)
     {
-        bool neg1 = v1 < 0.0;
-        bool neg2 = v2 < 0.0;
+	bool neg1 = v1 < 0.0;
+	bool neg2 = v2 < 0.0;
 
-        if (neg1 != neg2)
-            return std::fabs(v1) < epsilon && std::fabs(v2) < epsilon;
+	if (neg1 != neg2)
+	    return std::fabs(v1) < epsilon && std::fabs(v2) < epsilon;
 
         int int1, int2;
-        std::frexp(v1, &int1);
-        std::frexp(v2, &int2);
-        int min12 = int1 < int2 ? int1 : int2;
+	std::frexp(v1, &int1);
+	std::frexp(v2, &int2);
+	int min12 = int1 < int2 ? int1 : int2;
 
-        v1 = std::ldexp(v1, -min12);
-        v2 = std::ldexp(v2, -min12);
+	v1 = std::ldexp(v1, -min12);
+	v2 = std::ldexp(v2, -min12);
 
-        return std::fabs(v1 - v2) < epsilon;
+	return std::fabs(v1 - v2) < epsilon;
     }
 }
 
+
 #endif
+

dep/agg/include/agg_bezier_arc.h

@@ -2,8 +2,8 @@
 // Anti-Grain Geometry - Version 2.4
 // Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
 //
-// Permission to copy, use, modify, sell and distribute this software
-// is granted provided this copyright notice appears in all copies.
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
 // This software is provided "as is" without express or implied
 // warranty, and with no claim as to its suitability for any purpose.
 //
@@ -13,7 +13,7 @@
 //          http://www.antigrain.com
 //----------------------------------------------------------------------------
 //
-// Arc generator. Produces at most 4 consecutive cubic bezier curves, i.e.,
+// Arc generator. Produces at most 4 consecutive cubic bezier curves, i.e., 
 // 4, 7, 10, or 13 vertices.
 //
 //----------------------------------------------------------------------------
@@ -27,42 +27,33 @@ namespace agg
 {
 
     //-----------------------------------------------------------------------
-    void arc_to_bezier(double cx,
-        double cy,
-        double rx,
-        double ry,
-        double start_angle,
-        double sweep_angle,
-        double* curve);
+    void arc_to_bezier(double cx, double cy, double rx, double ry, 
+                       double start_angle, double sweep_angle,
+                       double* curve);
+
 
     //==============================================================bezier_arc
-    //
+    // 
     // See implemantaion agg_bezier_arc.cpp
     //
     class bezier_arc
     {
     public:
         //--------------------------------------------------------------------
-        bezier_arc(): m_vertex(26), m_num_vertices(0), m_cmd(path_cmd_line_to)
-        {
-        }
-        bezier_arc(double x,
-            double y,
-            double rx,
-            double ry,
-            double start_angle,
-            double sweep_angle)
+        bezier_arc() : m_vertex(26), m_num_vertices(0), m_cmd(path_cmd_line_to) {}
+        bezier_arc(double x,  double y, 
+                   double rx, double ry, 
+                   double start_angle, 
+                   double sweep_angle)
         {
             init(x, y, rx, ry, start_angle, sweep_angle);
         }
 
         //--------------------------------------------------------------------
-        void init(double x,
-            double y,
-            double rx,
-            double ry,
-            double start_angle,
-            double sweep_angle);
+        void init(double x,  double y, 
+                  double rx, double ry, 
+                  double start_angle, 
+                  double sweep_angle);
 
         //--------------------------------------------------------------------
         void rewind(unsigned)
@@ -73,85 +64,67 @@ namespace agg
         //--------------------------------------------------------------------
         unsigned vertex(double* x, double* y)
         {
-            if (m_vertex >= m_num_vertices)
-                return path_cmd_stop;
+            if(m_vertex >= m_num_vertices) return path_cmd_stop;
             *x = m_vertices[m_vertex];
             *y = m_vertices[m_vertex + 1];
             m_vertex += 2;
             return (m_vertex == 2) ? unsigned(path_cmd_move_to) : m_cmd;
         }
 
-        // Supplemantary functions. num_vertices() actually returns doubled
+        // Supplemantary functions. num_vertices() actually returns doubled 
         // number of vertices. That is, for 1 vertex it returns 2.
         //--------------------------------------------------------------------
-        unsigned num_vertices() const
-        {
-            return m_num_vertices;
-        }
-        const double* vertices() const
-        {
-            return m_vertices;
-        }
-        double* vertices()
-        {
-            return m_vertices;
-        }
-
+        unsigned  num_vertices() const { return m_num_vertices; }
+        const double* vertices() const { return m_vertices;     }
+        double*       vertices()       { return m_vertices;     }
+ 
     private:
         unsigned m_vertex;
         unsigned m_num_vertices;
-        double m_vertices[26];
+        double   m_vertices[26];
         unsigned m_cmd;
     };
 
+
+
     //==========================================================bezier_arc_svg
-    // Compute an SVG-style bezier arc.
+    // Compute an SVG-style bezier arc. 
     //
-    // Computes an elliptical arc from (x1, y1) to (x2, y2). The size and
-    // orientation of the ellipse are defined by two radii (rx, ry)
-    // and an x-axis-rotation, which indicates how the ellipse as a whole
-    // is rotated relative to the current coordinate system. The center
-    // (cx, cy) of the ellipse is calculated automatically to satisfy the
-    // constraints imposed by the other parameters.
-    // large-arc-flag and sweep-flag contribute to the automatic calculations
+    // Computes an elliptical arc from (x1, y1) to (x2, y2). The size and 
+    // orientation of the ellipse are defined by two radii (rx, ry) 
+    // and an x-axis-rotation, which indicates how the ellipse as a whole 
+    // is rotated relative to the current coordinate system. The center 
+    // (cx, cy) of the ellipse is calculated automatically to satisfy the 
+    // constraints imposed by the other parameters. 
+    // large-arc-flag and sweep-flag contribute to the automatic calculations 
     // and help determine how the arc is drawn.
     class bezier_arc_svg
     {
     public:
         //--------------------------------------------------------------------
-        bezier_arc_svg(): m_arc(), m_radii_ok(false) {}
+        bezier_arc_svg() : m_arc(), m_radii_ok(false) {}
 
-        bezier_arc_svg(double x1,
-            double y1,
-            double rx,
-            double ry,
-            double angle,
-            bool large_arc_flag,
-            bool sweep_flag,
-            double x2,
-            double y2):
-            m_arc(),
-            m_radii_ok(false)
+        bezier_arc_svg(double x1, double y1, 
+                       double rx, double ry, 
+                       double angle,
+                       bool large_arc_flag,
+                       bool sweep_flag,
+                       double x2, double y2) : 
+            m_arc(), m_radii_ok(false)
         {
             init(x1, y1, rx, ry, angle, large_arc_flag, sweep_flag, x2, y2);
         }
 
         //--------------------------------------------------------------------
-        void init(double x1,
-            double y1,
-            double rx,
-            double ry,
-            double angle,
-            bool large_arc_flag,
-            bool sweep_flag,
-            double x2,
-            double y2);
+        void init(double x1, double y1, 
+                  double rx, double ry, 
+                  double angle,
+                  bool large_arc_flag,
+                  bool sweep_flag,
+                  double x2, double y2);
 
         //--------------------------------------------------------------------
-        bool radii_ok() const
-        {
-            return m_radii_ok;
-        }
+        bool radii_ok() const { return m_radii_ok; }
 
         //--------------------------------------------------------------------
         void rewind(unsigned)
@@ -165,27 +138,22 @@ namespace agg
             return m_arc.vertex(x, y);
         }
 
-        // Supplemantary functions. num_vertices() actually returns doubled
+        // Supplemantary functions. num_vertices() actually returns doubled 
         // number of vertices. That is, for 1 vertex it returns 2.
         //--------------------------------------------------------------------
-        unsigned num_vertices() const
-        {
-            return m_arc.num_vertices();
-        }
-        const double* vertices() const
-        {
-            return m_arc.vertices();
-        }
-        double* vertices()
-        {
-            return m_arc.vertices();
-        }
+        unsigned  num_vertices() const { return m_arc.num_vertices(); }
+        const double* vertices() const { return m_arc.vertices();     }
+        double*       vertices()       { return m_arc.vertices();     }
 
     private:
         bezier_arc m_arc;
-        bool m_radii_ok;
+        bool       m_radii_ok;
     };
 
+
+
+
 }
 
+
 #endif

dep/agg/include/agg_bitset_iterator.h

@@ -2,8 +2,8 @@
 // Anti-Grain Geometry - Version 2.4
 // Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
 //
-// Permission to copy, use, modify, sell and distribute this software
-// is granted provided this copyright notice appears in all copies.
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
 // This software is provided "as is" without express or implied
 // warranty, and with no claim as to its suitability for any purpose.
 //
@@ -20,20 +20,19 @@
 
 namespace agg
 {
-
+    
     class bitset_iterator
     {
     public:
-        bitset_iterator(const int8u* bits, unsigned offset = 0):
+        bitset_iterator(const int8u* bits, unsigned offset = 0) :
             m_bits(bits + (offset >> 3)),
             m_mask(0x80 >> (offset & 7))
-        {
-        }
+        {}
 
-        void operator++()
+        void operator ++ ()
         {
             m_mask >>= 1;
-            if (m_mask == 0)
+            if(m_mask == 0)
             {
                 ++m_bits;
                 m_mask = 0x80;
@@ -47,7 +46,7 @@ namespace agg
 
     private:
         const int8u* m_bits;
-        int8u m_mask;
+        int8u        m_mask;
     };
 
 }

dep/agg/include/agg_bounding_rect.h

@@ -2,8 +2,8 @@
 // Anti-Grain Geometry - Version 2.4
 // Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
 //
-// Permission to copy, use, modify, sell and distribute this software
-// is granted provided this copyright notice appears in all copies.
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
 // This software is provided "as is" without express or implied
 // warranty, and with no claim as to its suitability for any purpose.
 //
@@ -25,15 +25,10 @@ namespace agg
 {
 
     //-----------------------------------------------------------bounding_rect
-    template <class VertexSource, class GetId, class CoordT>
-    bool bounding_rect(VertexSource& vs,
-        GetId& gi,
-        unsigned start,
-        unsigned num,
-        CoordT* x1,
-        CoordT* y1,
-        CoordT* x2,
-        CoordT* y2)
+    template<class VertexSource, class GetId, class CoordT>
+    bool bounding_rect(VertexSource& vs, GetId& gi, 
+                       unsigned start, unsigned num, 
+                       CoordT* x1, CoordT* y1, CoordT* x2, CoordT* y2)
     {
         unsigned i;
         double x;
@@ -45,15 +40,15 @@ namespace agg
         *x2 = CoordT(0);
         *y2 = CoordT(0);
 
-        for (i = 0; i < num; i++)
+        for(i = 0; i < num; i++)
         {
             vs.rewind(gi[start + i]);
             unsigned cmd;
-            while (!is_stop(cmd = vs.vertex(&x, &y)))
+            while(!is_stop(cmd = vs.vertex(&x, &y)))
             {
-                if (is_vertex(cmd))
+                if(is_vertex(cmd))
                 {
-                    if (first)
+                    if(first)
                     {
                         *x1 = CoordT(x);
                         *y1 = CoordT(y);
@@ -63,14 +58,10 @@ namespace agg
                     }
                     else
                     {
-                        if (CoordT(x) < *x1)
-                            *x1 = CoordT(x);
-                        if (CoordT(y) < *y1)
-                            *y1 = CoordT(y);
-                        if (CoordT(x) > *x2)
-                            *x2 = CoordT(x);
-                        if (CoordT(y) > *y2)
-                            *y2 = CoordT(y);
+                        if(CoordT(x) < *x1) *x1 = CoordT(x);
+                        if(CoordT(y) < *y1) *y1 = CoordT(y);
+                        if(CoordT(x) > *x2) *x2 = CoordT(x);
+                        if(CoordT(y) > *y2) *y2 = CoordT(y);
                     }
                 }
             }
@@ -78,14 +69,11 @@ namespace agg
         return *x1 <= *x2 && *y1 <= *y2;
     }
 
+
     //-----------------------------------------------------bounding_rect_single
-    template <class VertexSource, class CoordT>
-    bool bounding_rect_single(VertexSource& vs,
-        unsigned path_id,
-        CoordT* x1,
-        CoordT* y1,
-        CoordT* x2,
-        CoordT* y2)
+    template<class VertexSource, class CoordT> 
+    bool bounding_rect_single(VertexSource& vs, unsigned path_id,
+                              CoordT* x1, CoordT* y1, CoordT* x2, CoordT* y2)
     {
         double x;
         double y;
@@ -98,11 +86,11 @@ namespace agg
 
         vs.rewind(path_id);
         unsigned cmd;
-        while (!is_stop(cmd = vs.vertex(&x, &y)))
+        while(!is_stop(cmd = vs.vertex(&x, &y)))
         {
-            if (is_vertex(cmd))
+            if(is_vertex(cmd))
             {
-                if (first)
+                if(first)
                 {
                     *x1 = CoordT(x);
                     *y1 = CoordT(y);
@@ -112,20 +100,17 @@ namespace agg
                 }
                 else
                 {
-                    if (CoordT(x) < *x1)
-                        *x1 = CoordT(x);
-                    if (CoordT(y) < *y1)
-                        *y1 = CoordT(y);
-                    if (CoordT(x) > *x2)
-                        *x2 = CoordT(x);
-                    if (CoordT(y) > *y2)
-                        *y2 = CoordT(y);
+                    if(CoordT(x) < *x1) *x1 = CoordT(x);
+                    if(CoordT(y) < *y1) *y1 = CoordT(y);
+                    if(CoordT(x) > *x2) *x2 = CoordT(x);
+                    if(CoordT(y) > *y2) *y2 = CoordT(y);
                 }
             }
         }
         return *x1 <= *x2 && *y1 <= *y2;
     }
 
+
 }
 
 #endif

dep/agg/include/agg_bspline.h

@@ -2,8 +2,8 @@
 // Anti-Grain Geometry - Version 2.4
 // Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
 //
-// Permission to copy, use, modify, sell and distribute this software
-// is granted provided this copyright notice appears in all copies.
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
 // This software is provided "as is" without express or implied
 // warranty, and with no claim as to its suitability for any purpose.
 //
@@ -26,49 +26,51 @@ namespace agg
 {
     //----------------------------------------------------------------bspline
     // A very simple class of Bi-cubic Spline interpolation.
-    // First call init(num, x[], y[]) where num - number of source points,
-    // x, y - arrays of X and Y values respectively. Here Y must be a function
-    // of X. It means that all the X-coordinates must be arranged in the
-    // ascending order. Then call get(x) that calculates a value Y for the
-    // respective X. The class supports extrapolation, i.e. you can call get(x)
-    // where x is outside the given with init() X-range. Extrapolation is a
-    // simple linear function.
+    // First call init(num, x[], y[]) where num - number of source points, 
+    // x, y - arrays of X and Y values respectively. Here Y must be a function 
+    // of X. It means that all the X-coordinates must be arranged in the ascending
+    // order. 
+    // Then call get(x) that calculates a value Y for the respective X. 
+    // The class supports extrapolation, i.e. you can call get(x) where x is
+    // outside the given with init() X-range. Extrapolation is a simple linear 
+    // function.
     //
     //  See Implementation agg_bspline.cpp
     //------------------------------------------------------------------------
-    class bspline
+    class bspline 
     {
     public:
         bspline();
         bspline(int num);
         bspline(int num, const double* x, const double* y);
 
-        void init(int num);
-        void add_point(double x, double y);
-        void prepare();
+        void   init(int num);
+        void   add_point(double x, double y);
+        void   prepare();
 
-        void init(int num, const double* x, const double* y);
+        void   init(int num, const double* x, const double* y);
 
         double get(double x) const;
         double get_stateful(double x) const;
-
+    
     private:
         bspline(const bspline&);
-        const bspline& operator=(const bspline&);
+        const bspline& operator = (const bspline&);
 
-        static void bsearch(int n, const double* x, double x0, int* i);
+        static void bsearch(int n, const double *x, double x0, int *i);
         double extrapolation_left(double x) const;
         double extrapolation_right(double x) const;
         double interpolation(double x, int i) const;
 
-        int m_max;
-        int m_num;
-        double* m_x;
-        double* m_y;
+        int               m_max;
+        int               m_num;
+        double*           m_x;
+        double*           m_y;
         pod_array<double> m_am;
-        mutable int m_last_idx;
+        mutable int       m_last_idx;
     };
 
+
 }
 
 #endif

dep/agg/include/agg_clip_liang_barsky.h

@@ -2,8 +2,8 @@
 // Anti-Grain Geometry - Version 2.4
 // Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
 //
-// Permission to copy, use, modify, sell and distribute this software
-// is granted provided this copyright notice appears in all copies.
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
 // This software is provided "as is" without express or implied
 // warranty, and with no claim as to its suitability for any purpose.
 //
@@ -13,7 +13,7 @@
 //          http://www.antigrain.com
 //----------------------------------------------------------------------------
 //
-// Liang-Barsky clipping
+// Liang-Barsky clipping 
 //
 //----------------------------------------------------------------------------
 #ifndef AGG_CLIP_LIANG_BARSKY_INCLUDED
@@ -31,14 +31,12 @@ namespace agg
         clipping_flags_x2_clipped = 1,
         clipping_flags_y1_clipped = 8,
         clipping_flags_y2_clipped = 2,
-        clipping_flags_x_clipped =
-            clipping_flags_x1_clipped | clipping_flags_x2_clipped,
-        clipping_flags_y_clipped =
-            clipping_flags_y1_clipped | clipping_flags_y2_clipped
+        clipping_flags_x_clipped = clipping_flags_x1_clipped | clipping_flags_x2_clipped,
+        clipping_flags_y_clipped = clipping_flags_y1_clipped | clipping_flags_y2_clipped
     };
 
     //----------------------------------------------------------clipping_flags
-    // Determine the clipping code of the vertex according to the
+    // Determine the clipping code of the vertex according to the 
     // Cyrus-Beck line clipping algorithm
     //
     //        |        |
@@ -54,37 +52,42 @@ namespace agg
     //        |        |
     //  clip_box.x1  clip_box.x2
     //
-    //
-    template <class T>
+    // 
+    template<class T>
     inline unsigned clipping_flags(T x, T y, const rect_base<T>& clip_box)
     {
-        return (x > clip_box.x2) | ((y > clip_box.y2) << 1) |
-               ((x < clip_box.x1) << 2) | ((y < clip_box.y1) << 3);
+        return  (x > clip_box.x2) |
+               ((y > clip_box.y2) << 1) |
+               ((x < clip_box.x1) << 2) |
+               ((y < clip_box.y1) << 3);
     }
 
     //--------------------------------------------------------clipping_flags_x
-    template <class T>
+    template<class T>
     inline unsigned clipping_flags_x(T x, const rect_base<T>& clip_box)
     {
-        return (x > clip_box.x2) | ((x < clip_box.x1) << 2);
+        return  (x > clip_box.x2) | ((x < clip_box.x1) << 2);
     }
 
+
     //--------------------------------------------------------clipping_flags_y
-    template <class T>
+    template<class T>
     inline unsigned clipping_flags_y(T y, const rect_base<T>& clip_box)
     {
         return ((y > clip_box.y2) << 1) | ((y < clip_box.y1) << 3);
     }
 
+
     //-------------------------------------------------------clip_liang_barsky
-    template <class T>
-    inline unsigned clip_liang_barsky(
-        T x1, T y1, T x2, T y2, const rect_base<T>& clip_box, T* x, T* y)
+    template<class T>
+    inline unsigned clip_liang_barsky(T x1, T y1, T x2, T y2,
+                                      const rect_base<T>& clip_box,
+                                      T* x, T* y)
     {
         const double nearzero = 1e-30;
 
         double deltax = x2 - x1;
-        double deltay = y2 - y1;
+        double deltay = y2 - y1; 
         double xin;
         double xout;
         double yin;
@@ -92,52 +95,52 @@ namespace agg
         double tinx;
         double tiny;
         double toutx;
-        double touty;
+        double touty;  
         double tin1;
         double tin2;
         double tout1;
         unsigned np = 0;
 
-        if (deltax == 0.0)
-        {
+        if(deltax == 0.0) 
+        {   
             // bump off of the vertical
             deltax = (x1 > clip_box.x1) ? -nearzero : nearzero;
         }
 
-        if (deltay == 0.0)
-        {
-            // bump off of the horizontal
+        if(deltay == 0.0) 
+        { 
+            // bump off of the horizontal 
             deltay = (y1 > clip_box.y1) ? -nearzero : nearzero;
         }
-
-        if (deltax > 0.0)
-        {
+        
+        if(deltax > 0.0) 
+        {                
             // points to right
-            xin = clip_box.x1;
+            xin  = clip_box.x1;
             xout = clip_box.x2;
         }
-        else
+        else 
         {
-            xin = clip_box.x2;
+            xin  = clip_box.x2;
             xout = clip_box.x1;
         }
 
-        if (deltay > 0.0)
+        if(deltay > 0.0) 
         {
             // points up
-            yin = clip_box.y1;
+            yin  = clip_box.y1;
             yout = clip_box.y2;
         }
-        else
+        else 
         {
-            yin = clip_box.y2;
+            yin  = clip_box.y2;
             yout = clip_box.y1;
         }
-
+        
         tinx = (xin - x1) / deltax;
         tiny = (yin - y1) / deltay;
-
-        if (tinx < tiny)
+        
+        if (tinx < tiny) 
         {
             // hits x first
             tin1 = tinx;
@@ -149,35 +152,35 @@ namespace agg
             tin1 = tiny;
             tin2 = tinx;
         }
-
-        if (tin1 <= 1.0)
+        
+        if(tin1 <= 1.0) 
         {
-            if (0.0 < tin1)
+            if(0.0 < tin1) 
             {
                 *x++ = (T)xin;
                 *y++ = (T)yin;
                 ++np;
             }
 
-            if (tin2 <= 1.0)
+            if(tin2 <= 1.0)
             {
                 toutx = (xout - x1) / deltax;
                 touty = (yout - y1) / deltay;
-
+                
                 tout1 = (toutx < touty) ? toutx : touty;
-
-                if (tin2 > 0.0 || tout1 > 0.0)
+                
+                if(tin2 > 0.0 || tout1 > 0.0) 
                 {
-                    if (tin2 <= tout1)
+                    if(tin2 <= tout1) 
                     {
-                        if (tin2 > 0.0)
+                        if(tin2 > 0.0) 
                         {
-                            if (tinx > tiny)
+                            if(tinx > tiny) 
                             {
                                 *x++ = (T)xin;
                                 *y++ = (T)(y1 + tinx * deltay);
                             }
-                            else
+                            else 
                             {
                                 *x++ = (T)(x1 + tiny * deltax);
                                 *y++ = (T)yin;
@@ -185,34 +188,34 @@ namespace agg
                             ++np;
                         }
 
-                        if (tout1 < 1.0)
+                        if(tout1 < 1.0) 
                         {
-                            if (toutx < touty)
+                            if(toutx < touty) 
                             {
                                 *x++ = (T)xout;
                                 *y++ = (T)(y1 + toutx * deltay);
                             }
-                            else
+                            else 
                             {
                                 *x++ = (T)(x1 + touty * deltax);
                                 *y++ = (T)yout;
                             }
                         }
-                        else
+                        else 
                         {
                             *x++ = x2;
                             *y++ = y2;
                         }
                         ++np;
                     }
-                    else
+                    else 
                     {
-                        if (tinx > tiny)
+                        if(tinx > tiny) 
                         {
                             *x++ = (T)xin;
                             *y++ = (T)yout;
                         }
-                        else
+                        else 
                         {
                             *x++ = (T)xout;
                             *y++ = (T)yin;
@@ -225,44 +228,38 @@ namespace agg
         return np;
     }
 
+
     //----------------------------------------------------------------------------
-    template <class T>
-    bool clip_move_point(T x1,
-        T y1,
-        T x2,
-        T y2,
-        const rect_base<T>& clip_box,
-        T* x,
-        T* y,
-        unsigned flags)
+    template<class T>
+    bool clip_move_point(T x1, T y1, T x2, T y2, 
+                         const rect_base<T>& clip_box, 
+                         T* x, T* y, unsigned flags)
     {
-        T bound;
+       T bound;
 
-        if (flags & clipping_flags_x_clipped)
-        {
-            if (x1 == x2)
-            {
-                return false;
-            }
-            bound =
-                (flags & clipping_flags_x1_clipped) ? clip_box.x1 : clip_box.x2;
-            *y = (T)(double(bound - x1) * (y2 - y1) / (x2 - x1) + y1);
-            *x = bound;
-        }
+       if(flags & clipping_flags_x_clipped)
+       {
+           if(x1 == x2)
+           {
+               return false;
+           }
+           bound = (flags & clipping_flags_x1_clipped) ? clip_box.x1 : clip_box.x2;
+           *y = (T)(double(bound - x1) * (y2 - y1) / (x2 - x1) + y1);
+           *x = bound;
+       }
 
-        flags = clipping_flags_y(*y, clip_box);
-        if (flags & clipping_flags_y_clipped)
-        {
-            if (y1 == y2)
-            {
-                return false;
-            }
-            bound =
-                (flags & clipping_flags_y1_clipped) ? clip_box.y1 : clip_box.y2;
-            *x = (T)(double(bound - y1) * (x2 - x1) / (y2 - y1) + x1);
-            *y = bound;
-        }
-        return true;
+       flags = clipping_flags_y(*y, clip_box);
+       if(flags & clipping_flags_y_clipped)
+       {
+           if(y1 == y2)
+           {
+               return false;
+           }
+           bound = (flags & clipping_flags_y1_clipped) ? clip_box.y1 : clip_box.y2;
+           *x = (T)(double(bound - y1) * (x2 - x1) / (y2 - y1) + x1);
+           *y = bound;
+       }
+       return true;
     }
 
     //-------------------------------------------------------clip_line_segment
@@ -270,29 +267,29 @@ namespace agg
     //          (ret & 1) != 0  - First point has been moved
     //          (ret & 2) != 0  - Second point has been moved
     //
-    template <class T>
-    unsigned clip_line_segment(
-        T* x1, T* y1, T* x2, T* y2, const rect_base<T>& clip_box)
+    template<class T>
+    unsigned clip_line_segment(T* x1, T* y1, T* x2, T* y2,
+                               const rect_base<T>& clip_box)
     {
         unsigned f1 = clipping_flags(*x1, *y1, clip_box);
         unsigned f2 = clipping_flags(*x2, *y2, clip_box);
         unsigned ret = 0;
 
-        if ((f2 | f1) == 0)
+        if((f2 | f1) == 0)
         {
             // Fully visible
             return 0;
         }
 
-        if ((f1 & clipping_flags_x_clipped) != 0 &&
-            (f1 & clipping_flags_x_clipped) == (f2 & clipping_flags_x_clipped))
+        if((f1 & clipping_flags_x_clipped) != 0 && 
+           (f1 & clipping_flags_x_clipped) == (f2 & clipping_flags_x_clipped))
         {
             // Fully clipped
             return 4;
         }
 
-        if ((f1 & clipping_flags_y_clipped) != 0 &&
-            (f1 & clipping_flags_y_clipped) == (f2 & clipping_flags_y_clipped))
+        if((f1 & clipping_flags_y_clipped) != 0 && 
+           (f1 & clipping_flags_y_clipped) == (f2 & clipping_flags_y_clipped))
         {
             // Fully clipped
             return 4;
@@ -302,25 +299,25 @@ namespace agg
         T ty1 = *y1;
         T tx2 = *x2;
         T ty2 = *y2;
-        if (f1)
-        {
-            if (!clip_move_point(tx1, ty1, tx2, ty2, clip_box, x1, y1, f1))
+        if(f1) 
+        {   
+            if(!clip_move_point(tx1, ty1, tx2, ty2, clip_box, x1, y1, f1)) 
             {
                 return 4;
             }
-            if (*x1 == *x2 && *y1 == *y2)
+            if(*x1 == *x2 && *y1 == *y2) 
             {
                 return 4;
             }
             ret |= 1;
         }
-        if (f2)
+        if(f2) 
         {
-            if (!clip_move_point(tx1, ty1, tx2, ty2, clip_box, x2, y2, f2))
+            if(!clip_move_point(tx1, ty1, tx2, ty2, clip_box, x2, y2, f2))
             {
                 return 4;
             }
-            if (*x1 == *x2 && *y1 == *y2)
+            if(*x1 == *x2 && *y1 == *y2) 
             {
                 return 4;
             }
@@ -329,6 +326,8 @@ namespace agg
         return ret;
     }
 
+
 }
 
+
 #endif