home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
GEMini Atari
/
GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso
/
zip
/
language
/
modula2.zoo
/
read.me
< prev
Wrap
Text File
|
1989-06-16
|
30KB
|
635 lines
-------------------------------
Dokumentation zum Modula-System Stand 12.04.89
-------------------------------
Vorwort:
========
Dieses Modula-2-System wurde für Ausbildungszwecke konzipiert und wird
zur Programmierausbildung für Studenten der Fakultät Elektrotechnik und
Informationstechnik eingesetzt.
Mit dieser Public-Domain-Version soll nun allen an Modula-2 Interessierten
die Möglichkeit geboten werden, sich mit dieser Sprache zu beschäftigen.
Allerdings muß an dieser Stelle erwähnt werden, daß von Seiten des
Lehrstuhls keine Dokumentation oder ausführliche Anleitung zur Verfügung
steht und daß keinerlei Beratung (weder telefonisch noch schriftlich)
durchgeführt werden kann.
Die folgenden Hinweise können natürlich kein komplettes Handbuch ersetzen,
sollten aber für die normale Bedienung des Systems ausreichen.
1.0 Zusammenstellung der Diskette :
-----------------------------------
- AUTO (Ordner, mit RAM-Disk)
- DEF (Ordner, mit den DEFINITION-Modulen zur Bibliothek)
- GEMLIB (Ordner, mit SBM- & OBM-Files für GEM)
- STDLIB (Ordner, mit SBM- & OBM-Files der Standardmodule)
- SYSTEM (Ordner, mit SBM- & OBM-Files der Systemumgebung)
- STANDALO.NE (Ordner, mit OBM-Files, die der Linker benötigt)
- SBM (Ordner, mit SBM-Files, die in die RAM-Disk kopiert
werden)
- OBM (Ordner, mit OBM-Files, -"- )
- WORK (Ordner, mit den Files, die bearbeitet werden sollen)
- COPY.LST (Liste der Files die in die Ramdisk überspielt werden)
- RAMDISK.INF (Infodatei der RAM-Disk, Größe, Laufwerksbuchstabe ...)
- (EDITOR.PRG) (eigener Editor z.B. Tempus)
- M2PATH.TXT (Suchpfade der MODULA-SHELL)
- ERROR.IND (Fehlermeldungen für den Compiler)
- MK_COPY.PRG (Kopierprogramm. Es wird von der RAM-Disk aufgerufen)
- M2LOADER.PRG (hiermit wird die Shell gestartet)
- DEBUG.RSC
- M2SHELL.RSC
- DESKTOP.INF
- READ.ME
- COPYRIGH.T
2.0 Modula-Shell :
------------------
2.1 Hochfahren des Systems
- ATARI einschalten
- Modula-Diskette einlegen
... Der ATARI bootet und installiert die RAM - Disk
... Einige Files entsprechend der Datei COPY.LST werden in die
RAM - Disk geladen
Jetzt wird der M2LOADER durch Sie auf der RAM-DISK gestartet.
(Der M2LOADER liest M2Paths.txt; man kann daher auch M2Loader als
Anwendung anmelden und dann M2LOADER durch Doppelklick auf M2Paths
starten. Dazu braucht M2LOADER.PRG nicht auf der RAM-Disk sein)
Im LOADER starten Sie M2SHELL.OBM durch betätigen der RETURN-Taste.
...Die Modula-Shell wird nun geladen.
Jetzt müssen Sie nur noch das DATUM eingeben, falls dies noch nicht
geschehen ist und schon kann's losgehen.
2.1 Bedienung der Shell
- Das Menü 'Desk':
- M2-Shell: ein paar Informationen zum Modula-2 System.
- Das Menü 'Modul':
- Editieren, Übersetzen & Starten bezieht sich jeweils auf die
Arbeitsdatei (wird in der Desktop-Box angezeigt). Ist noch keine
Arbeitsdatei ausgewählt, so geschieht dies nach dem Anwählen über
die Fileselectorbox. Entsprechend wird nun der Editor, der Com-
piler oder die Datei selbst geladen und ausgeführt.
Diese Funktionen können auch über die Tastenkombinationen
<control> E, Ü & S erreicht werden.
- Editiere ..., Übersetze ... & Starte ... beziehen sich jeweils
auf eine Datei, die erst noch mit der Fileselectorbox ausgewählt
wird. Diese Funktionen können auch über die Tastenkombinationen
<alternate> E, Ü & S erreicht werden.
- PRG erzeugen bezieht sich auf die aktuelle Arbeitsdatei und ruft
den Linker auf, der die importierten Module zusammenbindet und ein
lauffähiges Programm erzeugt. Erraten, das geht auch mit <control> L.
- Ende oder <control> X und die Shell wird verlassen, in der File-
selectorbox des M2LOADER muß dann <Abbruch> gewählt werden.
- Das Menü 'Optionen':
- Mit Modul auswählen oder <control> A kann die Arbeitsdatei festge-
legt werden.
- Mit Suchpfade ändern oder <control> P können die Pfade auf welchen
die Shell oder der Compiler die benötigten SBM- bzw. OBM-Files sucht
geändert werden.
- Mit Terminal öffnen bzw. <control> T können z.B. die letzten
Ausgaben eines Programms noch einmal untersucht werden, dazu wird das
Terminal-Window geöffnet.
- Compiler, Debug: ein paar Parameter können hier geändert werden,
die voreingestellten Werte sind Erfahrungswerte und müssen in den
wenigsten Fällen geändert werden.
- Editor: Hier kann der verwendete Editor gewählt werden, wobei gilt:
linker Eintrag: Editor als PRG-File
rechter Eintrag: Editor als OBM-File
Der gewählte Editor wird unter dem angezeigten Namen
gesucht. Beim 'PRG-Editor' wird er auf dem Pfad erwartet,
von dem aus der M2LOADER gestartet wurde.
Editor resident bezieht sich auf den 'OBM-Editor'.
- Backup: Der gerade bearbeitete Text (beim Aufruf des Editors) wird
auf dem angegebenen Pfad noch einmal abgespeichert, wenn ein Backup
gewünscht wird. Das ist besonders zu empfehlen, wenn sich die
Arbeitsdatei in der RAM-Disk befindet.
- mit *.DEF, *.MOD bearbeiten (<control> D, M) kann man einstellen ob
ein DEFINITION oder (IMPLEMANTATION) MODUL bearbeitet werden soll.
Das bezieht sich im besonderen auf den Compiler (existiert TEST.DEF
und TEST.MOD und soll TEST.DEF übersetzt werden, dann *.DEF bearbeiten
wählen und den Compiler aufrufen), außerdem werden dann in der File-
selectorbox nur *.DEF bzw. *.MOD angezeigt.
- Das Menü 'Datei':
- Kopieren, Löschen & Umbenennen: Es wird jeweils über die File-
selectorbox das entsprechende File ausgewählt und danach entweder
das Zieldirectory oder der neue Name bestimmt.
- Ausführen: Es kann ein Programm (*.PRG) gestartet werden.
3.0 Informationen über Linker, Debugger und Compiler :
------------------------------------------------------
3.1 Allgemeines:
- Die Arbeitsumgebung ist in Schichten aufgebaut. Unterste Schicht ist
der M2LOADER. Auf M2LOADER liegt dann (normalerweise) M2SHELL. Dies
ist ein Objektmodul d.h. es kann nicht ohne den M2LOADER laufen.
M2SHELL ruft dann ihrerseits Editor und Compiler auf.
Wird ein compiliertes Programm gestartet, so läuft es, wenn es
noch nicht gelinkt ist, wie alle ".OBM"- Programme unter Kontrolle
von M2LOADER, der bei Laufzeitfehlern den Debugger starten kann.
M2SHELL, der Compiler, der Editor und der Debugger bleiben, wenn sie
einmal geladen sind, resident.
- M2PATHS.TXT.
Diese Datei kann wie jede Textdatei mit dem Editor bearbeitet werden.
In ihr stehen Suchpfade, die der Compiler, der Debugger, die Shell
und M2LOADER auf der Suche nach Dateien benutzen.
Außerdem kann der Defaultaufruf des M2LOADER eingetragen werden. D.h.
diejenige Objekt-Datei, deren Name in der letzten Zeile nach @M steht,
wird vom M2LOADER vorgewählt und kann durch Anklicken von [OK] gestartet
werden.
In der vorletzten Zeile dieser Datei steht der Suchpfad (der letzte
Suchpfad) der als Default für Funktionen wie Modul auswählen usw.
verwendet wird.
Der vorletzte Suchpfad wird als Voreinstellung für den Backup-Pfad
verwendet und sollte sinnigerweise keine RAM-Disk als Ziel haben.
Fehlt die Angabe des Laufwerkes in einem Pfad, so bezieht sich dieser
auf den aktuellen Pfad des GEMDOS, im allgemeinen der Pfad von dem aus
der M2LOADER gestartet wurde.
Jeder Pfad muß mit '\' enden, denn intern wird nur noch der Filename an
den Pfad angehängt.
Maximal 15 Pfadnamen können angegeben werden.
3.2 Der Linker (Standalone Programme):
- Da man, wenn man "ernsthaft" programmieren will Programme ohne
den Schutz von M2LOADER laufen lassen will, muß man die compi-
lierten Objektmodule binden (linken). Dazu muß sich der Ordner
STANDALO.NE auf dem Laufwerk befinden, von dem M2LOADER geladen
wurde, d.h. Benutzer einer RAM-Disk müssen diesen Ordner mit Inhalt
per Maus, oder per COPY.LST automatisch, in die RAM-Disk kopieren.
Der Inhalt von STANDALO.NE sollte auf keinen Fall verändert werden!
Der Linker wird durch "PRG erzeugen" gestartet. Er sucht sich
dann alles zusammen, was er braucht (GEMX.OBM, PATH.OBM, HEAP.OBM, ...)
und erzeugt dann ein lauffähiges PRG-File aus allen nötigen OBM-Files.
(Diese müssen dann auch auf den Suchpfaden vorhanden sein). Der Linker
überprüft dabei die Module auch auf Versionskonflikte. Findet der
Linker ein OBM-File nicht, so gibt er dem Benutzer die Chance,
per "Hand" die gesuchten Module zu finden. Die fertigen Programme
werden, wenn keine Fehler auftraten, im gleichen Ordner wie das
OBM-File abgelegt.
Wichtig: Programme können nach dem Linken ein anderes Verhalten zeigen
wie beim Aufruf aus der Shell. Das liegt daran, daß von der
Shell bzw. Loader (vom Programmierer oft nicht wahrgenommen)
eine Reihe von Funktionen zur Verfügung gestellt werden, die nun
fehlen bzw. selbst eingerichtet werden müssen (z.B. Textausgabe,
Exceptionbehandlung usw.).
3.3 Der Debugger:
- Der Debugger ist ein Source-Level-Debugger, der nach einem "Programm-
absturz" aktiv wird (Post-Mortem-Debugger). Dazu wird er nach einem
Laufzeitfehler vom M2LOADER gestartet und zeigt im Textfenster den
Programmsourcetext; die Fehlerzeile ist dabei fett gedruckt.
Alle beim Fehlerauftritt sichtbaren Variablen können angezeigt werden.
Sichtbar sind alle gobalen Variablen und die lokalen Variablen aller
Prozeduren der aktuellen Prozeduraufrufkette.
Dazu bedarf es aber der RFM-Files der entsprechenden Module.
Es gibt fünf Fenster:
- Quelltext:
Da steht (hoffentlich) der Quelltext drin, in dem der Fehler auf-
trat. Ist das Fenster leer, so ist der Quelltext zum entsprechenden
Modul nicht erreichbar. Wenn der Quelltext in einem der Suchpfade
liegt, führt das Anklicken des Modulnamens im Modulfenster (meistens)
zum Erfolg.
- Prozeduraufrufkette und Datenfenster 1:
Diese beiden Fenster gehören zusammen. Das linke Fenster (Proze-
duraufrufkette) zeigt, in welcher Reihenfolge die Prozeduren auf-
gerufen wurden. Die oberste ist die Prozedur in der der Fehler auf-
getreten ist. Im rechten Fenster können die Variablen, die in der
ausgewählten Prozedur sichtbar sind, auf ihren Inhalt hin untersucht
werden.
- Modulliste und Datenfenster 2:
Hier gilt gleiches wie oben, nur daß hier alle Module angezeigt werden,
die sich gerade im Speicher befinden. Sofern die RFM-Files der Module
auf den Suchpfaden liegen, können die dort sichtbaren Variablen
untersucht werden.
- Durch Anklicken von Prozedur bzw. Modulnamen kann man diese
Prozedur bzw. dieses Modul betrachten, d.h. die dort sichtbaren
Variablen.
- Zu den Datenfenstern ist die Darstellung strukturierten Datentypen
(Arrays , Records) und die Darstellung der Pointer auf diese Datentypen
zu erwähnen. Beide sind durch "*" gekenzeichnet. Klickt man diesen an,
so "betritt" man das Array/Record. In der ersten Zeile des Fensters
erscheint nach einem "." der Name der angeklickten Variablen. Bei
tiefer strukturierten Datentypen können dort durchaus mehrere Bezeichner
durch "." getrennt hintereinander stehen (z.B. bei der Analyse einer
verketteten Liste ). Durch Anklicken der Bezeichner kann man dann
wieder "herauf"steigen.
- Variablen vom Typ BITSET, SET OF ... bzw. ADDRESS werden in hexa-
dezimaler Form ausgegeben.
- Die Menüeinträge erklären sich, wenn ein wenig mit ihnen 'gespielt'
wird, bald von selbst.
Hinweis: Error Process
Modula bietet eine Schnittstelle zum Arbeiten mit Coroutinen
(= Multitasking). Dazu wird der Datentyp "PROCESS" verwendet. Der
Debugger analysiert beim Doppelklick auf eine Variable vom Typ PROCESS
den lokalen Stack dieser Task. Soll auf den Stack der "abgestürzten" Task
zurückgekehrt werden, so muß der Menüpunkt Error Process angewählt werden.
- FEHLER: Wenn in einer WITH-Anweisung der Programmablauf gestoppt wird,
stürzt der Rechner beim Fortsetzen des Programmes ab, sofern auf die
dereferenzierte Variable noch innerhalb dieser WITH-Anweisung zugegriffen
wird.
Nach Aufruf des Debuggers kann es passieren, daß anschließend mit Tempus
abgespeicherte Dateien mehrfach unter dem gleichen Namen abgelegt werden.
Bei der Rückkehr in die Shell werden diese in *.X?? umbenannt, wobei X für
den ursprünglichen Buchstaben der Extension steht und ? für eine Ziffer,
Es wird durch eine Alertbox darauf hingewiesen.
Dieser Test beschränkt sich allerdings auf das aktuelle File das vor dem
Aufruf des Editors bestimmt wurde.
(Dieser Fehler sollte nun behoben sein!)
3.3 Der Compiler:
- Der Compiler ist ein Single-Pass-Compiler, alle Bezeichner müssen vor
ihrer Verwendung deklariert werden. Sollte dies für Prozeduren nicht
möglich sein, so ist eine FORWARD Anweisung zu verwenden, die auf der
gleichen Schachtelungstiefe wie die anschliessende Deklaration selbst
erfolgen muß. Syntax: wie bei der Prozedur-Deklaration und dabei
den BEGIN-END; - Block durch FORWARD; ersetzen.
- Werden beim übersetzten einer Datei importierte Module nicht auf den
Suchpfaden gefunden, so können Sie diese von Hand aufsuchen.
- Wenn Fehler gefunden wurden, so wird eine Datei *.ERR erzeugt, in der
neben Zeile und Spalte des Fehlers auch die Fehlermeldung zu finden ist.
- Die SBM-, RFM- und OBM-Files werden im gleichen Ordner wie die
Quelltexte abgelegt.
- Wird der Compiler mit einer Datei mit Extension *.CM? (? = beliebiges
Zeichen) aufgerufen, so erwartet er darin eine Liste von Modulnamen
(mit Extension). Die Module werden dann in dieser Reihenfolge über-
setzt. Dies eignet sich, wenn in einem größeren Programmpaket ein
DEFINITION MODUL geändert werden mußte, um ein komplettes Update zu er-
zeugen (ähnlich einem Make).
4.0 Allgemeine Hinweise:
------------------------
- Diese Diskette enthält einen zum Modula-System passenden Editor
(M2Editor). Da aber zum einen dieser Editor noch nicht 100 % ausge-
testet ist und zum anderen ein Editor Geschmacksache ist, kann jeder
andere Editor verwendet werden.
- Als Editor eignet sich (neben dem beiliegenden Editor) Tempus ausge-
zeichnet.
- Die Voreinstellungen können mit einem Resource-Construction-Set leicht
an eigene Wünsche angepaßt werden. Es ist nur darauf zu achten, daß der
Objektbaum nicht neu konstruiert wird (die Shell geht natürlich weiter-
hin von ihrer Objektstruktur aus).
Der Name des Editors kann ebenfalls geändert werden (max. 8 Zeichen).
Der Editor wird dann unter diesem Namen mit Extension *.PRG (linker
Eintrag) bzw. *.OBM (rechter Eintrag) gesucht.
- Wenn ein 1040'er verwendet wird, empfiehlt es sich das System wie folgt
einzurichten:
- Die RAM-Disk mit etwa 200 kByte installieren.
- Die SBM-Files in den Ordner SBM in der RAM-Disk.
- Die oft benötigten OBM-Files in den Ordner OBM in der RAM-Disk
- den Ordner WORK mit den Files die gerade von Ihnen bearbeitet werden
auf die RAM-Disk.
- ohne Ordner auf der RAM-Disk den Editor (mit *.RSC), die Datei
ERROR.IND sowie M2PATH.TXT.
- Nun auf M2LOADER.PRG eine Anwendung mit Extension *.TXT anmelden.
- DESKTOP.INF sichern.
- nun kann durch Doppelklick auf M2PATH.TXT in der RAM-Disk der M2LOADER
gestartet werden.
- M2LOADER glaubt sich von der RAM-Disk gestartet, und es werden
zusätzlich 25 kByte in der RAM-Disk frei.
- Das Pseudo-Modul SYSTEM exportiert folgende Bezeichner:
VAL, ADR, ADDRESS, LONG, SHORT, BYTE, WORD,
SETREG, REG, INLINE, CODE.
In aller Kürze:
- VAL und ADR wie bei N. Wirth.
- LONG und SHORT wandeln zwischen den verschiedenen Datenlängen um.
Bsp. mit Typen: LONG(CARDINAL) = LONGCARD.
- BYTE und WORD sind 'Universaltypen' der entsprechenden Länge.
- SETREG und REG setzen und lesen die Register des MC68000
dabei gilt die Zuordnung der Registernummern:
D0 -> 0, D1 -> 1, ... A0 -> 8, ... A7 -> 15.
In die Register werden nur 32 Bit Worte geschrieben.
Aufruf: SETREG( RegisterNummer, 32BitWort )
32BitWort := REG( RegisterNummer )
als 32 BitWort wird LONGINT und ADDRESS akzeptiert.
- INLINE es kann Maschinensprache Code integriert werden.
Bsp. INLINE( Zahl1, Zahl2, Zahl3 ) oder INLINE( Zahl1 ).
Zahl? muß vom Typ CARDINAL und eine Konstante sein.
- LONG-Konstanten müssen durch Anfügen von D als solche gekennzeichnet
werden (323.0E23D ist eine LONGREAL-Konstante).
- Zahlen in hexadezimaler Form können durch Anfügen von H gekennzeichnet
werden, die erste Ziffer muß dennoch eine Zahl sein, also nicht FFH,
sondern 0FFH
- Aufzählungstypen haben maximal 256 Elemente.
- Die Set-Grösse ist auf 16 (Wortgröße) beschränkt.
Zum Schluß wünsch' ich allen Benutzern viel Spaß.
M.Bayer
===========================================================================
Kurze Anleitung des beiliegenden Editors :
==========================================
Editorfunktionen Referenzliste
==================================================================
Funktionsname ! Menü ! Code ! Beschreibung
--------------+--------+----------+------------------------------------
ProgInfo ! Desk ! CA ~ I ! Infobildschirm zeigen
ProgQuit ! File ! CA ~ Q ! Programm verlassen
FileOpen ! File ! CA ~ O ! Datei in neues Fenster laden
FileLoad ! File ! CA ~ L ! Datei in aktuelles Fenster laden
FileMerge ! File ! CA ~ M ! Datei im aktuellen Fenster einfügen
FileSave ! File ! CA ~ S ! Text mit neuem Namen speichern
FileUpdate ! File ! CA ~ U ! Text direkt speichern
FileBackup ! File ! CA ~ B ! Text speichern, altes File -> .BAK
FileDelete ! File ! CA ~ D ! Datei löschen
--------------+--------+----------+------------------------------------
WindowOpen1 ! Window ! C ~ ( ! Fenster 1 öffnen
WindowOpen2 ! Window ! C ~ ) ! Fenster 2 öffnen
WindowOpen3 ! Window ! C ~ / ! Fenster 3 öffnen
WindowOpen4 ! Window ! C ~ * ! Fenster 4 öffnen
WindowFull1 ! - ! S ~ ( ! Fenster 1 auf volle Größe bringen
WindowFull2 ! - ! S ~ ) ! Fenster 2 auf volle Größe bringen
WindowFull3 ! - ! S ~ / ! Fenster 3 auf volle Größe bringen
WindowFull4 ! - ! S ~ * ! Fenster 4 auf volle Größe bringen
WindowClose1 ! Window ! A ~ ( ! Fenster 1 schließen
WindowClose2 ! Window ! A ~ ) ! Fenster 2 schließen
WindowClose3 ! Window ! A ~ / ! Fenster 3 schließen
WindowClose4 ! Window ! A ~ * ! Fenster 4 schließen
--------------+--------+----------+------------------------------------
TextDelete ! Edit ! CA ~ DEL ! Text eliminieren, Fenster schließen
SearchDefine ! Edit ! SC ~ S ! Suchparameter definieren
SearchStart ! Edit ! C ~ S ! Suchen starten
ReplaceDefine ! Edit ! SC ~ R ! Ersetzparameter definieren
ReplaceStart ! Edit ! C ~ R ! Ersetzen starten
--------------+--------+----------+------------------------------------
TextStart ! Jump ! SC ~ CU ! Textanfang anspringen
TextEnd ! Jump ! SC ~ CD ! Textende anspringen
TextLine ! Jump ! C ~ G ! Textzeile anspringen
ErrorFirst ! Jump ! C ~ F ! ersten Fehler anspringen
ErrorLast ! Jump ! C ~ L ! letzten Fehler anspringen
ErrorNext ! Jump ! C ~ N ! nächsten Fehler anspringen
ErrorPrevious ! Jump ! C ~ P ! vorherigen Fehler anspringen
--------------+--------+----------+------------------------------------
BlockMark ! Block ! A ~ B ! Zeilenblock markieren
BlockHide ! Block ! A ~ H ! Markierung löschen
BlockDelete ! Block ! A ~ D ! Block löschen
BlockMove ! Block ! A ~ M ! Block verschieben
BlockCopy ! Block ! A ~ C ! Block kopieren
--------------+--------+----------+------------------------------------
ModeIndent ! Mode ! C ~ I ! Indentmodus ein/ausschalten
ModeInsert ! Mode ! S ~ INS ! Insertmodus ein/ausschalten
ModeTab ! Mode ! C ~ TAB ! Tab-Weite definieren
--------------+--------+----------+------------------------------------
CharRight ! - ! CR ! ein Zeichen nach rechts
CharLeft ! - ! CL ! ein Zeichen nach links
CharReduce ! - ! BSP ! ein Zeichen links lösch.
CharDelete ! - ! DEL ! ein Zeichen auslöschen
CharInsert ! - ! INS ! ein Zeichen einfügen
--------------+--------+----------+------------------------------------
LineRight ! - ! S ~ CR ! an das Zeilenende
LineLeft ! - ! S ~ CL ! an den Zeilenanfang
LineDown ! - ! CD ! Zeile runter
LineUp ! - ! CU ! Zeile rauf
LineTailDelete! - ! S ~ DEL ! Zeile ab Cursor löschen
LineReduce ! - ! C ~ BSP ! Zeile vorher löschen
LineDelete ! - ! C ~ DEL ! Zeile herauslöschen
LineInsert ! - ! C ~ INS ! Zeile einfügen
LineDownSwap ! - ! C ~ + ! Zeile runter schieben
LineUpSwap ! - ! C ~ - ! Zeile rauf schieben
LineDouble ! - ! C ~ ENT ! Zeile verdoppeln
LineUndo ! - ! UNDO ! Zeile restaurieren
--------------+--------+----------+------------------------------------
Eol ! - ! RET ! Zeile abschließen
EolLineInsert ! - ! S ~ RET ! Return + neue Zeile
EolBackspace ! ! SC ~ BSP ! Zeile(n)+Zeile(n-1)
EolDelete ! ! SC ~ DEL ! Zeile(n)+Zeile(n+1)
EolInsert ! ! SC ~ INS ! (C~RET) Zeilenrest in neue Zeile
--------------+--------+----------+------------------------------------
TabRight ! - ! TAB ! nächste TAB-Position anspringen
TabLeft ! - ! S ~ TAB ! vorherige TAB-Position anspringen
ScrollUp ! - ! S ~ CU ! Text nach unten schieben
ScrollDown ! - ! S ~ CD ! Text nach oben schieben
ScreenUp ! - ! C ~ CU ! ein Bildschirm rauf
ScreenDown ! - ! C ~ CD ! ein Bildschirm runter
M o d u l a - U n t e r s t ü t z u n g :
Da der Altex-Editor speziell für das Modula-2-System entwickelt
wurde, enthält er einige Besonderheiten, die das Schreiben von
Modula-Programmen erleichtern.
Modula-Assistent:
Bei der Eingabe eines Modula-Programmes befindet man sich wegen
der Variablen und Kommentare normalerweise im Kleinschriftmodus.
Soll nun ein Modula-Schlüsselwort eingegeben werden, so muß man
entweder in den Großschriftmodus umschalten, oder die SHIFT-Taste
gedrückt halten. Dieses und die Eingabe des Schlüsselwortes
selbst kann man sich nun vom 'Modula-Assistenten' abnehmen
lassen. Für jedes bekannte Schlüsselwort existiert eine maximal
zwei Buchstaben lange Abkürzung, die nach Drücken der HELP-Taste
(Der Cursor muß dazu genau hinter der eingegebenen Abkürzung
stehen!) in die korrekte, ausführliche Modula-Schreibweise umge-
wandelt wird.
Beispiel: p <HELP> wird zu 'PROCEDURE' expandiert ...
Beispiel: ew <HELP> wird zu 'END(*WHILE*);' umgewandelt ...
Nachfolgend eine Liste der Modula-Schlüsselwörter und ihrer
Abkürzungen:
Schlüsselwort | Kürzel Schlüsselwort | Kürzel
-----------------------+-------- --------------+--------
ABS( | AB LONGINT;_ | LI
ADDRESS;_ | AS LONGREAL;_ | LR
ADR( | AD LOOP_ | L
AND_ | A MOD_ | M
ARRAY_ | AR MODULE_ | MO
BEGIN | B NEW( | NE
BITSET;_ | BS NIL_ | NI
BOOLEAN;_ | BL NOT_ | N
BY_ | BY ODD( | OD
BYTE;_ | BT OF_ | OF
CAP( | CP OR_ | O
CARDINAL;_ | CD ORD( | OR
CASE_ | CS POINTER_TO_ | PT
CHAR;_ | C PROC;_ | PR
CHR( | CR PROCEDURE_ | P
CONST_ | CN QUALIFIED_ | Q
DEC( | DC REAL;_ | RA
DEFINITION_MODULE_ | DM RECORD | RE
DISPOSE( | DP REG( | RG
DIV_ | DV REPEAT_ | RP
DO_ | D RETURN_ | R
ELSE_ | E Read( | RD
ELSIF_ | ES ReadCard( | RC
END_ | EN ReadInt( | RI
END(*CASE*);_ | EC ReadReal( | RR
END(*FOR*);_ | EF ReadStr( | RS
END(*IF*);_ | EI SET_OF_ | S
END(*LOOP*);_ | EL SETREG( | SR
END(*RECORD*);_ | ER SHIFT( | SF
END(*WHILE*);_ | EW SHORT( | SH
END(*WITH*);_ | EH SIZE( | SI
EXCL( | EX THEN_ | TH
EXIT;_ | ET TO_ | TO
EXPORT_ | EP TRUE | T
FALSE | F TRUNC( | TC
FLOAT( | FL TSIZE( | TS
FOR_ | FO TYPE_ | TY
FROM_ | FR UNTIL_ | U
HALT;_ | H VAL( | V
HIGH( | HI VAR_ | VR
IF_ | I WHILE_ | W
IMPLEMENTATION_MODULE_| IM WITH_ | WT
IMPORT_ | IP WORD;_ | WO
IN_ | IN Write( | WE
INC( | IC WriteCard( | WC
INCL( | IL WriteInt( | WI
INLINE( | II WriteLn;_ | WL
INTEGER;_ | IT WriteReal( | WR
LONG( | LO WriteStr( | WS
LONGCARD;_ | LC |
Compiler aufrufen:
Um den Zyklus 'bearbeiten, übersetzen, bearbeiten' zu beschleuni-
gen, besteht die Möglichkeit, den Compiler vom Editor aus zu
starten.
Exit 0........: Altex verlassen und Text speichern
Tastatur......: CTRL + ALT + 0 (Ziffernblock)
Altex wird ohne Sicherheitsabfrage verlassen und der aktuelle
Text (nur dieser!) unter seinem augenblicklichen Namen auf
Diskette gespeichert.
Exit 1........: Altex verlassen und übersetzen
Tastatur......: CTRL + ALT + 1 (Ziffernblock)
'Exit 1' funktioniert wie 'Exit 0', nur daß nach dem Verlassen
des Editors automatisch der Compiler zum Übersetzen des Textes
gestartet wird. Übersetzt wird allerdings nur ein Text, der
bereits in der Shell als aktueller Text angewählt wurde!
Exit 2........: Altex verlassen, übersetzen und starten
Tastatur......: CTRL + ALT + 2 (Ziffernblock)
'Exit 2' läuft genauso ab wie 'Exit 1'. Zusätzlich wird das
bearbeitete Programm nach dem (fehlerfreien!) Übersetzen sofort
gestartet.
Anmerkung: Sollte beim Übersetzen ein Fehler auftreten, so wird
automatisch wieder in den Editor gesprungen.
Fehler bearbeiten:
Auch bei der sorgfältigsten Programmierung ist man nicht völlig
gegen 'Fehler beim Übersetzen' gefeit. Um das Auffinden der
Fehlerstellen zu erleichtern, erhielt Altex vier spezielle Funk-
tionen.
FirstError.: zeige erste Fehlermeldung
Menü.......: Jump / FirstError
Tastatur...: CTRL + F
LastError..: zeige letzte Fehlermeldung
Menü.......: Jump / LastError
Tastatur...: CTRL + L
NextError..: zeige nächste Fehlermeldung
Menü.......: Jump / NextError
Tastatur...: CTRL + N
PrevError..: zeige vorherige Fehlermeldung
Menü.......: Jump / PreviousError
Tastatur...: CTRL + P
Beim Aufruf des Editors mit Angabe eines Dateinamens wird eine
evtl. vorhandene Fehlerdatei automatisch mitgeladen. Diese befin-
det sich dann im Fenster 1, die eigentliche Quellcode-Datei im
Fenster 2.
Sobald in das Fenster 1 eine Datei mit der Endung .ERR geladen
wird, wechselt Altex in den Fehlermodus. Nun erscheint in der
Infozeile von Fenster 2 die aktuelle Zeile aus der Fehlerdatei.
Mit den vorhandenen Funktionen kann man sich nun in der Fehlerda-
tei bewegen, während man die Sourcecode-Datei bearbeitet (ohne
dabei das Fenster wechseln zu müssen!). Wenn sich in der
aktuellen Zeile der Fehlerdatei eine Positionierungsangabe befin-
det, so wird diese Position im Sourcetext automatisch angesprun-
gen.
Versions-Update:
Für die tägliche Arbeit bei der Programmentwicklung wäre es oft
sehr nützlich, wenn man wüßte, wann man in welchem Programmteil
zuletzt Änderungen vorgenommen hat. Einige Programmierer schrei-
ben sich deshalb einen sauberen Programmkopf, in dem sie das
Datum der letzten Änderung eintragen. Das Problem bei dieser
Methode liegt nun darin, daß man leider in schöner Regelmäßigkeit
vergißt, dieses Datum zu aktualisieren.
Um diesem Mißstand wirkungvoll zu begegnen, besitzt Altex eine
spezielle Funktion.
Wenn innerhalb der ersten zehn Zeilen eines Programmtextes die
Zeichenfolge
'Version*:'
gefunden wird, so ersetzt Altex diese Zeichenfolge durch
'Version*: TT.MM.JJJJ SS:MM'
'*' steht für beliebig viele beliebige Zeichen.
'TT.MM.JJJJ' steht für das aktuelle Datum (z.B. 23.05.1989).
'SS:MM' steht für die aktuelle Zeit (z.B. 22:17).
Achtung: Hinter 'Version*:' sollte genügend Platz vorhanden sein,
da das Datum und die Zeit einfach überschreibend in den Text
plaziert werden.