Modifier

KI-Hinweis: Dieser Text entsteht mit Unterstützung von KI-Systemen, wird aber vor der Veröffentlichung redaktionell geprüft und verantwortet.

Der Modifier ist das Kürzel hinter dem Punkt: MOV.I, ADD.AB, SEQ.F. Er legt fest, welche Felder einer Instruktion gelesen und geschrieben werden.

Er wirkt unscheinbar. Tatsächlich bestimmt er die Bedeutung einer Instruktion stärker als der Opcode davor — zwei Zeichen Unterschied entscheiden regelmäßig zwischen einem funktionierenden und einem toten Warrior.

Die sieben Modifier

Jede Instruktion hat zwei Felder, A und B. Bei einer Operation gibt es eine Quelle (der A-Operand) und ein Ziel (der B-Operand). Der Modifier sagt, welches Feld der Quelle in welches Feld des Ziels wirkt:

Modifier	Quelle → Ziel
`.A`	A → A
`.B`	B → B
`.AB`	A → B
`.BA`	B → A
`.F`	A → A und B → B
`.X`	A → B und B → A (über Kreuz)
`.I`	die ganze Instruktion, samt Opcode und Adressierungsmodi

Am häufigsten verwechselt werden .AB und .BA sowie .F und .X. Merkhilfe: Bei .AB und .BA steht der erste Buchstabe für die Quelle, der zweite für das Ziel. .F ist „flach" (jedes Feld bleibt bei seinesgleichen), .X ist „über Kreuz".

Nachgeprüft

Diese Tabelle ist nicht abgeschrieben, sondern gemessen. Der Test setzt eine Quelle auf #1, #2, führt die Operation auf eine leere Zielzelle aus und vergleicht das Ergebnis mit dem erwarteten Wert:

Operation	Ziel vorher	Ziel nachher	bestätigt
`MOV.A`	`#0, #0`	`#1, #0`	✓
`MOV.B`	`#0, #0`	`#0, #2`	✓
`MOV.AB`	`#0, #0`	`#0, #1`	✓
`MOV.BA`	`#0, #0`	`#2, #0`	✓
`MOV.F`	`#0, #0`	`#1, #2`	✓
`MOV.X`	`#0, #0`	`#2, #1`	✓

Zur Kontrolle wurde derselbe Test mit absichtlich falschen Erwartungswerten wiederholt — dort scheitert er in allen Runden. Der Test unterscheidet also tatsächlich, statt nur zuzustimmen.

`.I` ist ein Sonderfall

.I überträgt die vollständige Instruktion: beide Felder, beide Adressierungsmodi und den Opcode.

Das macht es zum einzigen Modifier, mit dem sich ausführbarer Code bewegen lässt. Alle anderen bewegen nur Zahlen und lassen den Opcode der Zielzelle unverändert — die Zielzelle bleibt also, was sie war, meistens ein DAT.

Wie groß der Unterschied ist, zeigt der Imp. Derselbe Warrior, nur der Modifier geändert, jeweils 2000 Runden:

Variante	Punkte
`MOV.I $0, $1`	74,5
`MOV.A`, `.B`, `.AB`, `.BA`, `.F`, `.X`	0,0 (je 2000 Niederlagen)

Ein Imp mit .F kopiert brav beide Zahlenfelder in die Nachbarzelle — aber dort steht weiterhin DAT. Er schreibt sich sein eigenes Grab und läuft im nächsten Zyklus hinein.

Bei Rechenbefehlen gibt es .I faktisch nicht. ADD.I verhält sich wie ADD.F — nachgemessen. Das ist sinnvoll, denn einen Opcode zu addieren ergibt keine Bedeutung.

Welcher Modifier wozu

Situation	Üblich	Warum
Code kopieren, bomben mit ganzen Instruktionen	`.I`	einziger Modifier, der den Opcode überträgt
Zeiger um eine Konstante versetzen	`.AB`	Konstante steht als `#` im A-Feld, Ziel im B-Feld
zwei Zeiger gleichzeitig fortschreiben	`.F`	beide Felder in einem Zug
Scannen	`.I` oder `.F`	`.I` genauer, `.F` schneller zu formulieren
Bereichsprüfung mit `SLT`	`.AB`	Grenzwert unmittelbar, Prüfwert im B-Feld

Beim Vergleichen lohnt der Unterschied zwischen .I und .F eine Überlegung: .I vergleicht die vollständige Instruktion und erkennt deshalb auch Unterschiede im Opcode. .F vergleicht nur die beiden Zahlenfelder — zwei Zellen mit gleichen Zahlen, aber verschiedenen Opcodes gelten dort als identisch. Für einen Scanner kann das der Unterschied zwischen Fund und Nichtfund sein.

Wenn du keinen schreibst

Lässt du den Modifier weg, ergänzt der Assembler einen — nach festen Regeln, die vom Opcode und vom Modus des A-Operanden abhängen. Die vollständige Tabelle steht unter Befehlssatz.

Zwei Stellen, an denen die Voreinstellung überrascht:

SLT ohne # wird zu .B, nicht zu .F wie die anderen Rechenbefehle.
Sprungbefehle ignorieren den A-Modus komplett — DJN #1, $2 wird .B, obwohl im A-Operanden ein unmittelbarer Wert steht.

Die Empfehlung bleibt: Schreib den Modifier immer selbst hin. Nicht weil die Voreinstellungen falsch wären, sondern weil sie unsichtbar sind — und ein Fehler, dessen Ursache gar nicht im Quelltext steht, kostet mehr Zeit als das Tippen von zwei Zeichen.