kind: reference

MiniC: C für die MiniCPU

Programme in .c-Dateien schreibst du in MiniC, einem kleinen C, das die Sandbox schon beim Tippen in Assembler für die MiniCPU übersetzt. Was es gibt, was anders ist als in C, und wie der erzeugte Code aussieht.

1. Ein Programm in C

Nichts bleibt verborgen: Der Rand des Editors zeigt Adresse und Bytes jeder C-Zeile, und der Reiter Assembly über dem Editor zeigt das erzeugte Programm, jedes Stück unter seiner C-Zeile als Kommentar. Ausführen und Einzelschritte funktionieren wie bei Assembler; ein Schritt ist ein Befehl, und die C-Zeile, zu der er gehört, ist markiert.

// die Stufe (ohne Angabe 8X) und der Bildschirm, wie .display
#pragma cpu 8x
#pragma display 0x0800, 64, 48, mono

int squares[10];

int square(int n) {
    return n * n;
}

void main() {
    for (int i = 0; i < 10; i++)
        squares[i] = square(i);
    out(NUMBER, squares[9]);            // 81 auf der Zahlenanzeige
}

Der Reiter Assembly: das von MiniC erzeugte Programm, jede C-Zeile als Kommentar über ihren Befehlen, links Adressen und Bytes.

Das Menü »CPU« ändert die Zeile #pragma cpu.

2. Was es gibt

Typen char (8 Bit, 0–255), int (mit Vorzeichen), unsigned int, void, Zeiger, Arrays. int und Zeiger haben auf der 8X 16 Bit, auf der 8 und 8S 8 Bit.
Anweisungen if/else, while, do/while, for, break, continue, return, Blöcke; Variablen überall in einem Block.
Operatoren + - * / % & | ^ ~ << >> ! && || == != < <= > >= ?: = += -= … ++ -- & * [], Typumwandlungen, sizeof
Werte 42, 0x2A, 0b101010, 'A', "Texte" (mit \n, \0, \xHH)
Präprozessor #define NAME wert, #define NAME(a, b) …, #undef, #pragma cpu, #pragma display
Geräte in(port) gibt ein char zurück, out(port, wert) schreibt eins. Vordefiniert: JOYSTICK KEYBOARD TIMER RANDOM VSYNC KEYS SPEAKER NUMBER SCREEN_PAGE PALETTE COLOR NOTE_LENGTH, KEY_SHIFT, JOY_LEFT JOY_RIGHT JOY_UP JOY_DOWN JOY_FIRE, NULL true false (Geräte)
Assembler asm("INC A"); fügt Befehle ein, einen pro Zeile: asm("loop:\n" "DEC A\n" "JNZ loop"); Marken und ;-Kommentare wie im Assembler.

3. Anders als C, mit Absicht

  • char rechnet mit 8 Bit, wie die Register: Für zwei char ist 200 + 100 gleich 44. Sobald ein int dabei ist, wird in int gerechnet; eine Zahl nimmt den Typ des anderen Werts an, wenn sie hineinpasst. (int)a + b rechnet eine char-Summe ohne Überlauf. Ebenso ist -c ein char (aus −9 wird 247), für eine negative Zahl also -(int)c. Der Compiler warnt in diesen Fällen.
  • Arrays stehen außerhalb von Funktionen, und & funktioniert nur bei globalen Variablen. Lokale Variablen liegen auf dem Stack und werden mit [SP+n] erreicht, aber kein Befehl kopiert SP in ein Register, also lässt sich ihre Adresse nicht berechnen.
  • Es gibt kein struct, union, enum, switch, goto, typedef, keine Kommazahlen, kein long und kein #include. Statt Kommazahlen nimmt man Festkommazahlen, etwa 64 für 1,0 in 18-cube.c.
  • Die MiniCPU 8 hat keinen Stack: Ein Programm hat dort nur main, seine lokalen Variablen werden global, und *, /, % (außer mit Zweierpotenzen) und Schieben um eine variable Anzahl Bits gibt es nicht, weil sie Hilfsroutinen brauchen.

4. Der erzeugte Code

  • Der Wert eines Ausdrucks landet in A (8 Bit) oder X (16 Bit). Bei zwei Operanden wird zuerst der linke berechnet; ist der rechte keine Zahl und keine Variable, wartet der linke so lange auf dem Stack.
  • Funktionen halten sich an die Aufrufregeln der MiniCPU 8S: Der Aufrufer legt die Argumente von links nach rechts mit PUSH ab und ruft mit CALL; die Funktion beginnt mit SUB SP, n für ihre lokalen Variablen und erreicht sie und die Argumente mit [SP+n]. Das Ergebnis kommt in A oder X zurück. Jeder Aufruf darf A bis D, X und Y verändern.
  • Globale Variablen sind Marken mit Unterstrich (_score) hinter dem Code, Texte heißen string_1, … Schleifen und Verzweigungen verwenden Marken wie while_3.
  • *, /, % und Schieben um eine variable Anzahl Bits rufen Hilfsroutinen auf (mul16, divs16, sar16, …), die nur angehängt werden, wenn das Programm sie braucht. Mal und geteilt durch Zweierpotenzen werden zu Schiebebefehlen. >> 8 nimmt einfach das obere Byte, deshalb sind 8.8-Festkommazahlen billig.
  • table[1024 + i] zählt 1024 schon beim Übersetzen zur Adresse von table. Ein char-Index läuft trotzdem über: a[c + 1] mit c = 255 ist a[0]; a[(int)c + 1] ist a[256].
  • Das Programm beginnt mit CALL _main und hält an, wenn main zurückkehrt.

Auf der 8S und 8X wächst der Stack vom Ende des RAMs nach unten. Ein Programm, das das ganze RAM füllt, lässt ihm keinen Platz; der Compiler warnt, wenn weniger als 32 Bytes übrig sind.

5. Zum Nachschlagen

MiniC gibt es nur in der CPU Sandbox; diese Seite ist seine Referenz. Dazu: