Clack-BASIC Compiler & 16-Bit Relais-Architektur

Clack-BASIC bietet wesentlich mehr Sprachoperationen, als die Relais-CPU hardwaremäßig besitzt. Die physische ALU beherrscht ausschließlich ADD, AND, OR, NOT, SHL und SHR. Es gibt keine Hardware-Befehle für Multiplikation (*), Division (/), Subtraktion oder direkte Vergleiche (CMP). Der Compiler übersetzt diese Funktionen in ausgeklügelte Software-Routinen (Multiplikation via Shift-and-Add __mul, Division via wiederholte Subtraktion, Subtraktion via Zweierkomplement NOT + 1 + ADD).

🧮 Numerische Architektur: Q8.8 Festkomma (FIXED8) & Zuse-Style Gleitkomma (CLACK-F16)

Da der 16-Bit Relaiscomputer keinen Hardware-Barrel-Shifter besitzt (jeder SHL/SHR schiebt exakt 1 Bit in 4 Mikroprogramm-Schritten ≈ 280 ms) und das Hardware-Return-Register SR physisch nur eine einzige Rücksprungebene speichert, stellt der Clack-BASIC Compiler zwei komplementäre 16-Bit Kommazahlen-Formate bereit. Über den Lazy Runtime Linker werden mathematische Laufzeitroutinen nur dann in das 1024-Worte-RAM eingebunden, wenn sie im Programm tatsächlich aufgerufen werden:

• Warum Zuse-Style S1-E7-M8 statt IEEE 754 binary16? Exponent (Bits 14..8) und Mantisse (Bits 7..0) liegen exakt auf Byte-Grenzen, und das Produkt zweier 9-Bit-Mantissen passt bei schrittweiser Shift-Addition direkt in den 16-Bit-Akkumulator – ganz ohne teure 32-Bit-Doppelwort-Arithmetik im RAM.
• Sonderfall- & Sättigungspolitik: Die kanonische Null ist 0x0000 (1.0 = 0x3F00, -1.0 = 0xBF00, 1.5 = 0x3F80, 3.75 = 0x40E0). Bei Überlauf (Overflow) sättigen sowohl Q8.8 als auch CLACK-F16 definiert auf den maximalen darstellbaren Betrag (0x7FFF bzw. 0xFFFF); bei Unterflow geht CLACK-F16 sauber auf 0x0000.
• Automatische Typ-Promotion & 1-Level SR-Garantie: Gemischte Ausdrücke zwischen INT16 und Kommazahlen werden vom Compiler automatisch konvertiert (Konstanten zur Compile-Zeit, Variablen via __f16_itof bzw. 8-Bit-Shift). Sämtliche FPU-Routinen teilen sich einen gemeinsamen Normierungs- und Pack-Block per direktem Sprung (BA) und belegen niemals mehr als die 1 physische Hardware-CALL-Ebene des SR-Registers.

10 REM ========================================================
20 REM CLACK-BASIC: Q8.8 FESTKOMMA & CLACK-F16 GLEITKOMMA DEMO
30 REM ========================================================
40 REM 1. Schnelles Q8.8 Festkomma (Addition direkt in 2 ALU-Befehlen!)
50 DIM AX, BX, CX AS FIXED8
60 AX = 1.5
70 BX = 2.25
80 CX = (AX + BX) * 2.0
90 R_FIXED = FTOI(CX)
100 PRINT "Q8.8 (1.5 + 2.25) * 2.0 -> INT = "; R_FIXED
110 REM --------------------------------------------------------
120 REM 2. CLACK-F16 Gleitkomma (S1-E7-M8) mit #-Suffix & Mixed-Int
130 X# = 1.5
140 Y# = 2.25
150 OFFSET = 4
160 Z# = (X# * Y#) + OFFSET
170 IF Z# > 7.0 THEN R_FLOAT = FTOI(Z#)
180 PRINT "CLACK-F16 (1.5 * 2.25) + 4 -> INT = "; R_FLOAT
190 END

📐 Technischer Deep-Dive: Die divisionsfreie Wurzelfunktion in v1.5.5

Da ein Relaiscomputer für eine Ganzzahl-Division bis zu 32 Zyklen mit Relais-Klickfolgen benötigt, implementiert Clack-BASIC v1.5.5 das Wurzelziehen als divisionsfreien 8-Schritt Bit-für-Bit Algorithmus (Shift-and-Subtract). Für 16-Bit Ganzzahlen benötigt die Berechnung exakt 8 feste Iterationsstufen:

10 REM ========================================================
20 REM CLACK-BASIC v1.5.5 SQR DEMO // 16-BIT RELAISCOMPUTER
30 REM ========================================================
40 CLS
50 PRINT "TEST 1: GANZZAHLIGE WURZELN"
60 FOR X = 1 TO 10
70   Y = SQR(X * X)
80   PRINT "SQRT("; X * X; ") = "; Y
90 NEXT X
100 PRINT "----------------------------------------"
110 PRINT "TEST 2: HOCHPRÄZISE FESTKOMMA-WURZEL"
120 REM SQR(2, 2) berechnet Wurzel 2 mit 2 Nachkommastellen (x100)
130 F = SQR(2, 2)
140 W_INT = F / 100
150 W_DEC = F MOD 100
160 PRINT "SQRT(2) = "; W_INT; "."; W_DEC; " (ERGEBNIS: 1.41)"
170 END

🌌 1. Mandelbrot-Fraktal auf 32×32 Relais-Matrix

Dieses Programm läuft real auf Peter's 16-Bit Relaiscomputer! Es berechnet die Mandelbrot-Menge mittels 16-Bit Festkomma-Arithmetik (Skalierungsfaktor 256) und schaltet die Relais der 32×32 LED-Matrix entsprechend ein.

10 REM ========================================================
20 REM MANDELBROT-MENGE 32x32 FUER PETER'S RELAISCOMPUTER
30 REM 16-Bit Festkomma-Arithmetik (Skalierung: 256 = 1.0)
40 REM ========================================================
50 CLS
60 MAXITER = 16
70 FOR Y = 0 TO 31
80   CI = (Y - 16) * 16
90   FOR X = 0 TO 31
100    CR = (X - 22) * 16
110    ZR = 0
120    ZI = 0
130    FOR I = 1 TO MAXITER
140      ZR2 = (ZR * ZR) / 256
150      ZI2 = (ZI * ZI) / 256
160      IF (ZR2 + ZI2) > 1024 THEN GOTO 220
170      ZI = (ZR * ZI) / 128 + CI
180      ZR = ZR2 - ZI2 + CR
190    NEXT I
200    PSET(X, Y, 1)
210    GOTO 230
220    PSET(X, Y, 0)
230  NEXT X
240 NEXT Y
250 END

Reales Ergebnis auf Peter's 32×32 Relais-Display

Das Foto zeigt das originale LED-Anzeigefeld des Relaiscomputers nach Durchlauf der obigen Mandelbrot-Berechnung. Die Apfelmännchen-Struktur ist auf den 1024 Relaispunkten scharf erkennbar!

📊 2. Datentabellen & Haltepunkte: DATA, READ, RESTORE & STOP

Demonstriert die sequentielle Werteabarbeitung aus dem Programmspeicher sowie den programmierten CPU-Haltepunkt (STOP) zur Register- und Speicherinspektion.

10 REM ========================================================
20 REM CLACK-BASIC: DATA, READ, RESTORE & STOP DEMO
30 REM ========================================================
40 CLS
50 PRINT "LESE DATENTABELLE EIN:"
60 FOR I = 1 TO 4
70   READ V
80   PRINT "WERT "; I; " = "; V
90 NEXT I
100 PRINT "PROGRAMMIERTER HALTEPUNKT (STOP)..."
110 STOP : REM Hier stoppt die CPU; Register koennen inspiziert werden!
120 PRINT "SETZE DATENZEIGER ZURUECK (RESTORE)..."
130 RESTORE
140 READ FIRST_VAL
150 PRINT "ERSTER WERT ERNEUT GELESEN: "; FIRST_VAL
160 DATA 100, 250, 42, 888
170 END

💻 Clack CLI Schnellstart

Nach dem Download kann der Compiler direkt im Terminal ausgeführt werden:

# Ausführungsrechte vergeben (unter Linux / macOS)
chmod +x clack-linux-amd64

# BASIC Programm kompilieren zu Relais-Maschinencode
./clack-linux-amd64 build mandelbrot.bas -o mandelbrot.bin

# Programm im virtuellen 16-Bit Emulator ausführen
./clack-linux-amd64 run mandelbrot.bas

# Maschinencode disassemblieren
./clack-linux-amd64 disasm mandelbrot.bin