                                                     13.Jan.2026
================================================================
Das Gesamtsystem  (alle Zahlen sind hexadezimal)
================================================================

memory-page 0  RAM0   vorgesehen als TextRAM
            1  ROM [20K] - TextRAM [10K] - Video-RAM [10K]
            2  RAM1   Haupt-RAM
            3  RAM2   Neben-RAM
            4  Slot4
            5  Slot5
            6  Slot6
            7  Slot7

Die Zuordnung der Adressregister P,X,Y,Z zu einer memory-page
erfolgt durch 3bit-Latches MP,MX,MY,MZ, welche die Werte 0..4
haben können, und durch das 2bit-Latch SL. Wenn M# den Wert 4
hat, dann liefert SL die unteren 2bit zur Page-Auswahl.

Und es gibt Austauschregister NP,NX,NY,NZ.
Das CPU-Signal B# tauscht M# - N#              # = P,X,Y,Z

In fc00..ffff von RAM1 findet Adressersetzung statt: Adr98 wird
mit SL xor-verknüpft.  Für jeden Slot sind 100 Byte reserviert.
Die Software des aktiven Slot findet die Bytes auf ff00..ffff

In 8000..8FFF  von memory-page 1 findet Adressersetzung statt:
Adr e wird mit PG xor-verknüpft. Das Flipflop PG legt fest,
welche von zwei gleichartigen RAM-Einheiten als Video-RAM
fungiert und welche als Text-RAM.

Das Display ist 200 Pixel breit und 100 Pixel hoch.
Die Pixel sind zweiwertig. Darstellung 76543210

c000  ................  ff00
----                    ----
----                    ----
c0ff  ................  ffff

Das Auslesen des Video-RAM zum Display stört nicht den Lauf
der CPU. Als Video-RAM kann ein Dual-Port-RAM verwendet werden.

Wirkung des CPU-Signals HA hängt ab von Adressleitungen 7..0

00      RK  read  keyboard
01      CK  clear keyboard / read DG   A7 wird DG
02      GK  read  keyboard mit Warten
03      negiere PG                       A wird 0

04      setze NP = 4                     A wird 0
05      setze NX = 4                     A wird 0
06      setze NY = 4                     A wird 0
07      setze NZ = 4                     A wird 0

08      lies den Wert  (SL .MP .NP)
09      lies den Wert  (SL .MX .NX)
0a      lies den Wert  (SL .MY .NY)
0b      lies den Wert  (SL .MZ .NZ)

0c+xx   setze SL = xx   Wenn Slot aktiv: A wird 0

10+xx   setze NP = 0xx                   A wird 0
14+xx   setze NX = 0xx                   A wird 0
18+xx   setze NY = 0xx                   A wird 0
1c+xx   setze NZ = 0xx                   A wird 0

20+xx   deaktiviere Slot xx
24+xx   aktiviere   Slot xx

28      dea SD
29      act SD
2a      rw1 SD
2b      rw4 SD
2c      seri
2d      sero

DG wird 1 durch einen Taster. Der Taster ist separat
angeordnet und mit einem Warnsymbol gekennzeichnet.

GK startet ein Monoflop, und es werden (AR/BN)-Zyklen eingefügt
mittels REP, bis das Monoflop abfällt (Cursor-Blinkdauer). Das
Monoflop fällt vorzeitig ab, wenn eine Taste gedrückt wird.
Bei GK und RK erhält A das Zeichen mit U=1 wenn vorhanden,
sonst U wird 0. Bei GK wird es automatisch gelöscht.
Bei RK bleibt das Zeichen erhalten bis CK.
Beim Loslassen der Taste wird stets das Zeichen gelöscht.

Bei Reset werden alle M# =1 und alle N# =1. Akku A erhält
den Wert (00000000) beim FPGA-Start, dann (W 1111111) mit
W=0 für Power-Up-Reset, W=1 für Tasten-Reset (Warmstart)
Die eingelesene Startadresse ist 0037.

================================================================

Zeichensatz
----------------------------------------------------------------
Zu jedem Code ist angegeben das Zeichen, durch welches er
dargestellt wird, und die Beschriftung jener Taste, welche
diesen Code liefert (SP=Leertaste).  Gesetztes Bit7
wird durch Unterstreichen des Zeichens dargestellt.
Die Zeichen 1c..1f und 5c..5f sind veränderlich.

| 00    SP      | 20 #   # %     | 40 hb  hb    | 60 0   0
| 01 €  sh-$    | 21 =   = ||    | 41 $   $     | 61 1   1
| 02 a  sh-A    | 22 +   + ne    | 42 A   A     | 62 2   2
| 03 b  sh-B    | 23 -   - |     | 43 B   B     | 63 3   3
| 04 c  sh-C    | 24 *   * '     | 44 C   C     | 64 4   4
| 05 d  sh-D    | 25 o   o "     | 45 D   D     | 65 5   5
| 06 e  sh-E    | 26 /   / !     | 46 E   E     | 66 6   6
| 07 f  sh-F    | 27 \   \ ?     | 47 F   F     | 67 7   7
| 08 g  sh-G    | 28 .   . ,     | 48 G   G     | 68 8   8
| 09 h  sh-H    | 29 :   : ;     | 49 H   H     | 69 9   9
| 0a i  sh-I    | 2a (   ( (m    | 4a I   I     | 6a xA  xA
| 0b j  sh-J    | 2b )   ) )m    | 4b J   J     | 6b xB  xB
| 0c k  sh-K    | 2c <   < <=    | 4c K   K     | 6c xC  xC
| 0d l  sh-L    | 2d >   > >=    | 4d L   L     | 6d xD  xD
| 0e m  sh-M    | 2e [   [ [m    | 4e M   M     | 6e xE  xE
| 0f n  sh-N    | 2f ]   ] ]m    | 4f N   N     | 6f xF  xF
| 10 o  sh-O    | 30 &   le      | 50 O   O     | 70 0^  FB
| 11 p  sh-P    | 31 ||  ri      | 51 P   P     | 71 1^  RB
| 12 q  sh-Q    | 32 %   lew     | 52 Q   Q     | 72 2^  UL
| 13 r  sh-R    | 33 |   riw     | 53 R   R     | 73 3^  BS
| 14 s  sh-S    | 34 '   can     | 54 S   S     | 74 4^  CR
| 15 t  sh-T    | 35 "   ins     | 55 T   T     | 75 5^  BK
| 16 u  sh-U    | 36 !   canb    | 56 U   U     | 76 6^  DL
| 17 v  sh-V    | 37 ?   insb    | 57 V   V     | 77 7^  MV
| 18 w  sh-W    | 38 ,   up      | 58 W   W     | 78 8^  ZB
| 19 x  sh-X    | 39 ;   dn      | 59 X   X     | 79 9^  AM
| 1a y  sh-Y    | 3a (m  upw     | 5a Y   Y     | 7a xA^ SM
| 1b z  sh-Z    | 3b )m  dnw     | 5b Z   Z     | 7b xB^ UM
| 1c ä  sh-Ä    | 3c <=  ups     | 5c Ä   Ä     | 7c xC^ EN
| 1d ö  sh-Ö    | 3d >=  dns     | 5d Ö   Ö     | 7d xD^ -C
| 1e ü  sh-Ü    | 3e [m  canl    | 5e Ü   Ü     | 7e xE^ -D
| 1f ß  sh-SG   | 3f ]m  insl    | 5f SG  SG    | 7f xF^ -E

Folgende Zeichen konnten hier nicht dargestellt werden:
3a,3b,3e,3f  modifizierte Version der Klammern ()[]
25  Kreis       5f  Großbuchstabe Sigma
40  der auf der Grundlinie liegende Bindestrich hb
70..7f  Ziffern mit Überstrich    Die Hex-Ziffern xA..xF
werden dargestellt durch modfizierte Großbuchstaben A..F

Statt des Zeichens 40 steht in dieser Dokumentation ein Punkt.

Die Ziffern mit Überstrich sind dazu gedacht, längere Ziffern-
folgen zu strukturieren und so leichter lesbar zu machen.

Die Buchstabentasten liefern Großbuchstaben, und Kleinbuch-
staben nur zusammen mit Shift. Es gibt aber einen Eingabe-
modus, welcher die Wirkung der Shift-Taste invertiert.

Die Tasten 20..2f sind beschriftet mit den Zeichen 20..2f
und den Zeichen 30..3f. Letztere sind über einen Alt-Modus
erreichbar. Entsprechendes gilt für die Zifferntasten.
Die Tasten 30..3f sind mit Pfeilsymbolen beschriftet.

Die Tasten 32,33,36,37,3a,3b,3e,3f kann man einsparen. Die
Codes werden dann geliefert durch sh+30,31,34,35,38,39,3c,3d.
================================================================

Adressen-Übersicht
----------------------------------------------------------------
=== RAM1 ===                       |   === ROM ===
0000      TF-Merker                |   0000  R00   Rückkehr
  01      ZV  VarNr-Offset fÜr RV  |
  02      TA  Top of A             |         Leiste de
  03      TC  Top of C             |         =========
  04..05  SA  Stackpointer A       |   00d0  ERR   Rückkehr
  06..07  SC  Stackpointer C       |     d2  COVE  Rückkehr
  08      Full                     |     d4  na-b8
  09      NV  Anzahl der RV        |     d6  na-8b
  0a      TB  Top of B             |     d8  na-75
  0b      TD  Top of D             |     da  na-57
  0c..0d  SB  Stackpointer B       |     dc  na-32
  0e..0f  SD  stackpointer D       |     de  na-23
  10..13  Replace-D-Tabelle        |
  14..17  Replace-E-Tabelle        |   00e0  FC KD-Routine
  18..1f  WS8     Arbeitsbereich   |     e2  FD KD-Routine
  20..2f  K-Zeile (Kommandozeile)  |     e4  GC KD-Routine
  30..37  Ed-WS   Arbeitsbereich   |     e6  GD KD-Routine
  38      MOD    (MPRO,MDAT,MASS)  |     e8  SC KD-Routine
  39      W1     (VarPos von W1 )  |     ea  SD KD-Routine
  3a      W2     (Varpos von W2 )  |     ec  LF Linefeed
  3b..3c  SAVE    Ablage           |     ee  FIND
  3d      XS  Start der CX-Datei   |
  3e      XL  Länge der CX-Datei   |         Leiste 400
  3f      LF      Parameter        |         ==========
  40..4f  KD-Par  Parameter        |   0400  in-A
  50..5f  KD-WS   Arbeitsbereich   |     02  in-B
  60..7f  SY-G Syszeile global     |     04  in-C
  80..9f  SY-L Syszeile lokal      |     06  in-D
  a0..bf  WS20    Arbeitsbereich   |     08  cone
  c0..ff  WS40    Arbeitsbereich   |     0a  disc
0100..01ff  WS100 Arbeitsbereich   |     0c  make
0200..023f  BF40  für KD-Routinen  |     oe  delt
0240..027f  Variablen der K-Zeile  |
0280..03ff  KEY-Strings            |----------------------------
0400..07ff  RV-Dir                 |   === Text-RAM ===
0800..      Stack A                |   8000..803f  die Zeichen
    ..f7ff  Stack C                |               1c..1f 5c..5f
f800..fbff  CX-Datei               |   8040..bfff  Zeilen 01..ff
fc00..ffff  reserviert für Slots   |                a 40 Zeichen
-----------------------------------|             Seite C  01..3f
=== RAM2 ===                       |             Seite D  40..7f
0000..      Stack B                |             Seite E  80..ff
    ..ffff  Stack D                |
----------------------------------------------------------------
Stackpointer A/B zeigt auf das erste freie Byte  über  Stack A/B
Stackpointer C/D zeigt auf das unterste besetzte Byte von St C/D

Wenn Stack B ganz RAM2 füllt ist Full=01  SB=0000  SD=0000
Wenn Stack D ganz RAM2 füllt ist Full=ff  SB=0000  SD=0000
Sonst ist Full=00
================================================================
Bei allen Adresszeigern und allen 2-byte-Längen gilt
low-byte unten, high-byte oben.  Bei relativen Zeigern ist
Zieladresse = (Adresse des high-byte des Zeigers) + Zeiger
================================================================

KD-Routinen (Keyboard/Display-Routinen)
----------------------------------------------------------------
SC|SD  Ausgabe von Seite C|D     (Dauer 19e00 Zyklen)
FC|FD  Eingabe eines Zeichens bei Darstellung von Seite C|D
GC|GD  Eingabe einer Teilzeile in Seite C|D

Bei Aufruf und Rückkehr: Standard-MN aber MY und NY getauscht
X Y S D V bleiben erhalten / Z wird 0042 / KD-WS wird Null
S wird abgelegt in SL/SH / FC|D,GC|D ändern BF40

Darstellung 10 Zeilen a 40 Zeichen und 1 Systemzeile SY-G/SY-L
                    SY-G wie vorgefunden   SY-L selbst erzeugt
KD-Par
40 SL KD-Routinen und Routine LF retten hier CPU-Register S
41 SH KD-Routinen und Routine LF retten hier CPU-Register S
42 ch Resultat von FC|FD
43 RC Rechter Rand bei  GC  //  PC<=RC<40  PD<=RD<40  PE<40
44 dC Displayzeile Seite C  //  40<=LD<80<=LE  dC,dD,dE <10
45 PC StartPos     Seite C  //
46 RD Rechter Rand bei  GD  // Der darzustellende Zeilenbereich
47 dD Displayzeile Seite D  // ergibt sich durch Koinzidenz von
48 PD StartPos     Seite D  // Zeile und Displayzeile. In Seite
49 LD Zeile        Seite D  // C ist Zeile = 30+Displayzeile
4a dE Displayzeile Seite E  //
4b PE Position     Seite E  //  FC,FD,GC,GD ändern dE PE LE
4c LE Zeile        Seite E  //              und    BS BE MR
4d BS Block-Start-Zeile     //  BS=BE=0  oder  BS und BE in
4e BE Block-Ende -Zeile     //  gleicher Seite mit BS <= BE
4f MR Randmarke   links     //                     MR <  40

================================================================
Routine LF    Linefeed in Seite C  (Dauer 5fe0 Zyklen)
----------------------------------------------------------------
V=1: 40-LF globale Linefeeds          Stets muß gelten:
V=0: 1 Linefeed der Zeilen LF..3f               0<LF<40
Anzahl  1 weniger wenn Zeile 3f leer war

Bei Aufruf und Rückkehr: Standard-MN aber MY und NY getauscht
X S bleiben erhalten / Z wird 003f / V wird 0 / Y wird 8fc0
S wird abgelegt in SL/SH
================================================================

Namen
----------------------------------------------------------------
Namenstring =      b Zeichen  /  Name =      8 Byte
Kurznamenstring =  7 Zeichen  /  Kurzname =  5 Byte
Mikronamenstring = 3 Zeichen  /  Mikroname = 2 Byte

Die ersten 2 Zeichen sind aus 40..5f, die übrigen aus 40..7f

Konversionsroutinen na-b8/8b|75/57|32/23    (5c|3c|1c Zyklen)
Y zeigt auf letztes Byte des Strings - bei Rückkehr auf erstes
Z zeigt auf letztes Byte des Namens  - bei Rückkehr auf erstes
MX MY MZ NX NY NZ X S bleiben erhalten / V bleibt erhalten |wird
bei na-b8/75/32 dann gesetzt wenn unzulässiges Zeichen auftritt

Konvertierung ist verträglich mit der kleiner-größer-Relation.
Bei Namenseingaben dürfen jenseits der Mindestlänge 3
am Ende stehende Zeichen 40 weggelassen werden.
================================================================

Steckkarten
----------------------------------------------------------------
0000.. Name
0008.. Zeiger auf Reset-Sequenz
000a.. Zeiger auf String-Wert-Konversionsroutine  /=0: keine
000c.. Zeiger auf Wert-String-Konversionsroutine  /=0: keine
000e.. Zeiger auf Mikronamen-Tabelle              /=0: keine
0010.. Felder 02..ff a 8 Byte (=Zeiger/Nummer/Kurzname)
0800.. Formelinterpreter

Die Kurznamen sind Kommandonamen, der Größe nach geordnet.
Nummer liefert dazu die Kommandonummer. Das ist die Nummer
02..ff des Feldes, in dem der Zeiger auf das Kommando steht.
Alle Kommandos 02..ff müssen vorhanden sein. Sie dürfen auch
Dummies sein, welche stets Error liefern.

Mikronamen-Tabelle: 80 Mikronamen der Mikro-Operationen
für den Formelinterpreter. Position 00..7f ist MOP-Code.
4 Teiltabellen s mit s=0..3 auf Positionen 4n+s. Ein
Mikroname darf in jeder Teiltabelle einmal vorkommen.

Der Formelinterpreter muß stets vorhanden sein, auch wenn es
keine Mikronamen-Tabelle gibt. Er darf auch ein Dummy sein,
welcher stets Error liefert.
================================================================

RV-Dir  Verzeichnis der residenten Variablen
----------------------------------------------------------------
40 Felder a 10 Byte
                             VarPos ist die Position 00..3f der
0. Zeiger auf Wert, relativ  Variablen in RV-Dir. Die Gesamtheit
2. Länge-1 des Werts         der Lücken bildet die Replace-RV-
4  (Lücke)                   Tabelle. Sie ist eine Permutation
5  l  unterer Stack-Nachbar  der Werte 00..3f. Bei NV= 00..40
6  h  oberer  Stack-Nachbar  Variablen sind die unteren NV Ein-
7  RV-Typ                    träge der Tabelle gültige VarPos.
8..f  Name der RV            Die übrigen Werte liefern die
                             freien Plätze in RV-Dir.
VarNr ist die Position 00..3f der VarPos in der Replace-RV-
Tabelle. Relative VarNr ist VarNr + ZV mod 100.
l,h sind VarPos. Sie werden =ff gesetzt wenn ein solcher Nachbar
auf demselben Stack nicht existiert.    TA,TB,TC,TD sind VarPos.
Sie werden =ff gesetzt wenn betreffender Stack keine RV enthält.
Beginnend mit TA|TB liefert die Folge der l die RV auf Stack A|B
Beginnend mit TC|TD liefert die Folge der h die RV auf Stack C|D
Während eines Programmlaufs müssen die gemäß l/h benachbarten RV
nicht dicht liegen wegen prozeduraler Variablen dazwischen.
================================================================
PV   Prozedurale Variable  (= Variable in Programmen)
----------------------------------------------------------------
PT =Variablen-Aufruf  ist relativer Zeiger auf TA
TA =Typ/Adresse       Adresse ist relativer Zeiger auf AL
                      bei Data auf letztes Byte des Werts
AL =Adresse/Länge-1   Adresse ist relativer Zeiger
                      auf erstes Byte des Werts

Der PT0 zeigt auf sein eigenes HighByte und liefert Typ 00.

Programme können RV acquirieren. Dabei wird ein freier TA
auf den AL in RV-Dir ausgerichtet und der Typ kopiert.
Acquirierbar sind N TP PG BF BO XP T1 T2 T3 XB E1 E2 E3.
Beim Acquirieren von BF bleibt die RV erhalten, sonst
wird sie durch Vergabe des Typs 00 deaktiviert.
================================================================
RV-Typ          s= 0|1|2|3  für Stack  A|B|C|D
======
00   Variable nicht verfügbar oder freies Feld in RV-Dir
01   W1 Arbeitsdatei in Stack C       nicht verschiebbar
02   W2 Arbeitsdatei in Stack D       nicht verschiebbar
03   N  Wert ist nicht installiert
04+s DR Nachlass von MDAT
08+s TP Programm-Rumpf   Fixbox ist abgetrennt
0c+s PG Programm
10+s AR Nachlass von MASS
14+s CO Code     nicht ausführbar
18+s BF DataBox  befestigt            nicht verschiebbar
1c+s BO DataBox
20+s XP Exe-Routine  nach INIT entstanden aus E1 oder E2
24+s T1 Exe-Rumpf        Fixbox ist abgetrennt
28+s T2 Exe-Rumpf        Fixbox ist abgetrennt
2c+s T3 Exe-Rumpf        Fixbox ist abgetrennt
30+s XB Exe-Routine  nach INIT entstanden aus E3
34+s E1 Exe-Routine  INITbar in RAM1
38+s E2 Exe-Routine  INITbar in RAM2
3c+s E3 Exe-Routine  INITbar in RAM1 und RAM2
40+4*n+s 1n  | NT-Datei - Der Name ist Erweiterung des Typs
80+4*n+s 2n  | n=0   : Datei frei
c0+4*n+s 3n  | n=1..f: Datei aktiv - muß in ihrem RAM bleiben
----------------------------------------------------------------
PV-Typ
======
00   freier TA   oder PT0
01   Prozedur in Programm             Adressierung speziell
02   Nc Wert ist nicht installiert    Länge konstant
03   N  Wert ist nicht installiert
04   Variable nicht verfügbar
05   aktive  Prozedur
06   aktives Programm in Stack A      nicht verschiebbar
07   aktives Programm in Stack C      nicht verschiebbar
08+s TP
0c+s PG
10+s BFc DataBox befestigt    Länge als konstant vorgemerkt
14+s BOc DataBox              Länge als konstant vorgemerkt
18+s BF
1c+s BO
20+s XP
24+s T1
28+s T2
2c+s T3
30+s XB
34+s E1
38+s E2
3c+s E3
40+k DataNinst k+1 Byte       nicht installiert
80+k DataConst k+1 Byte       konstant  in RAM1
c0+k Data      k+1 Byte                 in RAM1
================================================================

Leiste 400
----------------------------------------------------------------
in-A|B|C|D    installieren, uninstallieren, transportieren
==========
MX=MY=MZ=2 NX=3 NZ=0 NY X Y V=0  bleiben erhalten
Y=Zeiger-auf-Typ  im TA  oder  in RV-Dir
X wird abgelegt in SL/SH (KD-Par)  / S wird Länge-1  / Z wird 0

Falls Typ= N,Nc : installieren als BO,BOc             100 Zyklen
Falls installiert auf diesem  Stack: uninstallieren   100 Zyklen
Falls installiert auf anderem Stack: transportieren   6*Länge +
                                                      180 Zyklen
Bei Error Typ/Platzbedarf/nicht-Stackende
Rückkehr mit  V=1  S=0         100 Zyklen
----------------------------------------------------------------
cone      verbinden benachbarter Werte           100 Zyklen
disc      trennen   eines Werts                  100 Zyklen
====
MX=MY=MZ=2 NX=3 NY NZ X Y S V=0  bleiben erhalten

Y=Zeiger-auf-ersten  S=Zeiger-auf-zweiten-Typ  im TA | in RV-Dir
X wird abgelegt in SL/SH (KD-Par)   / Z wird 0

Die zweite Variable darf nur dann RV oder acquirierte RV sein
wenn auch die erste Variable RV oder acquirierte RV ist.

Bei Error Typ/acqu-Status/nicht-benachbart/Länge
Rückkehr mit  V=1                     100 Zyklen

cone   aus  BO+BO      wird  BO+N
       aus  TP+BO      wird  PG+N
       aus  T1|2|3+BO  wird  E1|2|3+N

disc   aus  BO+N      wird  BO+BO     es gilt die Länge von N
       aus  PG+N      wird  TP+BO     Länge von N wird ignoriert
       aus  E1|2|3+N  wird  T1|2|3+BO
----------------------------------------------------------------
make    erzeugen einer RV vom Typ N                60 Zyklen
====
MY=2 MX MZ NX NY NZ X Z S V=0  bleiben erhalten
Z zeigt auf letztes Byte eines Namens
Y wird Zeiger-auf-Typ in RV-Dir

Bei Error NV-Limit   Rückkehr mit  V=1  Y=0008     60 Zyklen
Ausschluss von Namenskollision obliegt dem rufenden Programm

delt    löschen  einer RV vom Typ N               240 Zyklen
====
MY=2 MX MZ NX NY NZ X Z S V=0  bleiben erhalten
S ist VarNr                         Y wird 0008

Bei Error Typ/VarNr  Rückkehr mit  V=1  Y=0008    240 Zyklen
================================================================
Routine FIND                                     11e0 Zyklen
============
MY=2 MX MZ NX NY NZ X Z  V=0  bleiben erhalten
Z zeigt auf letztes Byte eines Namens
Falls RV gefunden wird : S wird VarNr, Y zeigt auf Typ in RV-Dir
Falls RV nicht gefunden: S wird ffff , Y wird 0000

================================================================
================================================================

Exe-Routine  ist:   Le/Ad/Hauptroutine...IT-Routine.../Fixbox
===========
                 Le= Länge der Fixbox                 /=0: keine
                 Ad= relativer Zeiger auf IT-Routine  /=0: keine
================================================================
PG  Programm  ist:   Le/Kopf/Code/Folge-der-Prozeduren/Fixbox
============
    Prozedur = Kopf/Code        Le= Länge der Fixbox  /=0: keine
    Kopf=  TA- und AL-Zeiger der PV  +  Werte der Konstanten
           +  9 weitere Bytes (Par-Anzahl, Rückkehradresse, ..)

Die PV werden gelistet als    Parameter|UIB|UID|ACQ|CON|FIX|AUT
Sie werden realisiert durch      freier TA | N,Nc | DataNinst |
                    freier TA | DataConst | BFc,Data | BFc,Data

    Code = Folge von Operationen

In der folgenden Auflistung der Operationen steht PT für einen
Variablen-Aufruf.  Im Quelltext steht hier ein Variablen-Name.

*ACQU /nn PT ..   3+2v Byte / 40+40v Zyklen  v=1..3f Zahl der PT
      acquirieren der RV mit relativer VarNr nn, nn+1, ..
      durch die freien TA der Variablen PT

*UACQ             4 Byte / 30+20v Zyklen
      rückgängig machen einer ACQU-Operation

*FASN PT ..       2+2v Byte / 20+20v Zyklen  v=1..10 Zahl der PT
      Vergabe des Status befestigt an BO,BOc (werden BF,BFc)

*UFAS             4 Byte / 30+10v Zyklen
      rückgängig machen einer FASN-Operation

*BORR PT .. PTb   4+2v Byte / 60+30v Zyklen  v=1..20 Zahl der PT
      ausleihen des Werts der befestigten Box PTb in RAM1|2 an
      die Variablen PT. Aus  N, Nc, DataNinst(nur RAM1)  werden
      BF, BFc, Data. Ihre Werte überdecken den Wert der Box PTb

*BORX PT .. PTb PTx   6+2v Byte / 80+30v Zyklen  v=1..20
      ausleihen indexed eines Teils des Werts der Box PTb ab
      Index PTx an die Variablen PT     -   Index ist 2 Byte

*UBOR                 4 Byte / 30+10v Zyklen
      rückgängig machen einer BORR|BORX -Operation

-CALL PTp PT ..   4+2v Byte / 80+30v+20a Zyklen   v=0..1f
      Aufruf des Programms in RAM1 | der Prozedur   PTp
      a= Zahl der AUT-Variablen. Sie werden am Ende von Stack A
      installiert (Startwerte unbekannt). Parameter PT können
      nicht sein die Typen 04..07. Bei Übergabe von BF, BFc,
      DataConst, Data  bleibt der globale TA erhalten, sonst
      wird er durch Vergabe des Typs 04 deaktiviert.

+EXEC PTe PT ..   4+2v Byte / 40+T Zyklen  v=0..1f  T=Eigendauer
      Aufruf der EXE-Routine PTe vom Typ XP/XB

nCOMMAND /nn PT ..    3+2v Byte / 28+T Zyklen     v=0..1f
nCOMMAND PT ..        2+2v Byte / 28+T Zyklen     v=0..1f
      Aufruf des Kommandos COMMAND in Slot n      T=Eigendauer

n: MicroOp MicroOp ..  2+L Byte / 28+T Zyklen     T=Eigendauer
      Aufruf des Formelinterpreters in Slot n
                 Länge der MicroOp-Folge  L=1+x
   MicroOp ist    oMOP /nn PT   oder   oMOP PT      (4|3 Byte)
           oder   oMOP /nn      oder   oMOP         (2|1 Byte)
      Jede MicroOp beginnt mit MOP-Code
      Bit7 des MOP-Code ist 1 bei der letzten MicroOp
      Bit1 gibt an ob PT vorhanden. Bit0 gibt an ob /nn vor-
      handen. Slot kehrt erst nach der letzten MicroOp zurück

=INIT PTe PT     6 Byte / 60+T Zyklen
=INIT PTe        4 Byte / 60+T Zyklen
      initialisieren der Exe-Routine PTe. Aus E1|2|3 wird XP|XB
      T= Eigendauer der IT-Routine falls vorhanden

=TERM PTe        4 Byte / 60+T Zyklen
      entlassen der Exe-Routine PTe.      Aus XP|XB wird E1|2|3
      T= Eigendauer der IT-Routine falls vorhanden

=DLAY /nn        2 Byte / 10+nn Zyklen    Verzögerung

=P.1s     2 Byte / 20 Zyklen       s=0|1
      der 1-Bit-Wert s wird von oben auf den TF-Merker geschoben

=P.2s     2 Byte / 20 Zyklen       s=0|1|2|3
      der 2-Bit-Wert s wird von oben auf den TF-Merker geschoben

=PL.r     2 Byte / 20 Zyklen      r=1|2|3
      r Nullbits werden von unten auf den TF-Merker geschoben

=PP.r /nn PT     5 Byte / 50 Zyklen  r=0|1|2|3
                 Die obersten 3 Bit des TF-Merker bestimmen
      eine Bitposition im Byte nn. Die 1|2-Byte-Variable PT
      wird 8|10-fache Kopie dieses Bits. Danach werden
      r Nullbits von unten auf den TF-Merker geschoben.

=PZ.r /nn PT     5 Byte / 50 Zyklen  r=0|1|2|3
                 Die obersten 3 Bit des TF-Merker bestimmen
      eine Bitposition im Byte nn. Die 1|2-Byte-Variable PT
      wird Null, falls dieses Bit =0 ist. Danach werden
      r Nullbits von unten auf den TF-Merker geschoben.

=PM.r /nn PT     5 Byte / 50 Zyklen  r=0|1|2|3
                 Die obersten 3 Bit des TF-Merker bestimmen
      eine Bitposition im Byte nn. Die 1|2-Byte-Variable PT
      erhält Maxwert, falls das Bit =1 ist. Danach werden
      r Nullbits von unten auf den TF-Merker geschoben.

=TT.Z PT           4 Byte / 40 Zyklen
      von oben wird 0|1 auf den TF-Merker geschoben falls die
      1|2-Byte-Variable PT null ist | nicht null ist

=TT.M PT           4 Byte / 40 Zyklen
      von oben wird 1|0 auf den TF-Merker geschoben falls die
      1|2-Byte-Variable PT Maximalwert hat | nicht hat

=D.TA PT    4 Byte / 40 Zyklen     Die 1|2-Byte-Variable PT wird
            decrementiert, dann auf 0 getestet wie bei TT.Z

=D.TB PT    4 Byte / 40 Zyklen     Die 1|2-Byte-Variable PT wird
            auf 0 getestet, falls >0 ausserdem decrementiert

=INCR PT    4 Byte / 40 Zyklen
            Die 1|2-Byte-Variable PT wird incrementiert

=DECR PT    4 Byte / 40 Zyklen
            Die 1|2-Byte-Variable PT wird decrementiert

*RETN       4Byte / 80+10v+10n Zyklen     v= Zahl der Parameter
            Ende Programm/Prozedur    n= Zahl der UIB-Variablen
      Prüft bei UIB ob sie uninstalliert sind und setzt bei N
      die Länge-1 auf 0 zurück. Falls AUT vorhanden sind:
      prüft vor Uninstallieren ob sie am Stackende liegen

================================================================
Bei allen 2-Byte-Variablen gilt    LowByte oben / HighByte unten
================================================================

(Jr) /nn    5 Byte / 40 Zyklen    r=0..3
            bedingter Sprung. Die obersten 3 Bit des TF-Merker
     bestimmen eine Bitposition im Byte nn. Der Sprung erfolgt
     falls das Bit =1 ist. Nach der Auswertung werden
     r Nullbits von unten auf den TF-Merker geschoben

(JZ) PT     6 Byte / 40 Zyklen
            Sprung falls die 1|2-Byte-Variable PT =0 ist

(JS) PT     6 Byte / 40 Zyklen
            Sprung falls die 1|2-Byte-Variable PT >0 ist

(JM) PT     6 Byte / 40 Zyklen
            Sprung falls die 1|2-Byte-Variable PT
            Maximalwert hat

(JN) PT     6 Byte / 40 Zyklen
            Sprung falls die 1|2-Byte-Variable PT
            nicht Maximalwert hat

(JD) PT     6 Byte / 40 Zyklen
            Sprung und Decrementieren der 1|2-Byte-Variablen PT
            falls diese nicht =0 ist

(Jx) /nn PT   5+2*nn Byte / 40 Zyklen
              indexierter Sprung mit 1-Byte-Index PT
              erster  Fall:  Index = nn oder größer
              letzter Fall:  Index = 0

(JP)        4 Byte / 20 Zyklen     unbedingter Sprung

----------------------------------------------------------------
Quelltext bei MPRO
----------------------------------------------------------------
*IF.ccc    *ENDF         //      *IF.ccc    *ELSE    *ENDE

if         end if                if         else     end else
----------------------------------------------------------------
*LOOP      *RP.ddd       //      *L.JP      *HERE    *RP.ddd

loop       repeat if             Schleife mit Hineinsprung
----------------------------------------------------------------
ccc ist [0|1|2|3 /nn] oder [Z|S|M|N PT], ddd ist ccc oder [D PT]
----------------------------------------------------------------
*CASE /nn PT     *NEXT /nn     *LAST        nn absteigend bis 00
----------------------------------------------------------------
Alle  *IF.ccc  und  *RP.ddd  ausgeschrieben:
                                                 *RP.D var
*IF.0 /nn      *IF.Z var          *RP.0 /nn      *RP.Z var
*IF.1 /nn      *IF.S var          *RP.1 /nn      *RP.S var
*IF.2 /nn      *IF.M var          *RP.2 /nn      *RP.M var
*IF.3 /nn      *IF.N var          *RP.3 /nn      *RP.N var
----------------------------------------------------------------
An der Stelle von  ELSE, L.JP, NEXT  steht im Code ein (JP)
An der Stelle von  ENDE, LAST  steht im Code ein =DLAY /10
ENDF, LOOP, HERE  sind Marken ohne Entsprechung im Code

Variablennamen sind Kurznamen. Für PT kann anstelle eines
Variablennamens ein Zeichen 20 angegeben werden (PT0).
Bei -CALL und +EXEC ist anstelle von CALL|EXEC gleich der
Name des PTp|PTe anzugeben. Hinter UBOR ist der Name der
ersten Variablen des BORR|BORX anzugeben. Die BORR|BORX-
UBOR - (Pseudo-)Blöcke können einander überkreuzen.
================================================================

Schnittstellen
----------------------------------------------------------------
Standard-MN bedeute   MX=MY=MZ=2 NX=3 NY=1 NZ=4

nCOMMAND findet vor: Standard-MN NP=1 Z=0 V=0 Y=0010+n
         Register D enthält noch einmal die Kommandonummer
         S = 2v+c mit v=Anzahl der PT und c=1 wenn /nn
         vorhanden    X zeigt auf /nn oder den ersten PT
         oder die nächste Operation falls S=0

n Formelinterpreter findet vor: Standard-MN NP=1 Y=S=0 V=0
                    Z=0010+n    X zeigt auf ersten MOP-Code

+EXEC Exe-Routine findet vor: Standard-MN NP=1 Z=0,V=0,Y zeigt
                  auf eigenen TA  S=Anzahl der PT  X zeigt auf
                  ersten PT oder nächste Operation falls S=0

=INIT/TERM IT-Routine der Exe findet vor: Standard-MN NP=1 Z=0
           Y zeigt auf eigenen TA  V=0|1 für INIT|TERM  S=0|=1
           wenn bei INIT ein PT vorhanden  X zeigt auf nächste
           Operation oder den PT falls bei INIT vorhanden

================================================================
Rückkehr ohne Error nach R00 mit Standard-MN V=0
                    X zeigt auf nächste Operation

Rückkehr mit Error nach ERR.  X zeigt auf nächste Operation
    ersatzweise auf Startwert-2 bei Slot / Startwert-4 bei
    Exe-Routine.    Y-lowbyte wird als Benutzerinformation
    ausgegeben falls Y-highbyte >0. In KD-WS kann ein String
    übergeben werden. *PER Rückkehr aus Programm - in Seite D
    wird S als Erroradresse ausgegeben zusammen mit den Adressen
    der aktiven CALL-Operationen (reloziert auf Referenzlage der
    Programme).  *RER Rückkehr mit V=1.  Bei *PER und *RER nach
    Fehlermeldung Warten auf Reset. *QER quittieren mit Taste EN

    Error-Meldungen
    ===============
    bei Übersetzen der Kommandozeile: FORM  COMD  PARA
    bei Kommando-Ausführung:          ELSE
    bei MPRO/MDAT/MASS:      M.OFL1  M.OFL2  M.ELSE
    bei Programm-Operation:  PV.TYP  RV.TYP  BOSIZE  NOCARD
                                     NUMBER  A.SIZE  RETURN

String/Wert-Konversionsroutine findet vor: Standard-MN NP=1
            S=X=Y=Z=0 V=0  String linksbündig in WS40 /seine
            Länge-1 in 00bf. Rückkehr nach COVE mit Standard-MN
            Wert startbündig in BF40 /seine Länge-1 in 00bf

Wert/String-Konversionsroutine findet vor: Standard-MN NP=1
            S=X=Y=Z=0 V=0  Musterstring in WS40 /seine Länge-1
            in 00bf. Wert in BF40. Rückkehr nach COVE mit
            Standard-MN  String in WS40  Aus Musterstring
            ermittelte Länge-1 des Werts in 00bf

Beide bei Rückkehr: V=1 zeigt Error. Wert/String-Kr sollte nur
      dann Error liefern wenn Musterstring unzulässig.  Wert un-
      zulässig sollte am zurückgelieferten String erkennbar sein

Init-Sequenz findet vor: Standard-MN  NP=1  S=X=Y=Z=0  V=0
Rückkehr nach 00ee (FIND) mit V=1 Standard-MN.  Kein Error

================================================================
Erlaubte Aktionen  für nCOMMAND, Formelinterpreter, Exe-Routine:
----------------------------------------------------------------
beschreiben von WS20,WS40,WS100,BF40,RAM1/ff00..ffff (nur Slot),
WS8, TF-Merker, ZV, SAVE, LF/KD-Par mit Restriktionen, SY-G SY-L
KEY-Strings, Text-RAM, Video-RAM, Werten von Data (nicht Const)/
BO/BOc/BF/BFc, Längen von N (nicht Nc), Namen der RV ausser NT-
Datei, überschreiben von BO (nicht BOc,BF,BFc) passender Länge
mit  DR,AR,CO,10,20,30,TP,T1,T2,T3,PG,E1,E2,E3  unter Anpassung
des Typs (bei NT-Datei auch Name), umwandeln von DR..E3 in BO,
verwenden der Routinen der Leiste-de und Leiste-400, permutie-
ren der unteren NV Einträge der Replace-RV-Tabelle, verwenden
von CX-Datei/XS/XL nach Vorschrift, verwenden/umbenennen von
NT-Datei gemäß der dem Namen zugeordneten Spezifikation.
Die veränderlichen Zeichen im Text-RAM 8000..803f dürfen nur als
Block ersetzt werden - alle Zeichen müssen verschieden aussehen.
----------------------------------------------------------------
für Init-Sequenz, String/Wert-, Wert/String-Konversionsroutine:
----------------------------------------------------------------
beschreiben von WS8,WS20,WS40,WS100,BF40,RAM1/ff80..ffff
================================================================

Reset: Nur bei Kaltstart: Beschreiben mit 00 des Gesamt-RAM.
Initialisieren des ROM, danach ist das ROM schreibgeschützt.
Laden der Slot4-Software aus dem ROM. Aktivieren von Slot4.
Bei Kaltstart und Warmstart: Initialisieren des RAM1 und der
veränderlichen Zeichen. Deaktivieren von Slot 4 bis 7 ausser
Slot4 bei Kaltstart. Start der Kommandozeile.

================================================================
CX-Datei       10 Zeilen a 40 Zeichen
========       XS = 0...f  nächste zu lesende Zeile
               XL = 0..10  Anzahl der besetzten Zeilen

Beschreiben der Zeile XS+XL mod 10 falls XL<10 : XL wird XL+1
Auslesen der Zeile XS falls XL>0 : Die Zeile wird mit 00
        gefüllt.   XL wird  XL-1     XS wird XS+1 mod 10.
================================================================
Kommandozeile    Eingabe in Seite C Zeile 3f. Vorher Bedarfs-
=============    Linefeed, nachher Linefeed. Falls CX-Datei
nicht leer statt Eingabe Einlesen einer Zeile der CX-Datei mit
überschreiben von Zeile 3f und auch nachher kein Linefeed.
Kommandozeile löscht TF-Merker. Bei Eingabe wird in SY-G-Zeile
angezeigt ZV NV Replace-D-Tabelle Replace-E-Tabelle MOD.

Leerzeile oder #   Leerkommando
nCOMMAND /nn       Kommando in Slot n
nCOMMAND           Kommando in Slot n
=COMM /nn          ROM-Kommando
=COMM              ROM-Kommando
+ZZ                Aufruf der Exe-Routine mit relativer VarNr ZZ
-ZZ                Starten des Programms  mit relativer VarNr ZZ

Anstelle von ZZ kann der Name der RV angegeben werden     (FIND)

Es folgen 0..4 Variable. Diese können sein

#                       Wird übersetzt in  : freier TA
+Z..   1..b Ziffern aus 60..7f             : DataConst 1..6 Byte
-...   1..b Zeichen ohne Leerzeichen          : DataConst b Byte
=Name  3..b Zeichen                           : DataConst 8 Byte
*ZZ    2 Ziffern         : acquirierte RV mit relativer VarNr ZZ

Nach + und * kann anstelle von ZZ ein RV-Name angegeben
       werden. Es wird die relative VarNr eingesetzt.     (FIND)
Nach = kann anstelle eines Namenstrings eine relative VarNr
       angegeben werden. Es wird der Name der RV eingesetzt.

Die übersetzte Kommandozeile in 0020..002f hat für nCOMMAND
und Exe-Routine dasselbe Format wie eine Programm-Operation.

Bei Verwendung der CX-Datei ergibt sich die Ausführungszeit aus
dem in Programmen geltenden Wert plus der Übersetzungszeit
1000+1200*f Zyklen mit f= Zahl der FIND-Operationen.
Leerkommando 400 Zyklen.

nCOMMAND oder Exe-Routine kann feststellen ob der Aufruf aus
der Kommandozeile erfolgt, indem es X HighByte auf 00 prüft.
================================================================

Bei Kommandozeile und bei Programmausführung werden Slotnummern
gemäß Replace-D-Tabelle ersetzt. Bei MPRO/MDAT/EDAT wird für das
Auffinden der Kommandonamen, Mikronamen, Konversionsroutinen die
Replace-E-Tabelle verwendet. In den Tabellen stehen die Werte
                             0c + physikalische Slot-Nummer.

================================================================
ROM-Kommandos        Zur rechnerischen Dauer bei CX-Datei kommt
=============     die Übersetzungszeit 1000+1200*f Zyklen hinzu.

##########################################
Die angegbenen Zyklenzahlen sind nach dem
aktuellen Umbau derzeit nicht mehr gültig.
##########################################

=WARE    6300 Zyklen   Ausgabe der Namen der Steckkarten

=DIR     9200 Zyklen   Ausgabe der RV mit Stack-Abfolge, Seite D

=KEYS    interaktiv  anzeigen/ändern der den Tasten 40..5f
                     zugeordneten Key-Strings
             ändern: betreffende Taste  beenden: Leertaste

=PMD +ZZZZZZZZ     0 Zyklen   ändern der Replace-D-Tabelle
=PME +ZZZZZZZZ     0 Zyklen   ändern der Replace-E-Tabelle

=POS /nn           0 Zyklen   ZV wird nn
=POS /nn #         0 Zyklen   ZV wird nn-NV    mod 100
=POS /nn +ZZ       0 Zyklen   ZV wird nn+ZV-ZZ mod 100

=NEW =NEUNAME      1200 Zyklen  erzeuge RV mit Länge-1 = 0
=NEW =NEUNAME +ZZ     ........  erzeuge RV mit Länge wie RVar ZZ
=NEW =NEUNAME +ZZZZ     ......  erzeuge RV mit Länge-1 = ZZZZ

=LEN +ZZ +XX       0 Zyklen    Gib RVar ZZ die Länge von RVar XX
=LEN +ZZ +ZZZZ     0 Zyklen    Gib RVar ZZ die Länge-1 = ZZZZ

=RENA +ZZ =NEUNAME   1200 Zyklen    ändere Name  /  bei NT-Datei
                       bestätigen mit Taste EN während DG-Taster

=DEL +ZZ              180 Zyklen  lösche RVar ZZ vom Typ N
=DEL                  interaktiv  lösche RVars   vom Typ N
                      löschen: Taste EN  lassen: Leertaste

=IN.A|B|C|D +ZZ        40 Zyklen     installiere   RVar ZZ
=MV.A|B|C|D +ZZ     60100 Zyklen     transportiere RVar ZZ

=CONE +ZZ +XX          40 Zyklen     verbinde Werte
=DISC +ZZ +XX          40 Zyklen     trenne   Wert

=UI. +ZZ        40 Zyklen      uninstalliere RVar  von Stackende

=UI.A|B|C|D    interaktiv      uninstalliere RVars von Stackende
                            uninstall: Taste EN  Ende: Leertaste

=PL.A|B|C|D    interaktiv           schiebe Werte auf Gegenstack
                             schieben: Taste EN  Ende: Leertaste

=FASN +ZZ ... ... ...   0 Zyklen   Vergabe  des Status befestigt
=UFAS +ZZ ... ... ...   0 Zyklen   Wegnahme des Status befestigt

=FASN       interaktiv    ausführen: Taste EN  lassen: Leertaste
=UFAS       interaktiv    ausführen: Taste EN  lassen: Leertaste

=PERM       interaktiv    umordnen der RV  (Taste EN, Leertaste)

=COPY +ZZ +XX    60000 Zyklen   kopieren auf Box - Länge passend

=FORG +ZZ            0 Zyklen   umwandeln in Box

=FREE             c000 Zyklen   Stackpointer-Abstände ausgeben

=INIT *ZZ ...     Dauer und Wirkung wie in Programm
=TERM *ZZ         Dauer und Wirkung wie in Programm

=SSL /0x  deaktiviere Slot x              x,s = 4 bis 7
=SSL /1x  lade SYSCARD aus dem ROM und aktiviere Slot x
=SSL /sx  lade Bytes 8000 bis ffff von Slot s nach 0000 bis 7fff
          von Slot x und aktiviere Slot x. Kommando nur eingeben
          wenn gültige Slot-Software übertragen wird. Wenn bei
          Enter DG-Taster nicht aktiv, wird nichts ausgeführt.

================================================================
=MPRO   erzeugen von PG aus Text in Seite E.         Die jeweils
=====   einzigen Variablen in Stack C/D sind BO und werden W1/W2
MOD wird 02. Text wird ab Cursorposition wortweise aus Block ge-
holt (Punkt ignoriert / Backslash und Rest der Zeile ignoriert).
Wenn Text aufgebraucht Unterbrechung / Ende mit =ENDM oder neuer
Text und weiter mit =CONT. Bei ENDM W1/W2 wieder einzig in
ihren Stacks.
                Programm-Kopf (Reihenfolge einhalten):
*PGM  Name  Parameter  ...
*UIB  Name (bei N)  Name /nnnn (bei Nc)  ...
*UID  Name /nn  Name /nn  ...
*ACQ  Name  Name  ...                              unterstrichen
*CON  Name/# String  Name/# String  ...    String bis 40 Zeichen

# ist +,-,=,4..7    legt fest, wie der String zu übersetzen ist:

+Zahl / -String / =Name / 4..7 Konvertierung durch Slot 4..7

*FIX  Name /nnnn (bei box)  Name /nn (bei dat)  ...
*AUT  Name /nnnn (bei box)  Name /nn (bei dat)  ...

*BEGN (Code Start)

Nach RETN ist Mod=03. Beenden oder weiter mit Prozedur (im Kopf
steht PRO statt PGM). Die Prozedur muß vorher als ACQ vereinbart
worden sein. Ihr Name sollte einmalig sein.

Nach ENDM wird in Block Seite E ein Kurzlisting ausgegeben mit
den für das Lokalisieren von Laufzeitfehlern benötigten Adressen
der Operationen (reloziert auf Referenzlage). Dabei ist MOD=01.
Bei Unterbrechung Platz machen und =CONT bis Ende. MOD wird 00,
W1 wird PG, W2 wird wieder BO.

Rangfolge der Variablen bei Namensgleichheit:
Gesucht wird im Kopf der aktuellen Prozedur vom Ende her, dann
im Kopf der Mutter-Prozedur ... usw.   Bei  *PRO Name wird
Name vom Ende her gesucht ohne Rücksicht auf Baumstruktur.
----------------------------------------------------------------
=MDAT   erzeugen von BO-Inhalt und DR aus Text in Seite E.  Die
=====   jeweils einzigen Variablen in Stack C/D sind BO und wer-
den W1/W2. MOD wird 04. Text wird ab Cursorzeile 2-Zeilen-weise
aus Block geholt.  Unterbrechung /=CONT /=ENDM wie bei =MPRO.

erste Zeile:  Name  /nn  #  Name2  (# wie bei =MPRO/*CON)
zweite Zeile:   unterstrichener String   bis 40 Zeichen

Name2 setzt zuvor Adresszeiger auf Start der Variablen Name2
und ist nur zulässig vorherige Var das Ende von W1 erreicht
oder mit einer früheren Var bündig endet. Im selben Fall ist
MDAT beendbar und MOD wird jeweils 05.  In W1 abgelegt werden
die Werte vor dem ersten Name2. Nach ENDM wird MOD=00,
W1 wird wieder BO (mit Inhalt), W2 wird DR.
----------------------------------------------------------------
=EDAT     bearbeiten von Paaren BO/DR. Sie sind die einzigen
=====     Variablen in Stack C/D. Die Länge von BO wird geprüft.

Zum Adresszeiger passende Variable wird angezeigt.
   Taste 40: andere Var /Leertaste: diese Var
Wenn Var ausgewählt ist:
   Taste 40: Wert eingeben /Leertaste: Wert lassen
Wenn Dateiende erreicht:
   Taste 40: zurück zum Anfang /Leertaste: Ende
================================================================
=MASS   erzeugen von AR und CO aus Text in Seite E  /Die jeweils
=====   einzigen Variablen in Stack C/D sind BO und werden W1/W2
MOD wird 06. Text wird ab Cursor-Halbzeile zeilenweise von Posi-
tion 04..1f aus Block geholt. Wenn Text aufgebraucht Unterbrech-
ung / Ende mit =ENDM oder neuer Text und weiter mit =CONT. Bei
=ENDM müssen W1/W2 wieder einzige Variablen ihrer Stacks sein.

Var-Zeile ist  Name xx  oder  Name xx nnnn   Name ist 6 Zeichen.
Erstes x ist + für gültig oder - für ungültig. Zweites x
ist + für Public oder - für Local.  Die erste Variable ist das
Startlabel. Dort steht statt xx ein //  dann die Startadresse.
Labels erhalten Wert durch Setzen in Code-Zeile und sind als
ungültig zu vereinbaren.

Code-Zeile ist  =Label xxx   (=Label ist optional )
In der ersten Code-Zeile muss das Startlabel stehen

xxx ist ZZ..     bis zu 8 Byte ohne Leerzeichen
        Mnemonic               bei 00..3f  68..ff
        Mnemonic nn            bei 40..67
        Mnemonic Name+n        bei 40..55
        Mnemonic nn.mm         bei 5a..5f
        /.H.                         (Makro H.. H.. )
        /.J.                         (Makro H.. J.. )
        ##M%I                        (Makro ##M% I%E ##M% )
        ##M%D                        (Makro ##M% D%E ##M% )
        /GRD       nn oder Name+n    (Makro GTR nn  DC.A )
        /ARI       nn oder Name+n    (Makro ADR nn  IC.A )
        /ARD       nn oder Name+n    (Makro ADR nn  DC.A )
        /GTR     nnnn oder Name+n    (Makro GTR nn  AD. nn )
        /GTA     nnnn oder Name+n    (Makro GTA nn  AD. nn )
        /ADR     nnnn oder Name+n    (Makro ADR nn  AD. nn )
        /ADA     nnnn oder Name+n    (Makro IKL nn  AD. nn )
        /UR      nnnn oder Name+n    (Adresse relativ low high)
        /DR      nnnn oder Name+n    (Adresse relativ high low)
        /UA      nnnn oder Name+n    (Adresse absolut low high)
        /DA      nnnn oder Name+n    (Adresse absolut high low)
        //ZO     nnnn                ( 00-Block mit Endadresse)
        //ZL     nnnn                ( 00-Block mit Länge-1   )

Variablenaufruf Name+n mit Offset +n (+0 weglassen). Der Offset
ist signed: 8 bis f steht für -8 bis -1.            nn.mm  wird
bei IXL,IYL,IZL ersetzt durch das Byte mm-nn-1, bei DXL,DYL,DZL
durch nn-mm-1.          ## ist ST LV AV SV GT AN XR NR
Bei /UR ist Zieladresse = Adresse des HighByte  + Wert.
Bei /DR ist Zieladresse = Adresse des HighByte  - Wert.
Bei /GTR, /ADR, /UR, /DR  ist nnnn der Wert,
die Variable Name+n ist die Zieladresse.

Ab erster Code-Zeile ist MOD=07 und MASS ist beendbar.
=ENDM wertet Variable aus. MOD wird 00, W1/W2 wird AR/CO.
================================================================
=EASS     anzeigen von Paaren  AR/CO.  Sie sind die einzigen
=====     Variablen in Stack C/D. Kompatibilität wird geprüft.

Var-Zeile:  Links steht ein + wenn bei Variablen-Auswertung die
       Variable ungültig war oder Distanzfehler aufgetreten ist.
Das erste x nach dem Namen kann nun neben + und - auch = sein
(das steht für Label). Das zweite x nach dem Namen kann nun
neben + und - auch * (das steht für Public/referenziert)
und = (das steht für Local/referenziert) sein.

Leertaste: nächste Zeile      Taste 40: Abbruch

Code-Zeile:  Links steht ein + wenn bei Variablen-Auswertung die
        Variable ungültig war oder Distanzfehler aufgetreten ist.
    Bei allen Relativwerten ist angezeigtes nnnn die Zieladresse.

Leertaste: nächste Zeile      Taste 40: Abbruch

----------------------------------------------------------------
=COVE +ZZ    Umwandlung der Typen  30/20/10/CO/E3/E2/E1/BO
=========    Bei Ausgabe des Ausrufzeichens Taste EN drücken
             bei aktivem DG-Taster. Ohne Taster Abbruch.
================================================================

KD-Routinen  GC GD  aus Benutzersicht    & stehe für C oder D
=====================================
In SY-L wird angezeigt  Zeilenmode/Zeichenmode/Zeile/Position
                        /MR/BS/BE /Zeichenzahl im Buffer

Zeilenmode ist &B|&C|&D|&E  davor steht ein o

               &B      Basismode/ Eingabe Teilzeile in Seite &
               &C      betrachten von Seite C
               &D      betrachten von Seite D
               &E      Texteingabe in Seite E

        Taste  &B  &C  &D  &E  Ausgangsmode
           -C  &C  &B  &C  &C  Zielmode
           -D  &D  &D  &B  &D  Zielmode
           -E  &E  &E  &E  &B  Zielmode

Zeichenmode ist NNN    wenn Alt-Mod gesetzt statt erstem N ein A
                       wenn Sh-Mod gesetzt statt zweitem N ein S
                       wenn UL-Mod gesetzt statt drittem N ein U

UL -Mod: eingegebene Zeichen werden unterstrichen
Sh -Mod: eingeg Zeichen 01..1f und 41..5f werden vertauscht
Alt-Mod: eingeg Zeichen 20..2f werden durch 30..3f ersetzt
         eingeg Zeichen 60..6f werden durch 70..7f ersetzt
         eingeg Zeichen 40..5f rufen String aus KEY-Strings ab
                        00..1f ebenso doch ohne erstes Zeichen

Spos/Rpos seien linke/rechte Grenzposition ( =00/3f bei &C|D|E )

Taste le   Cursor nach links
      ri   Cursor nach rechts
      lew  Cursor 8 Positionen nach links
      riw  Cursor 8 Positionen nach rechts
      up   Cursor eine Zeile zurück
      dn   Cursor eine Zeile vorwärts
      upw  Cursor 8 Zeilen zurück
      dnw  Cursor 8 Zeilen vorwärts
      ups  Cursor und Text zusammen eine Zeile nach oben
      dns  Cursor und Text zusammen eine Zeile nach unten
      can  herausnehmen des Zeichens an Cursorposition
      ins  einfügen eines Leerzeichens - nur wenn das an
           Rpos herausfallende Zeichen ein Leerzeichen ist
      canb herausnehmen eines Zeichens - Umbruch bis Blockende
      insb einfügen eines Leerzeichens - nur wenn das Zeichen
           am Blockende ein Leerzeichen ist
      canl löschen der Teilzeile bis Rpos (retten in Buffer)
           Wenn sie bereits leer war heranrücken der
           folgenden Teilzeilen bis Blockende
      insl einfügen einer leeren Teilzeile - nur
           wenn die Teilzeile am Blockende leer ist

Taste -C Wechsel in die Seite C - Betrachtungsmodus
           oder von dort zurück in den Basismode
      -D Wechsel in die Seite D - Betrachtungsmodus
           oder von dort zurück in den Basismode
      -E wechsel in die Seite E - Texteditmodus
           oder von dort zurück in den Basismode
      AM negiert Alt-Mod /jede andere Taste löscht Alt-Mod
      SM negiert Sh -Mod
      UM negiert UL -Mod
      ZB löscht Buffer
      EN Enter - beendet GC/GD (nur im Basismode)
         in &E : zurück zu Ausgangsstelle /im Alt-Mod:
                 merkt Cursorstelle als Ausgangsstelle
      CR setzt Cursor auf Spos /wenn er dort ist auf MR
                 im Alt-Mod : setzt Randmarke MR
      BS Cursor nach links und löscht dortiges Zeichen
               im Alt-Mod Cursor fest und löscht dieses Zeichen
      FB kopiert Zeichen nach Buffer /Cursor rechts /nicht &B
                       kopieren des Zeichens an Rpos im Alt-Mod
      RB auslesen eines Zeichens aus Buffer /Cursor rechts
                                    auslesen an Rpos im Alt-Mod
      UL Zeichen verändern und Cursor rechts
           im UL-Mod: Unterstrich negieren  sonst: austauschen
           00.1f und 40.5f / 20.2f und 30.3f / 60.6f und 70.7f
      DL löschen der Teilzeile bis Rpos (retten in Buffer)
                Wenn sie bereits leer war: eine Zeile vorwärts
      BK wenn kein Block in dieser Seite: setzt BS und BE
         ist man ausserhalb von Block: versetzt die nähere Marke
         ist man auf einer Blockmarke: versetzt die andere Marke
         ist man im Inneren von Block: versetzt BE  /Alt-Mod BS
         beide Marken in Cursorzeile : löscht Blockmarken
      MV ist man in BS-Zeile rechts von MR:
         Spaltenvertauschung MR..Pos-1 mit Pos..3f
         ist man auf MR-Pos innerhalb von Block:
         Zeilenvertauschung BS..Zeile-1 mit Zeile..BE
         ist man in BS-Zeile links von MR | auf MR-Pos ausser-
         halb von Block :   Block kopieren an den Cursor (unter-
         bleibt komplett wenn Zielbereich zu klein | nicht leer)
----------------------------------------------------------------
KD-Routinen  FC FD   Vor dem Zeilenmode steht ein * . Im Basis-
==================   mode Eingabe eines Zeichens und Rückkehr.
                     -C/-D/-E werden abgefangen und ausgeführt
================================================================

Namens-Management bei NT-Datei
==============================
Folgende Konvention wird vorgeschlagen: Bei 1n ist der gesamte
Name typbestimmend und unveränderlich, bei 2n nur die ersten
7 Zeichen, bei 3n nur die ersten 3 Zeichen.

Eine Anwendung des Variablentyps NT-Datei
=========================================
Eine Datei des Typs 3n enthalte ein Unterprogramm-Paket zur
Verwendung durch Exe-Routinen. Man verwende n als Merker für
die Anzahl der Bezug-nehmenden Exe-Routinen. Eine Exe-Routine
erkennt bei INIT die Datei an den ersten 2 Bytes des Namens,
erhöht n um 1 und merkt sich die VarPos der Datei. Bei TERM
verringert sie n wieder. Solange n>0, ist die Datei vor Un-
installieren geschützt, ebenso jede Exe-Routine nach INIT.

Eine Anwendung der CX-Datei: Compilieren langer Quelltexte
==========================================================
Der Text liege seitenweise auf einem Massenspeicher in Slot n.
Ein nCOMMAND lädt die erste Seite in die Seite E des TextRAM und
schreibt in die CX-Datei die Zeilen  =MPRO  und  nCOMMAND, wobei
es sich mit der zweiten Zeile selbst erneut aufruft. Es lädt die
nächste Seite und schreibt in die CX-Datei die Zeilen =CONT und
erneut nCOMMAND, und so fort bis Textende.

Kommandonummer und kompatible Steckkarten
=========================================
Eine neuere Steckkarte enthalte zusätzliche Kommandos. Die
Tabelle der Kommandonamen ist verändert. Die Nummern der alten
Kommandos bleiben unverändert. So können bereits kompilierte
Programme weiterverwendet werden.

nCOMMAND -Schnittstelle  / die mit-übergebene Kommandonummer
============================================================
Es gebe Kommandos COMM1, COMM2, COMM3 mit aufeinanderfolgenden
Kommandonummern, welche im wesentlichen dasselbe tun, wobei
1..3 als Konstante fungiert. Man programmiere ein einziges
Kommando, auf welches alle 3 Kommando-Zeiger zeigen. Das
Kommando kann die Konstante aus der Kommandonummer ermitteln.








