Das Schneider CPC Systembuch

Das Betriebssystem des Schneider CPC

Die Aufteilung des RAMs im Schneider CPC

Jedes Programm, das im Schneider CPC laufen soll, muss hier auf einige Gegebenheiten Rücksich nehmen, die vom Betriebssystem vorgezeichnet sind. Ausgenommen davon bleiben wirklich nur Programme, die keine einzige Routine des Betriebssystems benutzen.

Nicht betroffen sind natürlich auch Programme, die in einer höheren Programmiersprache, also beispielsweise auch in Einleitung: BASIC
Anhang: Basic
Basic
geschrieben sind. Hier muss sich der Interpreter bzw. der Compiler darum kümmern, dass die Speicheraufteilung durch ein Vordergrund-Programm: Speicher-Aufteilung totalSpeicher-Aufteilung eingehalten wird.

Grundsätzlich ist die Verteilung der normalen RAM-Bank (und nur um die dreht es sich hier) so geregelt, dass Die Anschlussbelegungen der wichtigsten ICs im CPC: Das RAM 4164das RAM von unten her ab Adresse &0000 und von oben her ab Adresse &FFFF für verschiedene Aufgaben reserviert wird und in der Mitte ein freier Bereich bleibt, der Memory Pool.

Speicherbelegung durch das Betriebssystem

Wird ein Vordergrund-Programm gestartet (Beispielsweise der Basic-Interpreter, Einleitung: CP/MCP/M oder ein Spiel in Maschinensprache), so reserviert sich das Betriebssystem oben und unten einen RAM-Bereich und übergibt dem Programm drei Zeiger, die auf die Unter- und Obergrenze des Memory-Pools zeigen:

BC = &B0FF --> letztes Datentypen: Bytes
Datenbreite: Bytes
Byte
des Memory Pools (total) HL = &ABFF --> letztes Datentypen: Bytes
Datenbreite: Bytes
Byte
des Memory Pools (Vorschlag) DE = &0040 --> erstes Datentypen: Bytes
Datenbreite: Bytes
Byte
des Memory Pools

Diese Zeiger enthalten dabei IMMER die selben Adressen. Der Sinn dieser Zeiger wird später klarer, wenn die Aufteilung, die der Basic-Interpreter in seinem RAM vornimmt, besprochen wird.

Das RAM bis &003F

In diesem Bereich liegen die Restart-Unterprogramme der Die ICs im Überblick: Die CPU Z80
Das Innenleben der CPC-Rechner: Die CPU Z80
Die Anschlussbelegungen der wichtigsten ICs im CPC: Die CPU Z80
Z80
. Er wird im Schneider CPC der 'Überblick: LOW KERNEL JUMPBLOCK
Die Firmware des Schneider CPC: LOW KERNEL JUMPBLOCK
LOW KERNEL JUMPBLOCK
' genannt, weil fast alle ROM-Konfiguration: RestartsRestarts spezielle Grundlagen: UnterprogrammeUnterprogramme des MAIN FIRMWARE JUMPBLOCK: KERNEL
Die Firmware des Schneider CPC: KERNEL
Kernel
aufrufen, die den Befehlssatz der Die ICs im Überblick: Die CPU Z80
Das Innenleben der CPC-Rechner: Die CPU Z80
Die Anschlussbelegungen der wichtigsten ICs im CPC: Die CPU Z80
Z80
erweitern. Dieser Bereich ist im RAM und im Erläuterung zu den Anschlüssen 40 bis 45: 42 - ROMEN (0)ROM identisch und darf, bis auf zwei Ausnahmen (External Alle noch folgenden Anschlüsse fallen unter die Rubrik STEUER- oder auch CONTROLBUS:: INT - InterruptInterrupt und User-Restart) nicht verändert werden.

Diese Vektoren sind im AnhangAnhang alle genau dokumentiert. Die folgende Grafik bietet aber eine grobe Orientierungshilfe. Zwischen den einzelnen ROM-Konfiguration: RestartsRestarts liegen dabei aber noch weitere Einsprungsstellen, die weitere, sinnvoll Die Fließkomma-Routinen: FunktionenFunktionen bereitstellen:

+------------------------------------------------------------------------------+
|                           THE Überblick: LOW KERNEL JUMPBLOCK
Die Firmware des Schneider CPC: LOW KERNEL JUMPBLOCK
LOW KERNEL JUMPBLOCK
| +--------------+---------------------------------------------------------------+ | &0040: | Beginn des Memory Pool. | +--------------+---------------------------------------------------------------+ | &003LOW KERNEL JUMPBLOCK: 000B: LOW KL LOW PCHL
LOW KERNEL JUMPBLOCK: 001B: LOW KL FAR PCHL
LOW KERNEL JUMPBLOCK: 003B: LOW EXT INTERRUPT
B
: | External Alle noch folgenden Anschlüsse fallen unter die Rubrik STEUER- oder auch CONTROLBUS:: INT - InterruptInterrupt. Einsprungs-Adresse für die Behandlungs- | | | Routinen für Alle noch folgenden Anschlüsse fallen unter die Rubrik STEUER- oder auch CONTROLBUS:: INT - InterruptInterrupts, die von System-Erweiterungen am | | | Die Anschlüsse am Schneider CPC: Der Expansion-Port (Systembus)Expansion-Port erzeugt wurden. | | | | | &0038 Speicheraufteilung durch ein Vordergrund-Programm: RST 3
LOW KERNEL JUMPBLOCK: 0000 - RST 0: LOW RESET ENTRY
LOW KERNEL JUMPBLOCK: 0008 - RST 1: LOW LOW JUMP
LOW KERNEL JUMPBLOCK: 0010 - RST 2: LOW SIDE CALL
LOW KERNEL JUMPBLOCK: 0018 - RST 3: LOW FAR CALL
LOW KERNEL JUMPBLOCK: 0020 - RST 4: LOW RAM LAM
LOW KERNEL JUMPBLOCK: 0028 - RST 5: LOW FIRM JUMP
LOW KERNEL JUMPBLOCK: 0030 - RST 6: LOW USER RESTART
LOW KERNEL JUMPBLOCK: 0038 - RST 7: LOW INTERRUPT ENTRY
RST
7: | Alle noch folgenden Anschlüsse fallen unter die Rubrik STEUER- oder auch CONTROLBUS:: INT - InterruptInterrupt Entry: Einsprungsstelle für den | | | Hardware-Interrupt, der 300 mal in jeder Sekunde von der Die ICs im Überblick: Die ULA 40007, 40008 oder 40010
Die Anschlussbelegungen der wichtigsten ICs im CPC: Die ULA 40007 und 40008 (CPC 464 und 664)
Die Anschlussbelegungen der wichtigsten ICs im CPC: Die ULA 40010 (CPC 6128)
ULA
| | | erzeugt wird. | | | | | &0030 Speicheraufteilung durch ein Vordergrund-Programm: RST 3
LOW KERNEL JUMPBLOCK: 0000 - RST 0: LOW RESET ENTRY
LOW KERNEL JUMPBLOCK: 0008 - RST 1: LOW LOW JUMP
LOW KERNEL JUMPBLOCK: 0010 - RST 2: LOW SIDE CALL
LOW KERNEL JUMPBLOCK: 0018 - RST 3: LOW FAR CALL
LOW KERNEL JUMPBLOCK: 0020 - RST 4: LOW RAM LAM
LOW KERNEL JUMPBLOCK: 0028 - RST 5: LOW FIRM JUMP
LOW KERNEL JUMPBLOCK: 0030 - RST 6: LOW USER RESTART
LOW KERNEL JUMPBLOCK: 0038 - RST 7: LOW INTERRUPT ENTRY
RST
6: | Die Sprungleisten: User RestartUser Restart. Dieser ROM-Konfiguration: RestartsRestart ist für das | | | Vordergrund-Programm frei verfügbar. Die ROM-Version ruft | | | dabei den RAM-Restart auf. | | | | | &0028 Speicheraufteilung durch ein Vordergrund-Programm: RST 3
LOW KERNEL JUMPBLOCK: 0000 - RST 0: LOW RESET ENTRY
LOW KERNEL JUMPBLOCK: 0008 - RST 1: LOW LOW JUMP
LOW KERNEL JUMPBLOCK: 0010 - RST 2: LOW SIDE CALL
LOW KERNEL JUMPBLOCK: 0018 - RST 3: LOW FAR CALL
LOW KERNEL JUMPBLOCK: 0020 - RST 4: LOW RAM LAM
LOW KERNEL JUMPBLOCK: 0028 - RST 5: LOW FIRM JUMP
LOW KERNEL JUMPBLOCK: 0030 - RST 6: LOW USER RESTART
LOW KERNEL JUMPBLOCK: 0038 - RST 7: LOW INTERRUPT ENTRY
RST
5: | FIRM MAIN FIRMWARE JUMPBLOCK: JUMPER
Die Firmware des Schneider CPC: JUMPER
JUMP
: Sprung zu einer Routine mit eingeschaltetem | | | unterem Erläuterung zu den Anschlüssen 40 bis 45: 42 - ROMEN (0)ROM. | | | | | &0020 Speicheraufteilung durch ein Vordergrund-Programm: RST 3
LOW KERNEL JUMPBLOCK: 0000 - RST 0: LOW RESET ENTRY
LOW KERNEL JUMPBLOCK: 0008 - RST 1: LOW LOW JUMP
LOW KERNEL JUMPBLOCK: 0010 - RST 2: LOW SIDE CALL
LOW KERNEL JUMPBLOCK: 0018 - RST 3: LOW FAR CALL
LOW KERNEL JUMPBLOCK: 0020 - RST 4: LOW RAM LAM
LOW KERNEL JUMPBLOCK: 0028 - RST 5: LOW FIRM JUMP
LOW KERNEL JUMPBLOCK: 0030 - RST 6: LOW USER RESTART
LOW KERNEL JUMPBLOCK: 0038 - RST 7: LOW INTERRUPT ENTRY
RST
4: | RAM LAM: Erweitertes 'LD_A,(HL)', bei dem nur aus dem RAM | | | gelesen wird. | | | | | &0018 Speicheraufteilung durch ein Vordergrund-Programm: RST 3
LOW KERNEL JUMPBLOCK: 0000 - RST 0: LOW RESET ENTRY
LOW KERNEL JUMPBLOCK: 0008 - RST 1: LOW LOW JUMP
LOW KERNEL JUMPBLOCK: 0010 - RST 2: LOW SIDE CALL
LOW KERNEL JUMPBLOCK: 0018 - RST 3: LOW FAR CALL
LOW KERNEL JUMPBLOCK: 0020 - RST 4: LOW RAM LAM
LOW KERNEL JUMPBLOCK: 0028 - RST 5: LOW FIRM JUMP
LOW KERNEL JUMPBLOCK: 0030 - RST 6: LOW USER RESTART
LOW KERNEL JUMPBLOCK: 0038 - RST 7: LOW INTERRUPT ENTRY
RST
3: | FAR Maschinencode über HIMEM: CALLCALL: Aufruf eines Grundlagen: UnterprogrammeUnterprogramms in jedem Erläuterung zu den Anschlüssen 40 bis 45: 42 - ROMEN (0)ROM oder RAM. | | | | | &0010 Speicheraufteilung durch ein Vordergrund-Programm: RST 3
LOW KERNEL JUMPBLOCK: 0000 - RST 0: LOW RESET ENTRY
LOW KERNEL JUMPBLOCK: 0008 - RST 1: LOW LOW JUMP
LOW KERNEL JUMPBLOCK: 0010 - RST 2: LOW SIDE CALL
LOW KERNEL JUMPBLOCK: 0018 - RST 3: LOW FAR CALL
LOW KERNEL JUMPBLOCK: 0020 - RST 4: LOW RAM LAM
LOW KERNEL JUMPBLOCK: 0028 - RST 5: LOW FIRM JUMP
LOW KERNEL JUMPBLOCK: 0030 - RST 6: LOW USER RESTART
LOW KERNEL JUMPBLOCK: 0038 - RST 7: LOW INTERRUPT ENTRY
RST
2: | SIDE Maschinencode über HIMEM: CALLCALL: Aufruf einer Routine in einem 'benachbarten' Erläuterung zu den Anschlüssen 40 bis 45: 42 - ROMEN (0)ROMs. | | | Das ist nur bei sehr umfangreicher Maschinencode auf dem CPC: ROM-SoftwareROM-Software nötig. | | | | | &0008 Speicheraufteilung durch ein Vordergrund-Programm: RST 3
LOW KERNEL JUMPBLOCK: 0000 - RST 0: LOW RESET ENTRY
LOW KERNEL JUMPBLOCK: 0008 - RST 1: LOW LOW JUMP
LOW KERNEL JUMPBLOCK: 0010 - RST 2: LOW SIDE CALL
LOW KERNEL JUMPBLOCK: 0018 - RST 3: LOW FAR CALL
LOW KERNEL JUMPBLOCK: 0020 - RST 4: LOW RAM LAM
LOW KERNEL JUMPBLOCK: 0028 - RST 5: LOW FIRM JUMP
LOW KERNEL JUMPBLOCK: 0030 - RST 6: LOW USER RESTART
LOW KERNEL JUMPBLOCK: 0038 - RST 7: LOW INTERRUPT ENTRY
RST
1: | LOW MAIN FIRMWARE JUMPBLOCK: JUMPER
Die Firmware des Schneider CPC: JUMPER
JUMP
: Sprung zu einer Routine im unteren Erläuterung zu den Anschlüssen 40 bis 45: 42 - ROMEN (0)ROM mit | | | wählbarem ROM-Konfiguration: ROM-Status
Anschluss eines Zusatz-ROM: ROM-Status
ROM-Status
. | | | | | &0000 Speicheraufteilung durch ein Vordergrund-Programm: RST 3
LOW KERNEL JUMPBLOCK: 0000 - RST 0: LOW RESET ENTRY
LOW KERNEL JUMPBLOCK: 0008 - RST 1: LOW LOW JUMP
LOW KERNEL JUMPBLOCK: 0010 - RST 2: LOW SIDE CALL
LOW KERNEL JUMPBLOCK: 0018 - RST 3: LOW FAR CALL
LOW KERNEL JUMPBLOCK: 0020 - RST 4: LOW RAM LAM
LOW KERNEL JUMPBLOCK: 0028 - RST 5: LOW FIRM JUMP
LOW KERNEL JUMPBLOCK: 0030 - RST 6: LOW USER RESTART
LOW KERNEL JUMPBLOCK: 0038 - RST 7: LOW INTERRUPT ENTRY
RST
0: | RESET-ENTRY: Kaltstart. | | | | +--------------+---------------------------------------------------------------+
Aufteilung des RAMs ab &B100

Oberhalb der Adresse &B100 = 45312 liegen mehrere Bereiche, die sich funktional klar trennen lassen. Zwischen dem CPC 464 und den beiden anderen gibt es hier zum Teil erhebliche Unterschiede. Die folgende, grobe Unterteilung trifft aber auf alle drei Schneider-Computer zu. Abweichende Werte für den CPC 664 bzw. 6128 sind in Befehls-Elemente: KlammernKlammern angegeben:

+------------------------------------------------------------------------------+
|                             Die Anschlussbelegungen der wichtigsten ICs im CPC: Das RAM 4164Das RAM ab &B100:                                |
+--------------------------+---------------------------------------------------+
| &C000 bis &FFFF          |  Bildwiederholspeicher, Video-RAM                 |
|                          |                                                   |
| &BF00 bis &BFFF          |  reservierter Bereich für den Hardware-Stack      |
|                          |                                                   |
| &BE40 bis &BE81          |  wird von Die Abteilungen des Betriebssystems: AmsdosAmsdos belegt!!!                        |
|                          |                                                   |
| &Die Indirections der Firmware-Packs: BDCD:  IND TXT DRAW CURSORBDCD bis &BDF3 (&BDF6)  |  Überblick: Die Indirections der Firmware-Packs
Die Firmware des Schneider CPC: Die Indirections der Firmware-Packs
Indirections
| | | | | &KEY MANAGER: BB00: KM INITIALIZEBB00 bis &BD39 (&BD5D) | Überblick: MAIN FIRMWARE JUMPBLOCKMAIN FIRMWARE JUMPBLOCK | | | | | &HIGH KERNEL JUMPBLOCK: B921: HI KL POLL SYNCHRONOUSB921 bis &BAE8 (&BAE3) | In's RAM kopierte Routinen, Interrupt-Routine | | | ab &HIGH KERNEL JUMPBLOCK: B921: HI KL POLL SYNCHRONOUSB921: HI KL POLL SYNCHRONOUS. | | | | | &HIGH KERNEL JUMPBLOCK: B900: HI KL U ROM ENABLEB900 bis &B920 | Die Sprungleisten: High Kernel Jumpblock
Überblick: HIGH KERNEL JUMPBLOCK
Die Firmware des Schneider CPC: HIGH KERNEL JUMPBLOCK
HIGH KERNEL JUMPBLOCK
| | | | | &B100 bis &B8FF | Systemspeicher für die Firmware-Routinen | +--------------------------+---------------------------------------------------+ | &B0FF | Ende des Memory Pool. | +--------------------------+---------------------------------------------------+

Speicheraufteilung durch ein Vordergrund-Programm

Unter einem 'Vordergrund-Programm' versteht man das Maschinencode-Programm, das nach der Initialisierung des Rechners durch entsprechende Firmware-Routinen gestartet wird. Das kann beispielsweise der Basic-Interpreter, Einleitung: CP/MCP/M oder ein in Maschinencode geschriebenes Spiel sein.

Wird ein Vordergrund-Programm gestartet, so darf es sich innerhalb der Grenzen &0040 und &B0FF, die ihm vom Betriebssystem in den Registern DE und BC übergeben werden, seinen Speicher organisieren, wie es will. Das Betriebssystem macht aber zusätzlich eine Annahme, die sich in dem in HL übergebenen Wert äußert: Dass das Vordergrund-Programm sich nämlich ab &AC00 einen Bereich für Systemvariablen reservieren wird.

Das trifft für den Basic-Interpreter zu. Andere Vordergrund-Programme können diesen Wert aber nach belieben ändern oder ganz ignorieren.

Hintergrund-ROMs

Nun können zusätzlich die sogenannten Speicheraufteilung durch ein Vordergrund-Programm: Hintergrund-ROMsHintergrund-ROMs initialisiert werden. Der Basic-Interpreter macht das immer, wofür er den Vektor 'KERNEL: BCCB: KL ROM WALKKL ROM WALK' aufruft.

Speicheraufteilung durch ein Vordergrund-Programm: Hintergrund-ROMsHintergrund-ROMs enthalten System-Erweiterungen. Sie stellen Routinen bereit, die vom Vordergrund-Programm aus aufgerufen werden können. Ein Beispiel ist das Erläuterung zu den Anschlüssen 40 bis 45: 42 - ROMEN (0)ROM mit dem AMSDOS-Disketten-Betriebssystem.

Man kann davon ausgehen, dass jedes Speicheraufteilung durch ein Vordergrund-Programm: Hintergrund-ROMsHintergrund-ROM ebenfalls Systemspeicher im RAM einrichten muss (Amsdos beispielsweise &500 = 1280 Datentypen: Bytes
Datenbreite: Bytes
Bytes
). Der muss nun vom Memory Pool des Vordergrund-Programms abgezogen werden. Dazu übergibt das Vordergrund-Programm den Speicheraufteilung durch ein Vordergrund-Programm: Hintergrund-ROMsHintergrund-ROMs bei deren Initialisierung die Zeiger auf die Unter- und die Oberkante des noch frei verfügbaren System-Speichers in den Registern DE und HL. Die System-Erweiterung (Die Abteilungen des Betriebssystems: AmsdosAmsdos) reserviert sich dann einfach Speicherplatz, indem es die Werte in diesen Registern verändert.

Zusätzlich zieht auch noch das Betriebssystem pro Speicheraufteilung durch ein Vordergrund-Programm: Hintergrund-ROMsHintergrund-ROM 4 Datentypen: Bytes
Datenbreite: Bytes
Bytes
ab, die für die verkettete Trees: ListenListe aller RSX-Kommandos benötigt werden.

Begnuegt sich das Vordergrund-Programm mit den vom Betriebssystem angenommenen Werten (HL=&ABFF und DE=&0040), benötigt es also keinen festen Variablenbereich am unteren Ende des Memory Pools (wofür erst DE verändert werden müsste) und benutzt es einen statischen (ortsfesten) Variablenbereich ab &AC00, so braucht es keine Die Tonausgabe: Das Kontrollregister (Reg. 7)
Die Tonausgabe: Die möglichen Hüllkurvenformen (Reg. 13)
Register
zu verändern, bevor es die Speicheraufteilung durch ein Vordergrund-Programm: Hintergrund-ROMsHintergrund-ROMs initialisiert. Es kann direkt mit den ihm übergebenen Werten KERNEL: BCCB: KL ROM WALKKL ROM WALK aufrufen. Das macht beispielsweise der Basic-Interpreter.

Um sich unten Speicherplatz zu reservieren, muss das Speicheraufteilung durch ein Vordergrund-Programm: Hintergrund-ROMsHintergrund-ROM bei seiner Initialisierung das DE-Register entsprechend erhöhen. Um am oberen Ende des Memory Pools Speicherplatz zu erhalten, muss HL erniedrigt werden. Diese Ausgaben in den HL- und DE-Doppelregistern können dann direkt als Eingabe für das nächste Speicheraufteilung durch ein Vordergrund-Programm: Hintergrund-ROMsHintergrund-ROM benutzt werden, sofern es ein solches noch gibt.

Sonst erhält das Vordergrund-Programm diese beiden, veränderten Zeiger zurück und erkennt daran, welcher Bereich ihm noch zur Verfügung steht.

RST 3

Dabei hat das Vordergrund-Programm, im Normalfall also der Basic-Interpreter, vor den Speicheraufteilung durch ein Vordergrund-Programm: Hintergrund-ROMsHintergrund-ROMs einen entscheidenden Vorteil: Es bekommt vom MAIN FIRMWARE JUMPBLOCK: KERNEL
Die Firmware des Schneider CPC: KERNEL
Kernel
immer eine feste Ober- und Untergrenze übergeben, während Speicheraufteilung durch ein Vordergrund-Programm: Hintergrund-ROMsHintergrund-ROMs mit dem zufrieden sein müssen, was ihnen von vorher initialisierten Speicheraufteilung durch ein Vordergrund-Programm: Hintergrund-ROMsHintergrund-ROMs und vom Vordergrund-Programm übrig gelassen wird.

Speicheraufteilung durch ein Vordergrund-Programm: Hintergrund-ROMsHintergrund-ROMs haben keine Möglichkeit, in irgendeiner festen Speicherzelle die Adresse ihres dynamischen RAM-Bereiches zu speichern. Sie könnten im Normalfall gar nicht auf ihr reserviertes RAM zugreifen, weil sie nicht wissen, wo es liegt!

Das ist natürlich ein unmöglicher Zustand. Deshalb wird bei jedem Aufruf einer Routine in einem Speicheraufteilung durch ein Vordergrund-Programm: Hintergrund-ROMsHintergrund-ROM via

&0010 LOW MAIN FIRMWARE JUMPBLOCK: KERNEL
Die Firmware des Schneider CPC: KERNEL
KL
SIDE Maschinencode über HIMEM: CALLCALL (LOW KERNEL JUMPBLOCK: 0010 - RST 2: LOW SIDE CALLRST_2) &0013 LOW KERNEL JUMPBLOCK: 0013: LOW KL SIDE PCHLLOW KL SIDE PCHL &0018 LOW MAIN FIRMWARE JUMPBLOCK: KERNEL
Die Firmware des Schneider CPC: KERNEL
KL
FAR Maschinencode über HIMEM: CALLCALL (LOW KERNEL JUMPBLOCK: 0018 - RST 3: LOW FAR CALLRST_3), &001LOW KERNEL JUMPBLOCK: 001B: LOW KL FAR PCHLB LOW KL FAR PCHL und &0023 LOW KERNEL JUMPBLOCK: 0023: LOW KL FAR ICALLLOW KL FAR ICALL

der angesprungenen Routine im IY-Register die Untergrenze des dynamischen RAM-Bereiches über dem Memory Pool übergeben, der für ihr Erläuterung zu den Anschlüssen 40 bis 45: 42 - ROMEN (0)ROM reserviert wurde. Mit Hilfe des IY-Registers kann dann auf den über dem Memory Pool liegenden System-Speicher zugegriffen werden. Um die Verwaltung des unterhalb vom Memory Pool reservierten Systemspeicher müssen sich die Hintergrund-Routinen aber selbst kümmern, was über Zeiger im oberen Systemspeicher geschehen muss.

Der Wert, der dabei immer im IY-Register übergeben wird, ist die Adresse des ersten Datentypen: Bytes
Datenbreite: Bytes
Bytes
im oberen Systemspeicher. Dieser Wert ist um Eins höher, als der im HL-Register nach der Initialisierung zurückgegebene Wert für die Oberkante des verbliebenen freien Speicherbereiches!

Speicher-Aufteilung total

Ein Vordergrund-Programm wird also im Normalfall zuerst die untere und obere Grenze erhöhen bzw. erniedrigen, um sich so einen Variablenbereich mit festen Adressen zu reservieren. Danach werden die Speicheraufteilung durch ein Vordergrund-Programm: Hintergrund-ROMsHintergrund-ROMs initialisiert und danach steht erst der für Anwenderprogramme, Daten o. AE. frei verfügbare Speicherbereich fest.

Daraus ergibt sich die folgende Unterteilung des RAMs, die für alle Vordergrund-Programme zutrifft. Die Adressen der von Einleitung: BASIC
Anhang: Basic
Basic
zusammen mit Die Abteilungen des Betriebssystems: AmsdosAmsdos reservierten Bereiche sind in Befehls-Elemente: KlammernKlammern eingetragen:

Speicher-Aufteilung durch Firmware, Vordergrund-Programm und Hintergrund-ROMs:
 &0000  +-----------------------------------------------+
        |                                               |
        |                                               |
        |             Bildwiederholspeicher             |
        |                                               |
        |                                               |
 &C000  +-----------------------------------------------+
        |                                               |
        | reservierter Speicher für das Betriebssystem  |
        |                                               |
 &B100  +-----------------------------------------------+
        |                                               |
        | vom Vordergrund-Programm reservierter Bereich |
        |     für statische (ortsfeste) Unterprogramme: VariablenVariablen       |
        |                                               |
(&AC00) +-----------------------------------------------+
        |                                               |
        |     evtl. von Speicheraufteilung durch ein Vordergrund-Programm: Hintergrund-ROMsHintergrund-ROMs reserviert     |
        |                                               |
(&A6FC) +-----------------------------------------------+
        |                                               |
        |      frei für das Vordergrund-Programm        |
        |             verfügbarer Speicher              |
       ...                                             ...
        |                 (Memory Pool)                 |
        |                                               |
(&0040) +-----------------------------------------------+
        |                                               |
        |     evtl. von Speicheraufteilung durch ein Vordergrund-Programm: Hintergrund-ROMsHintergrund-ROMs reserviert     |
        |                                               |
(&0040) +-----------------------------------------------+
        |                                               |
        |   evtl. vom Vordergrund-Programm reserviert   |
        |                                               |
 &0040  +-----------------------------------------------+
        | Reserviert für das Betriebssystem (ROM-Konfiguration: RestartsRestarts)  |
 &0000  +-----------------------------------------------+

Die Aufteilung des RAM durch den Basic-Interpreter

Bei Aufruf des Basic-Interpreters stehen ihm als Vordergrund-Programm der RAM-Bereich von &0040 bis &B0FF zur Verfügung. Ab &AC00 wird Die Anschlussbelegungen der wichtigsten ICs im CPC: Das RAM 4164das RAM für statische Systemvariablen benutzt, so wie es ihm vom Betriebssystem 'vorgeschlagen' wird. Abgesehen davon sind aber alle weiteren Daten, die Einleitung: BASIC
Anhang: Basic
Basic
speichern muss, und dazu gehört beispielsweise auch das Basic-Programm, das der Anwender eingegeben hat, frei verschieblich.

Das ist nur dadurch möglich, dass in dem statischen Variablenbereich oberhalb von &AC00 Zeiger gespeichert werden, die auf die Grenzen der zu verwaltenden Bereiche zeigen. Insgesamt ergibt sich das folgende Bild. Dabei sind die Adressen wieder für 'Einleitung: BASIC
Anhang: Basic
Basic
plus Die Abteilungen des Betriebssystems: AmsdosAmsdos' angegeben:

Speicher-Aufteilung durch Basic
 &B100  +--------------------------------------------+
        |                                            |
        |   Systemvariablen des Basic-Interpreters   |
        |                                            |
 &AC00  +--------------------------------------------+
        |                                            |
        | evtl. Systemvariablen von Speicheraufteilung durch ein Vordergrund-Programm: Hintergrund-ROMsHintergrund-ROMs |
        |                                            |
 &A6FC  +--------------------------------------------+ Obergrenze Memory Pool
        |          evtl. Maschinencode (Operationen: BD5B / 349A / 349A:  FLO SUBA)           |
 &A6FC  +--------------------------------------------+
        |   veränderbarer Teil des Die Text-VDU: Zeichensatz
Der Zeichensatz des Schneider CPC: Der Zeichensatz des Schneider CPC
Zeichensatzes
| |(SYMBOL AFTER ohne OPENOUT o. OPENIN aktiv) | &A67C +--------------------------------------------+ | evtl. Maschinencode (LOW KERNEL JUMPBLOCK: 000B: LOW KL LOW PCHL
LOW KERNEL JUMPBLOCK: 001B: LOW KL FAR PCHL
LOW KERNEL JUMPBLOCK: 003B: LOW EXT INTERRUPT
B
) | &A67C +--------------------------------------------+ | | | evtl. Kassetten- bzw. Disketten-I/O-Puffer | | (immer 4 kByte lang) | | | &A67C +--------------------------------------------+ | evtl. Maschinencode (C) | &A67C +--------------------------------------------+ | veränderbarer Teil des Die Text-VDU: Zeichensatz
Der Zeichensatz des Schneider CPC: Der Zeichensatz des Schneider CPC
Zeichensatzes
| |(SYMBOL AFTER wenn OPENOUT o. OPENIN aktiv) | &A67C +--------------------------------------------+ | evtl. Maschinencode (D) | &A67C +--------------------------------------------+ <-- HIMEM-Zeiger | | | String-Bereich (String-Inhalte) | | | +--------------------------------------------+ |<<< freier Speicherbereich, Memory Pool >>> | +--------------------------------------------+ | | | Bereich für dimensionierte | | Unterprogramme: VariablenVariablen (Felder) | | | +--------------------------------------------+ | | | Variablenbereich (normale Unterprogramme: VariablenVariablen) | | | +--------------------------------------------+ | | | Basic-Programm | | | &016F +--------------------------------------------+ |Tokenisierungs-Puffer für neue Basiczeilen | | oder Direkt-Kommandos. &12F Datentypen: Bytes
Datenbreite: Bytes
Bytes
lang. | &0040 +--------------------------------------------+ Untergrenze Memory Pool | evtl. reservierter Systemspeicher für | | Speicheraufteilung durch ein Vordergrund-Programm: Hintergrund-ROMsHintergrund-ROMs | &0040 +--------------------------------------------+

Oberhalb &AC00 liegen die statischen Systemvariablen des Basic-Interpreters.

Darunter kommt der Bereich, in dem sich Speicheraufteilung durch ein Vordergrund-Programm: Hintergrund-ROMsHintergrund-ROMs Speicherplatz für ihre eigenen Systemvariablen reserviert haben. Die Abteilungen des Betriebssystems: AmsdosAmsdos reserviert genau &500 Datentypen: Bytes
Datenbreite: Bytes
Bytes
, so dass, vorausgesetzt dass sonst keine weiteren ROM-Ereiterungen angeschlossen sind, die Obergrenze des Memory Pools auf &A6FB (=42747) sinkt. Prinzipiell ist die Länge dieses Bereiches zunächst einmal unbekannt. Sind aber alle Speicheraufteilung durch ein Vordergrund-Programm: Hintergrund-ROMsHintergrund-ROMs initialisiert, verändert sich die Obergrenze des Memory Pools nicht mehr.

Der Bereich darunter bis zu &0040 steht dem Basic-Interpreter noch zur Verfügung, nachdem er alle Speicheraufteilung durch ein Vordergrund-Programm: Hintergrund-ROMsHintergrund-ROMs initialisiert hat. Dabei ist zu bedenken, dass 'möglicherweise' auch noch unten Speicherplatz von Speicheraufteilung durch ein Vordergrund-Programm: Hintergrund-ROMsHintergrund-ROMs beansprucht wird, und sich die Untergrenze des Basic-Speichers nach oben verschiebt. Bei Die Abteilungen des Betriebssystems: AmsdosAmsdos ist das aber nicht der Fall.

Eine weitere, feste Einrichtung ist dann noch der Tokenisierungs-Puffer, den Einleitung: BASIC
Anhang: Basic
Basic
ganz unten anlegt. Jede Eingabe, die man mit dem Zeileneditor macht, muss in die interne Kurz-Kodierung von Einleitung: BASIC
Anhang: Basic
Basic
umgewandelt werden. Dabei werden vor allem die Befehlsworte durch ein einziges Kürzel, das sogenannte 'Basic: Die Token des Locomotive-BasicToken' ersetzt. Das hat den Vorteil, dass der von Basic-Programmen beanspruchte Speicherplatz kürzer wird, man also längere Programme schreiben kann, und dass die Programme erheblich schneller abgearbeitet werden.

In aller Regel liegt dann der Beginn des Programm-Speichers bei &016F (muss er aber nicht!!). Deshalb existiert oberhalb von &AC00 ein Zeiger auf diese Stelle.

Über dem Programm folgt der Bereich, in dem alle nicht dimensionierten Unterprogramme: VariablenVariablen gespeichert sind. Auch auf den Anfang dieses Bereiches existiert ein Zeiger. Das ist auf jeden Fall nötig, da sich die Lage des Variablenspeichers mit jeder Änderung im Programmtext verschiebt. Hier werden alle Unterprogramme: VariablenVariablen mit ihrem Namen und dem gespeicherten Wert abgelegt. Die Länge der einzelnen Variablen-Einträge ändert sich mit der Länge des Namens und ihrem Typ: Integer-Zahlen benötigen nur zwei Datentypen: Bytes
Datenbreite: Bytes
Bytes
, Fließkomma-Zahlen 5 Datentypen: Bytes
Datenbreite: Bytes
Bytes
und für Datentypen: StringsStrings wird der 'String-Descriptor' eingetragen, der drei Datentypen: Bytes
Datenbreite: Bytes
Bytes
beansprucht.

Über den normalen Unterprogramme: VariablenVariablen folgen die dimensionierten Felder. Deren Abspeicherung ist noch etwas komplizierter als bei den einfachen Unterprogramme: VariablenVariablen.

Danach beginnt der Bereich, der auch durch den Basic-Interpreter noch nicht benutzt ist, der verbliebene Memory Pool.

In den wachsen von oben her die Datentypen: StringsStrings hinein. In den Variablenbereichen werden ja nur die Descriptoren, also Längenangabe und Zeiger auf den eigentlichen String-Text abgespeichert. Im Kapitel über Daten ist die Speicherung von Datentypen: StringsStrings näher erläutert. Der Zeiger auf die Oberkante des String-Bereiches ist die auch für Basic-Programme zugängliche Systemvariable Die Aufteilung des RAM durch den Basic-Interpreter: Chaos über HIMEMHIMEM.

Darüber beginnt ein ziemliches Chaos.

Chaos über HIMEM

Schuld daran sind einige Bereiche, die nur bei Bedarf eingerichtet werden. Über Die Aufteilung des RAM durch den Basic-Interpreter: Chaos über HIMEMHIMEM können liegen:

Maschinencode-Programme
der Kassetten/Disketten-I/O-Puffer
und Zeichenmatrizen

Wird Einleitung: BASIC
Anhang: Basic
Basic
gestartet, so ist noch kein I/O-Puffer reserviert. Maschinencode-Programme über Die Aufteilung des RAM durch den Basic-Interpreter: Chaos über HIMEMHIMEM gibt es auch noch nicht, wohl werden aber die Definitionen der 16 letzten Zeichen des Zeichengenerators, CHR$(&Der Zeichensatz des Schneider CPC: &F0 = 240F0) bis CHR$(&FF) aus dem Erläuterung zu den Anschlüssen 40 bis 45: 42 - ROMEN (0)ROM hierhin kopiert.

Wird jetzt ein Programm geladen, so wird der I/O-Puffer unterhalb des Die Text-VDU: Zeichensatz
Der Zeichensatz des Schneider CPC: Der Zeichensatz des Schneider CPC
Zeichensatzes
eröffnet. Nach Abschluss des Lade-Vorgangs wird er aber normalerweise wieder geschlossen.

Man kann aber auch den veränderlichen Teil des Zeichengenerators vollständig aus dem RAM löschen (SYMBOL_AFTER_256). Eröffnet man jetzt eine Datei für Ein- oder Ausgabe, so wird der Puffer wieder eingerichtet. Während der Puffer eröffnet ist, kann man wieder mit SYMBOL AFTER einen Teil des Zeichengenerators in's RAM kopieren. Jetzt aber unterhalb des I/O-Puffers. Wird dieser danach wieder geschlossen, so kann dieser Bereich nicht mehr frei gegeben werden, weil die veränderbaren Zeichenmatrizen darunter liegen.

Zusätzlich können noch jederzeit Maschinencode-Programme über Die Aufteilung des RAM durch den Basic-Interpreter: Chaos über HIMEMHIMEM eingeladen werden. Es sind also viele Kombinationen denkbar, mit denen oberhalb von Die Aufteilung des RAM durch den Basic-Interpreter: Chaos über HIMEMHIMEM der Platz verteilt wird.

Mit dem Zeichengenerator hat der Basic-Interpreter jedoch so seine Probleme. Liegt dieser nicht mehr direkt über Die Aufteilung des RAM durch den Basic-Interpreter: Chaos über HIMEMHIMEM, weil darunter der I/O-Puffer eröffnet wurde oder Die Aufteilung des RAM durch den Basic-Interpreter: Chaos über HIMEMHIMEM vom Anwender herabgesetzt wurde (um darüber ein Maschinenprogramm einzuladen), so kann er die Größe dieses Bereiches nicht mehr ändern. Die folgenden Programme zeigen das:

10 OPENOUT "Erklärung der Anschlussbelegung: Testtest              oder:      10 MEMORY HIMEM-1
20 SYMBOL AFTER 256                      20 SYMBOL AFTER 256
RUN [ENTER]                              RUN [ENTER]
Improper argument in 20                  Improper argument in 20
Erklärung zu den Bezeichnungen: READY
Erklärungen zu den Anschlussbezeichnungen: READY
Ready
Erklärung zu den Bezeichnungen: READY
Erklärungen zu den Anschlussbezeichnungen: READY
Ready

Die Fehlermeldungen treten sogar auf, wenn durch das Symbol-After-Kommando die Anzahl der veränderlichen Zeichenmatrizen nicht geändert wird!

Es ist deshalb sehr oft ratsam, in einem Programm zunächst den Bereich der änderbaren Zeichen-Matrizen zu schließen, dann eventuell Mcode-Programme nachzuladen und erst danach wieder die benötigten Zeichen im RAM anzulegen.

Ein weiterer, sinnvoller Trick besteht darin, auch den I/O-Puffer so anzulegen, dass ihn Einleitung: BASIC
Anhang: Basic
Basic
nicht mehr schließen kann. Wenn Einleitung: BASIC
Anhang: Basic
Basic
diesen Puffer nämlich eröffnet und schließt, muss es jedesmal eine Strings: Garbage CollectionGarbage Collection durchführen. Wie oben bereits erwähnt, genügt es aber, irgend etwas unterhalb des Puffers einzurichten, und sei es auch nur ein einziges Datentypen: Bytes
Datenbreite: Bytes
Byte
:

 10 CLOSEIN:CLOSEOUT    ' Sicher ist sicher.
 20 SYMBOL AFTER 256    ' lösche Bereich der veränderlichen Matrizen
 30 |TAPE               ' nicht Garbage Collection: ... beim CPC 464beim CPC 464 ohne Die Abteilungen des Betriebssystems: AmsdosAmsdos
 40 OPENOUT ""          ' I/O-Puffer eröffnen
 50 MEMORY HIMEM-1      ' ein Datentypen: Bytes
Datenbreite: Bytes
Byte
dazwischen reservieren 60 CLOSEOUT ' Ausgabestrom freigeben. Puffer bleibt erhalten! 70 |DISC ' nicht Garbage Collection: ... beim CPC 464beim CPC 464 ohne Die Abteilungen des Betriebssystems: AmsdosAmsdos 80 MEMORY HIMEM-xyz ' nun evtl. eine Maschinencode-Erweiterung 90 LOAD "MCODE.BIN",Die Aufteilung des RAM durch den Basic-Interpreter: Chaos über HIMEMHIMEM+1 ' nachladen und evtl. initialisieren 100 Maschinencode über HIMEM: CALLCALL Die Aufteilung des RAM durch den Basic-Interpreter: Chaos über HIMEMHIMEM+1 110 SYMBOL AFTER 32 ' evtl. den gewünschten Teil des Zeichengenerators wieder in's RAM kopieren um ihn verändern zu können. 120 REM Programm

Die Zeilen 30 und 70 stellen dabei noch so etwas wie einen 'Trick im Trick' dar: Wird nämlich unter Die Abteilungen des Betriebssystems: AmsdosAmsdos eine Diskettendatei eröffnet, so kontrolliert Die Abteilungen des Betriebssystems: AmsdosAmsdos sofort, ob im aktuellen Laufwerk auch eine Diskette eingelegt ist. Dazu muss erst einmal der Laufwerk-Motor angeworfen werden (dauert genau eine Sekunde) und dann ist vielleicht keine Diskette drin, oder die Diskette rutscht durch oder was einem sonst noch passieren kann.

All das ist aber beim Kassetten-Manager nicht der Fall, weshalb die Aufgabe, den Puffer anzulegen, ganz galant von diesem übernommen wird.

Basic-Zeiger

Um diese dynamischen Bereiche zu verwalten, benötigt der Basic-Interpreter eine Vielzahl an Zeigern, die auf die verschiedenen Grenzen zeigen. Diese sind (ortsfest) oberhalb von &AC00 angelegt. Bei den CPCs 664 und 6128 entsprechen sich dabei die Adressen, leider nicht auch Garbage Collection: ... beim CPC 464beim CPC 464. In der folgenden Tabelle sind deshalb die Werte für den CPC 464 und die beiden anderen getrennt aufgeführt:

Adressen der Basic-Zeiger:
CPC 464   664/6128  zeigt auf:        (Bemerkung)
--------------------------------------------------------------------------------
 &AE7B     &AE5E    Die Aufteilung des RAM durch den Basic-Interpreter: Chaos über HIMEMHIMEM             (letztes benutzbares Datentypen: Bytes
Datenbreite: Bytes
Byte
) &AE7D &AE60 Basic-RAM-Ende (letztes Datentypen: Bytes
Datenbreite: Bytes
Byte
des Basic-Bereiches incl. Die Text-VDU: Zeichensatz
Der Zeichensatz des Schneider CPC: Der Zeichensatz des Schneider CPC
Zeichensatz
, I/O-Puffer und reservierter Bereiche für Maschinencode) &AE7F &AE62 Basic-RAM-Start (Anfang des Tokenisierungs-Puffers) &AE81 &AE64 Programm-Start (Zeiger auf Endbyte der 'nullten Zeile') &AE83 &AE66 Programm-Ende (normalerweise identisch mit Var.Start) &AE85 &AE68 Variablen-Start (Anfang der einfachen Unterprogramme: VariablenVariablen) &AE87 &AE6A Felder-Start (Anfang der dimensionierten Unterprogramme: VariablenVariablen) &AE89 &AE6C Felder-Ende (Zeiger auf erstes Datentypen: Bytes
Datenbreite: Bytes
Byte
des Memory Pools) &B08D &B071 Start der Datentypen: StringsStrings (Zeiger auf letztes Datentypen: Bytes
Datenbreite: Bytes
Byte
des Memory Pools) &B08F &B073 Ende der Datentypen: StringsStrings (normalerweise identisch mit Die Aufteilung des RAM durch den Basic-Interpreter: Chaos über HIMEMHIMEM)

Valid HTML   Valid CSS