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   
Text File  |  1989-06-16  |  30KB  |  635 lines
  1. -------------------------------
  2. Dokumentation zum Modula-System                         Stand 12.04.89
  3. -------------------------------
  4.  
  5. Vorwort:
  6. ========
  7. Dieses Modula-2-System wurde für Ausbildungszwecke konzipiert und wird
  8. zur Programmierausbildung für Studenten der Fakultät Elektrotechnik und
  9. Informationstechnik eingesetzt.
  10.  
  11. Mit dieser Public-Domain-Version soll nun allen an Modula-2 Interessierten
  12. die Möglichkeit geboten werden, sich mit dieser Sprache zu beschäftigen.
  13.  
  14. Allerdings muß an dieser Stelle erwähnt werden, daß von Seiten des
  15. Lehrstuhls keine Dokumentation oder ausführliche Anleitung zur Verfügung
  16. steht und daß keinerlei Beratung (weder telefonisch noch schriftlich)
  17. durchgeführt werden kann.
  18.  
  19.  
  20. Die folgenden Hinweise können natürlich kein komplettes Handbuch ersetzen,
  21. sollten aber für die normale Bedienung des Systems ausreichen.
  22.  
  23.  
  24. 1.0 Zusammenstellung der Diskette :
  25. -----------------------------------
  26.  
  27.    - AUTO         (Ordner, mit RAM-Disk)
  28.    - DEF          (Ordner, mit den DEFINITION-Modulen zur Bibliothek)
  29.    - GEMLIB       (Ordner, mit SBM- & OBM-Files für GEM)
  30.    - STDLIB       (Ordner, mit SBM- & OBM-Files der Standardmodule)
  31.    - SYSTEM       (Ordner, mit SBM- & OBM-Files der Systemumgebung)
  32.    - STANDALO.NE  (Ordner, mit OBM-Files, die der Linker benötigt)
  33.    - SBM          (Ordner, mit SBM-Files, die in die RAM-Disk kopiert
  34.                    werden)
  35.    - OBM          (Ordner, mit OBM-Files,            -"-              )
  36.    - WORK         (Ordner, mit den Files, die bearbeitet werden sollen)
  37.    - COPY.LST     (Liste der Files die in die Ramdisk überspielt werden)
  38.    - RAMDISK.INF  (Infodatei der RAM-Disk, Größe, Laufwerksbuchstabe ...)
  39.    - (EDITOR.PRG) (eigener Editor z.B. Tempus)
  40.    - M2PATH.TXT   (Suchpfade der MODULA-SHELL)
  41.    - ERROR.IND    (Fehlermeldungen für den Compiler)
  42.    - MK_COPY.PRG  (Kopierprogramm. Es wird von der RAM-Disk aufgerufen)
  43.    - M2LOADER.PRG (hiermit wird die Shell gestartet)
  44.    - DEBUG.RSC
  45.    - M2SHELL.RSC
  46.    - DESKTOP.INF
  47.    - READ.ME
  48.    - COPYRIGH.T
  49.  
  50.  
  51. 2.0 Modula-Shell :
  52. ------------------
  53.  
  54. 2.1 Hochfahren des Systems
  55.  
  56.     - ATARI einschalten
  57.     - Modula-Diskette einlegen
  58.       ... Der ATARI bootet und installiert die RAM - Disk
  59.       ... Einige Files entsprechend der Datei COPY.LST werden in die
  60.           RAM - Disk geladen
  61.       Jetzt wird der M2LOADER durch Sie auf der RAM-DISK gestartet.
  62.       (Der M2LOADER liest M2Paths.txt; man kann daher auch M2Loader als
  63.        Anwendung anmelden und dann M2LOADER durch Doppelklick auf M2Paths
  64.        starten. Dazu braucht M2LOADER.PRG nicht auf der RAM-Disk sein)
  65.       Im LOADER starten Sie M2SHELL.OBM durch betätigen der RETURN-Taste.
  66.       ...Die Modula-Shell wird nun geladen.
  67.       Jetzt müssen Sie nur noch das DATUM eingeben, falls dies noch nicht
  68.       geschehen ist und schon kann's losgehen.
  69.  
  70.  
  71. 2.1 Bedienung der Shell
  72.  
  73.     - Das Menü 'Desk':
  74.       - M2-Shell: ein paar Informationen zum Modula-2 System.
  75.     - Das Menü 'Modul':
  76.       - Editieren, Übersetzen & Starten bezieht sich jeweils auf die
  77.       Arbeitsdatei (wird in der Desktop-Box angezeigt). Ist noch keine
  78.       Arbeitsdatei ausgewählt, so geschieht dies nach dem Anwählen über
  79.       die Fileselectorbox. Entsprechend wird nun der Editor, der Com-
  80.       piler oder die Datei selbst geladen und ausgeführt.
  81.       Diese Funktionen können auch über die Tastenkombinationen
  82.       <control> E, Ü & S erreicht werden.
  83.       - Editiere ..., Übersetze ... & Starte ... beziehen sich jeweils
  84.       auf eine Datei, die erst noch mit der Fileselectorbox ausgewählt
  85.       wird. Diese Funktionen können auch über die Tastenkombinationen
  86.       <alternate> E, Ü & S erreicht werden.
  87.       - PRG erzeugen bezieht sich auf die aktuelle Arbeitsdatei und ruft
  88.       den Linker auf, der die importierten Module zusammenbindet und ein
  89.       lauffähiges Programm erzeugt. Erraten, das geht auch mit <control> L.
  90.       - Ende oder <control> X und die Shell wird verlassen, in der File-
  91.       selectorbox des M2LOADER muß dann <Abbruch> gewählt werden.
  92.     - Das Menü 'Optionen':
  93.       - Mit Modul auswählen oder <control> A kann die Arbeitsdatei festge-
  94.       legt werden.
  95.       - Mit Suchpfade ändern oder <control> P können die Pfade auf welchen
  96.       die Shell oder der Compiler die benötigten SBM- bzw. OBM-Files sucht
  97.       geändert werden.
  98.       - Mit Terminal öffnen bzw. <control> T können z.B. die letzten
  99.       Ausgaben eines Programms noch einmal untersucht werden, dazu wird das
  100.       Terminal-Window geöffnet.
  101.       - Compiler, Debug: ein paar Parameter können hier geändert werden,
  102.       die voreingestellten Werte sind Erfahrungswerte und müssen in den
  103.       wenigsten Fällen geändert werden.
  104.       - Editor: Hier kann der verwendete Editor gewählt werden, wobei gilt:
  105.                 linker  Eintrag: Editor als PRG-File
  106.                 rechter Eintrag: Editor als OBM-File
  107.                 Der gewählte Editor wird unter dem angezeigten Namen
  108.                 gesucht. Beim 'PRG-Editor' wird er auf dem Pfad erwartet,
  109.                 von dem aus der M2LOADER gestartet wurde.
  110.                 Editor resident bezieht sich auf den 'OBM-Editor'.
  111.       - Backup: Der gerade bearbeitete Text (beim Aufruf des Editors) wird
  112.         auf dem angegebenen Pfad noch einmal abgespeichert, wenn ein Backup
  113.         gewünscht wird. Das ist besonders zu empfehlen, wenn sich die
  114.         Arbeitsdatei in der RAM-Disk befindet.
  115.       - mit *.DEF, *.MOD bearbeiten (<control> D, M) kann man einstellen ob
  116.       ein DEFINITION oder (IMPLEMANTATION) MODUL bearbeitet werden soll.
  117.       Das bezieht sich im besonderen auf den Compiler (existiert TEST.DEF
  118.       und TEST.MOD und soll TEST.DEF übersetzt werden, dann *.DEF bearbeiten
  119.       wählen und den Compiler aufrufen), außerdem werden dann in der File-
  120.       selectorbox nur *.DEF bzw. *.MOD angezeigt.
  121.     - Das Menü 'Datei':
  122.       - Kopieren, Löschen & Umbenennen: Es wird jeweils über die File-
  123.       selectorbox das entsprechende File ausgewählt und danach entweder
  124.       das Zieldirectory oder der neue Name bestimmt.
  125.       - Ausführen: Es kann ein Programm (*.PRG) gestartet werden.
  126.  
  127.  
  128.  
  129. 3.0 Informationen über Linker, Debugger und Compiler :
  130. ------------------------------------------------------
  131.  
  132. 3.1 Allgemeines:
  133.  
  134. - Die Arbeitsumgebung ist in Schichten aufgebaut. Unterste Schicht ist
  135.   der M2LOADER. Auf M2LOADER liegt dann (normalerweise) M2SHELL. Dies
  136.   ist ein Objektmodul d.h. es kann nicht ohne den M2LOADER laufen.
  137.   M2SHELL ruft dann ihrerseits Editor und Compiler auf.
  138.   Wird ein compiliertes Programm gestartet, so läuft es, wenn es
  139.   noch nicht gelinkt ist, wie alle ".OBM"- Programme unter Kontrolle
  140.   von M2LOADER, der bei Laufzeitfehlern den Debugger starten kann.
  141.   M2SHELL, der Compiler, der Editor und der Debugger bleiben, wenn sie
  142.   einmal geladen sind, resident.
  143.  
  144. - M2PATHS.TXT.
  145.   Diese Datei kann wie jede Textdatei mit dem Editor bearbeitet werden.
  146.   In ihr stehen Suchpfade, die der Compiler, der Debugger, die Shell
  147.   und M2LOADER auf der Suche nach Dateien benutzen.
  148.   Außerdem kann der Defaultaufruf des M2LOADER eingetragen werden. D.h.
  149.   diejenige Objekt-Datei, deren Name in der letzten Zeile nach @M steht,
  150.   wird vom M2LOADER vorgewählt und kann durch Anklicken von [OK] gestartet
  151.   werden.
  152.   In der vorletzten Zeile dieser Datei steht der Suchpfad (der letzte
  153.   Suchpfad) der als Default für Funktionen wie Modul auswählen usw.
  154.   verwendet wird.
  155.   Der vorletzte Suchpfad wird als Voreinstellung für den Backup-Pfad
  156.   verwendet und sollte sinnigerweise keine RAM-Disk als Ziel haben.
  157.   Fehlt die Angabe des Laufwerkes in einem Pfad, so bezieht sich dieser
  158.   auf den aktuellen Pfad des GEMDOS, im allgemeinen der Pfad von dem aus
  159.   der M2LOADER gestartet wurde.
  160.   Jeder Pfad muß mit '\' enden, denn intern wird nur noch der Filename an
  161.   den Pfad angehängt.
  162.   Maximal 15 Pfadnamen können angegeben werden.
  163.  
  164.  
  165. 3.2 Der Linker (Standalone Programme):
  166.  
  167. - Da man, wenn man "ernsthaft" programmieren will Programme ohne
  168.   den Schutz von M2LOADER laufen lassen will, muß man die compi-
  169.   lierten Objektmodule binden (linken). Dazu muß sich der Ordner
  170.   STANDALO.NE auf dem Laufwerk befinden, von dem M2LOADER geladen
  171.   wurde, d.h. Benutzer einer RAM-Disk müssen diesen Ordner mit Inhalt
  172.   per Maus, oder per COPY.LST automatisch, in die RAM-Disk kopieren.
  173.   Der Inhalt von STANDALO.NE sollte auf keinen Fall verändert werden!
  174.   Der Linker wird durch "PRG erzeugen" gestartet. Er sucht sich
  175.   dann alles zusammen, was er braucht (GEMX.OBM, PATH.OBM, HEAP.OBM, ...)
  176.   und erzeugt dann ein lauffähiges PRG-File aus allen nötigen OBM-Files.
  177.   (Diese müssen dann auch auf den Suchpfaden vorhanden sein). Der Linker
  178.   überprüft dabei die Module auch auf Versionskonflikte.  Findet der
  179.   Linker ein OBM-File nicht, so gibt er dem Benutzer die Chance,
  180.   per "Hand" die gesuchten Module zu finden. Die fertigen Programme
  181.   werden, wenn keine Fehler auftraten, im gleichen Ordner wie das
  182.   OBM-File abgelegt.
  183.   Wichtig: Programme können nach dem Linken ein anderes Verhalten zeigen
  184.            wie beim Aufruf aus der Shell. Das liegt daran, daß von der
  185.            Shell bzw. Loader (vom Programmierer oft nicht wahrgenommen)
  186.            eine Reihe von Funktionen zur Verfügung gestellt werden, die nun
  187.            fehlen bzw. selbst eingerichtet werden müssen (z.B. Textausgabe,
  188.            Exceptionbehandlung usw.).
  189.  
  190.  
  191. 3.3 Der Debugger:
  192.  
  193. - Der Debugger ist ein Source-Level-Debugger, der nach einem "Programm-
  194.   absturz" aktiv wird (Post-Mortem-Debugger). Dazu wird er nach einem
  195.   Laufzeitfehler vom M2LOADER gestartet und zeigt im Textfenster den
  196.   Programmsourcetext; die Fehlerzeile ist dabei  fett gedruckt.
  197.   Alle beim Fehlerauftritt sichtbaren Variablen können angezeigt werden.
  198.   Sichtbar sind alle gobalen Variablen und die lokalen Variablen aller
  199.   Prozeduren der aktuellen Prozeduraufrufkette.
  200.   Dazu bedarf es aber der RFM-Files der entsprechenden Module.
  201.   Es gibt fünf Fenster:
  202.  
  203.     - Quelltext:
  204.     Da steht (hoffentlich) der Quelltext drin, in dem der Fehler auf-
  205.     trat. Ist das Fenster leer, so ist der Quelltext zum entsprechenden
  206.     Modul nicht erreichbar. Wenn der Quelltext in einem der Suchpfade
  207.     liegt, führt das Anklicken des Modulnamens im Modulfenster (meistens)
  208.     zum Erfolg.
  209.  
  210.     - Prozeduraufrufkette und Datenfenster 1:
  211.     Diese beiden Fenster gehören zusammen. Das linke Fenster (Proze-
  212.     duraufrufkette) zeigt, in welcher Reihenfolge die Prozeduren auf-
  213.     gerufen wurden. Die oberste ist die Prozedur in der der Fehler auf-
  214.     getreten ist. Im rechten Fenster können die Variablen, die in der
  215.     ausgewählten Prozedur sichtbar sind, auf ihren Inhalt hin untersucht
  216.     werden.
  217.  
  218.     - Modulliste und Datenfenster 2:
  219.     Hier gilt gleiches wie oben, nur daß hier alle Module angezeigt werden,
  220.     die sich gerade im Speicher befinden. Sofern die RFM-Files der Module
  221.     auf den Suchpfaden liegen, können die dort sichtbaren Variablen
  222.     untersucht werden.
  223.  
  224.   - Durch Anklicken von Prozedur bzw. Modulnamen kann man diese
  225.   Prozedur bzw. dieses Modul betrachten, d.h. die dort sichtbaren
  226.   Variablen.
  227.  
  228.   - Zu den Datenfenstern ist die Darstellung strukturierten Datentypen
  229.   (Arrays , Records) und die Darstellung der Pointer auf diese Datentypen
  230.   zu erwähnen. Beide sind durch "*" gekenzeichnet. Klickt  man diesen an,
  231.   so "betritt" man das Array/Record. In der ersten Zeile des Fensters
  232.   erscheint nach einem "." der Name der angeklickten  Variablen. Bei
  233.   tiefer strukturierten Datentypen können dort durchaus mehrere Bezeichner
  234.   durch "." getrennt hintereinander stehen (z.B. bei der Analyse einer
  235.   verketteten Liste ). Durch Anklicken der Bezeichner kann man dann
  236.   wieder "herauf"steigen.
  237.  
  238.   - Variablen vom Typ BITSET, SET OF ... bzw. ADDRESS werden in hexa-
  239.   dezimaler Form ausgegeben.
  240.  
  241.   - Die Menüeinträge erklären sich, wenn ein wenig mit ihnen 'gespielt'
  242.   wird, bald von selbst.
  243.  
  244.   Hinweis: Error Process
  245.   Modula bietet eine Schnittstelle zum Arbeiten mit Coroutinen
  246.   (= Multitasking). Dazu wird der Datentyp "PROCESS" verwendet. Der
  247.   Debugger analysiert beim Doppelklick auf eine Variable vom Typ PROCESS
  248.   den lokalen Stack dieser Task. Soll auf den Stack der "abgestürzten" Task
  249.   zurückgekehrt werden, so muß der Menüpunkt Error Process angewählt werden.
  250.  
  251.  
  252.   - FEHLER: Wenn in einer WITH-Anweisung der Programmablauf gestoppt wird,
  253.   stürzt der Rechner beim Fortsetzen des Programmes ab, sofern auf die
  254.   dereferenzierte Variable noch innerhalb dieser WITH-Anweisung zugegriffen
  255.   wird.
  256.   Nach Aufruf des Debuggers kann es passieren, daß anschließend mit Tempus
  257.   abgespeicherte Dateien mehrfach unter dem gleichen Namen abgelegt werden.
  258.   Bei der Rückkehr in die Shell werden diese in *.X?? umbenannt, wobei X für
  259.   den ursprünglichen Buchstaben der Extension steht und ? für eine Ziffer,
  260.   Es wird durch eine Alertbox darauf hingewiesen.
  261.   Dieser Test beschränkt sich allerdings auf das aktuelle File das vor dem
  262.   Aufruf des Editors bestimmt wurde.
  263.   (Dieser Fehler sollte nun behoben sein!)
  264.  
  265. 3.3 Der Compiler:
  266.  
  267.   - Der Compiler ist ein Single-Pass-Compiler, alle Bezeichner müssen vor
  268.   ihrer Verwendung deklariert werden. Sollte dies für Prozeduren nicht
  269.   möglich sein, so ist eine FORWARD Anweisung zu verwenden, die auf der
  270.   gleichen Schachtelungstiefe wie die anschliessende Deklaration selbst
  271.   erfolgen muß. Syntax: wie bei der Prozedur-Deklaration und dabei
  272.   den BEGIN-END; - Block durch FORWARD; ersetzen.
  273.   - Werden beim übersetzten einer Datei importierte Module nicht auf den
  274.   Suchpfaden gefunden, so können Sie diese von Hand aufsuchen.
  275.   - Wenn Fehler gefunden wurden, so wird eine Datei *.ERR erzeugt, in der
  276.   neben Zeile und Spalte des Fehlers auch die Fehlermeldung zu finden ist.
  277.   - Die SBM-, RFM- und OBM-Files werden im gleichen Ordner wie die
  278.   Quelltexte abgelegt.
  279.   - Wird der Compiler mit einer Datei mit Extension *.CM? (? = beliebiges
  280.   Zeichen) aufgerufen, so erwartet er darin eine Liste von Modulnamen
  281.   (mit Extension). Die Module werden dann in dieser Reihenfolge über-
  282.   setzt. Dies eignet sich, wenn in einem größeren Programmpaket ein
  283.   DEFINITION MODUL geändert werden mußte, um ein komplettes Update zu er-
  284.   zeugen (ähnlich einem Make).
  285.  
  286.  
  287.  
  288. 4.0 Allgemeine Hinweise:
  289. ------------------------
  290.  
  291.   - Diese Diskette enthält einen zum Modula-System passenden Editor
  292.     (M2Editor). Da aber zum einen dieser Editor noch nicht 100 % ausge-
  293.     testet ist und zum anderen ein Editor Geschmacksache ist, kann jeder
  294.     andere Editor verwendet werden.
  295.   - Als Editor eignet sich (neben dem beiliegenden Editor) Tempus ausge-
  296.     zeichnet.
  297.   - Die Voreinstellungen können mit einem Resource-Construction-Set leicht
  298.   an eigene Wünsche angepaßt werden. Es ist nur darauf zu achten, daß der
  299.   Objektbaum nicht neu konstruiert wird (die Shell geht natürlich weiter-
  300.   hin von ihrer Objektstruktur aus).
  301.   Der Name des Editors kann ebenfalls geändert werden (max. 8 Zeichen).
  302.   Der Editor wird dann unter diesem Namen mit Extension *.PRG (linker
  303.   Eintrag) bzw. *.OBM (rechter Eintrag) gesucht.
  304.   - Wenn ein 1040'er verwendet wird, empfiehlt es sich das System wie folgt
  305.   einzurichten:
  306.     - Die RAM-Disk mit etwa 200 kByte installieren.
  307.     - Die SBM-Files in den Ordner SBM in der RAM-Disk.
  308.     - Die oft benötigten OBM-Files in den Ordner OBM in der RAM-Disk
  309.     - den Ordner WORK mit den Files die gerade von Ihnen bearbeitet werden
  310.     auf die RAM-Disk.
  311.     - ohne Ordner auf der RAM-Disk den Editor (mit *.RSC), die Datei
  312.     ERROR.IND sowie M2PATH.TXT.
  313.     - Nun auf M2LOADER.PRG eine Anwendung mit Extension *.TXT anmelden.
  314.     - DESKTOP.INF sichern.
  315.     - nun kann durch Doppelklick auf M2PATH.TXT in der RAM-Disk der M2LOADER
  316.     gestartet werden.
  317.     - M2LOADER glaubt sich von der RAM-Disk gestartet, und es werden
  318.     zusätzlich 25 kByte in der RAM-Disk frei.
  319.  
  320.   - Das Pseudo-Modul SYSTEM exportiert folgende Bezeichner:
  321.     VAL, ADR, ADDRESS, LONG, SHORT, BYTE, WORD,
  322.     SETREG, REG, INLINE, CODE.
  323.     In aller Kürze:
  324.     - VAL und ADR wie bei N. Wirth.
  325.     - LONG und SHORT wandeln zwischen den verschiedenen Datenlängen um.
  326.       Bsp. mit Typen: LONG(CARDINAL) = LONGCARD.
  327.     - BYTE und WORD sind 'Universaltypen' der entsprechenden Länge.
  328.     - SETREG und REG setzen und lesen die Register des MC68000
  329.       dabei gilt die Zuordnung der Registernummern:
  330.         D0 -> 0, D1 -> 1, ... A0 -> 8, ... A7 -> 15.
  331.       In die Register werden nur 32 Bit Worte geschrieben.
  332.       Aufruf: SETREG( RegisterNummer, 32BitWort )
  333.               32BitWort := REG( RegisterNummer )
  334.       als 32 BitWort wird LONGINT und ADDRESS akzeptiert.
  335.     - INLINE es kann Maschinensprache Code integriert werden.
  336.       Bsp. INLINE( Zahl1, Zahl2, Zahl3 ) oder INLINE( Zahl1 ).
  337.       Zahl? muß vom Typ CARDINAL und eine Konstante sein.
  338.  
  339.   - LONG-Konstanten müssen durch Anfügen von D als solche gekennzeichnet
  340.   werden (323.0E23D ist eine LONGREAL-Konstante).
  341.  
  342.   - Zahlen in hexadezimaler Form können durch Anfügen von H gekennzeichnet
  343.   werden, die erste Ziffer muß dennoch eine Zahl sein, also nicht FFH,
  344.   sondern 0FFH
  345.  
  346.   - Aufzählungstypen haben maximal 256 Elemente.
  347.   - Die Set-Grösse ist auf 16 (Wortgröße) beschränkt.
  348.  
  349. Zum Schluß wünsch' ich allen Benutzern viel Spaß.
  350.  
  351.                                                     M.Bayer
  352.  
  353. ===========================================================================
  354.  
  355. Kurze Anleitung des beiliegenden Editors :
  356. ==========================================
  357.  
  358. Editorfunktionen                                    Referenzliste
  359. ==================================================================
  360.  
  361. Funktionsname ! Menü   ! Code     ! Beschreibung
  362. --------------+--------+----------+------------------------------------
  363. ProgInfo      ! Desk   ! CA ~ I   ! Infobildschirm zeigen
  364. ProgQuit      ! File   ! CA ~ Q   ! Programm verlassen
  365. FileOpen      ! File   ! CA ~ O   ! Datei in neues Fenster laden
  366. FileLoad      ! File   ! CA ~ L   ! Datei in aktuelles Fenster laden
  367. FileMerge     ! File   ! CA ~ M   ! Datei im aktuellen Fenster einfügen
  368. FileSave      ! File   ! CA ~ S   ! Text mit neuem Namen speichern
  369. FileUpdate    ! File   ! CA ~ U   ! Text direkt speichern
  370. FileBackup    ! File   ! CA ~ B   ! Text speichern, altes File -> .BAK
  371. FileDelete    ! File   ! CA ~ D   ! Datei löschen
  372. --------------+--------+----------+------------------------------------
  373. WindowOpen1   ! Window !  C ~ (   ! Fenster 1 öffnen
  374. WindowOpen2   ! Window !  C ~ )   ! Fenster 2 öffnen
  375. WindowOpen3   ! Window !  C ~ /   ! Fenster 3 öffnen
  376. WindowOpen4   ! Window !  C ~ *   ! Fenster 4 öffnen
  377. WindowFull1   ! -      !  S ~ (   ! Fenster 1 auf volle Größe bringen
  378. WindowFull2   ! -      !  S ~ )   ! Fenster 2 auf volle Größe bringen
  379. WindowFull3   ! -      !  S ~ /   ! Fenster 3 auf volle Größe bringen
  380. WindowFull4   ! -      !  S ~ *   ! Fenster 4 auf volle Größe bringen
  381. WindowClose1  ! Window !  A ~ (   ! Fenster 1 schließen
  382. WindowClose2  ! Window !  A ~ )   ! Fenster 2 schließen
  383. WindowClose3  ! Window !  A ~ /   ! Fenster 3 schließen
  384. WindowClose4  ! Window !  A ~ *   ! Fenster 4 schließen
  385. --------------+--------+----------+------------------------------------
  386. TextDelete    ! Edit   ! CA ~ DEL ! Text eliminieren, Fenster schließen
  387. SearchDefine  ! Edit   ! SC ~ S   ! Suchparameter definieren
  388. SearchStart   ! Edit   !  C ~ S   ! Suchen starten
  389. ReplaceDefine ! Edit   ! SC ~ R   ! Ersetzparameter definieren
  390. ReplaceStart  ! Edit   !  C ~ R   ! Ersetzen starten
  391. --------------+--------+----------+------------------------------------
  392. TextStart     ! Jump   ! SC ~ CU  ! Textanfang anspringen
  393. TextEnd       ! Jump   ! SC ~ CD  ! Textende anspringen
  394. TextLine      ! Jump   !  C ~ G   ! Textzeile anspringen
  395. ErrorFirst    ! Jump   !  C ~ F   ! ersten Fehler anspringen
  396. ErrorLast     ! Jump   !  C ~ L   ! letzten Fehler anspringen
  397. ErrorNext     ! Jump   !  C ~ N   ! nächsten Fehler anspringen
  398. ErrorPrevious ! Jump   !  C ~ P   ! vorherigen Fehler anspringen
  399. --------------+--------+----------+------------------------------------
  400. BlockMark     ! Block  !  A ~ B   ! Zeilenblock markieren
  401. BlockHide     ! Block  !  A ~ H   ! Markierung löschen
  402. BlockDelete   ! Block  !  A ~ D   ! Block löschen
  403. BlockMove     ! Block  !  A ~ M   ! Block verschieben
  404. BlockCopy     ! Block  !  A ~ C   ! Block kopieren
  405. --------------+--------+----------+------------------------------------
  406. ModeIndent    ! Mode   !  C ~ I   ! Indentmodus ein/ausschalten
  407. ModeInsert    ! Mode   !  S ~ INS ! Insertmodus ein/ausschalten
  408. ModeTab       ! Mode   !  C ~ TAB ! Tab-Weite definieren
  409. --------------+--------+----------+------------------------------------
  410. CharRight     ! -      !      CR  ! ein Zeichen nach rechts
  411. CharLeft      ! -      !      CL  ! ein Zeichen nach links
  412. CharReduce    ! -      !      BSP ! ein Zeichen links lösch.
  413. CharDelete    ! -      !      DEL ! ein Zeichen auslöschen
  414. CharInsert    ! -      !      INS ! ein Zeichen einfügen
  415. --------------+--------+----------+------------------------------------
  416. LineRight     ! -      !  S ~ CR  ! an das Zeilenende
  417. LineLeft      ! -      !  S ~ CL  ! an den Zeilenanfang
  418. LineDown      ! -      !      CD  ! Zeile runter
  419. LineUp        ! -      !      CU  ! Zeile rauf
  420. LineTailDelete! -      !  S ~ DEL ! Zeile ab Cursor löschen
  421. LineReduce    ! -      !  C ~ BSP ! Zeile vorher löschen
  422. LineDelete    ! -      !  C ~ DEL ! Zeile herauslöschen
  423. LineInsert    ! -      !  C ~ INS ! Zeile einfügen
  424. LineDownSwap  ! -      !  C ~ +   ! Zeile runter schieben
  425. LineUpSwap    ! -      !  C ~ -   ! Zeile rauf schieben
  426. LineDouble    ! -      !  C ~ ENT ! Zeile verdoppeln
  427. LineUndo      ! -      !     UNDO ! Zeile restaurieren
  428. --------------+--------+----------+------------------------------------
  429. Eol           ! -      !      RET ! Zeile abschließen
  430. EolLineInsert ! -      !  S ~ RET ! Return + neue Zeile
  431. EolBackspace  !        ! SC ~ BSP ! Zeile(n)+Zeile(n-1)
  432. EolDelete     !        ! SC ~ DEL ! Zeile(n)+Zeile(n+1)
  433. EolInsert     !        ! SC ~ INS ! (C~RET) Zeilenrest in neue Zeile
  434. --------------+--------+----------+------------------------------------
  435. TabRight      ! -      !      TAB ! nächste TAB-Position anspringen
  436. TabLeft       ! -      !  S ~ TAB ! vorherige TAB-Position anspringen
  437. ScrollUp      ! -      !  S ~ CU  ! Text nach unten schieben
  438. ScrollDown    ! -      !  S ~ CD  ! Text nach oben schieben
  439. ScreenUp      ! -      !  C ~ CU  ! ein Bildschirm rauf
  440. ScreenDown    ! -      !  C ~ CD  ! ein Bildschirm runter
  441.  
  442.  
  443.  
  444.  
  445.          M o d u l a - U n t e r s t ü t z u n g :
  446.  
  447.  
  448.  
  449. Da der Altex-Editor speziell für das Modula-2-System entwickelt
  450. wurde, enthält er einige Besonderheiten, die das Schreiben von
  451. Modula-Programmen erleichtern.
  452.  
  453.  
  454. Modula-Assistent:
  455.  
  456.  
  457. Bei der Eingabe eines Modula-Programmes befindet man sich wegen
  458. der Variablen und Kommentare normalerweise im Kleinschriftmodus.
  459. Soll nun ein Modula-Schlüsselwort eingegeben werden, so muß man
  460. entweder in den Großschriftmodus umschalten, oder die SHIFT-Taste
  461. gedrückt halten. Dieses und die Eingabe des Schlüsselwortes
  462. selbst kann man sich nun vom 'Modula-Assistenten' abnehmen
  463. lassen. Für jedes bekannte Schlüsselwort existiert eine maximal
  464. zwei Buchstaben lange Abkürzung, die nach Drücken der HELP-Taste
  465. (Der Cursor muß dazu genau hinter der eingegebenen Abkürzung
  466. stehen!) in die korrekte, ausführliche Modula-Schreibweise umge-
  467. wandelt wird.
  468.  
  469. Beispiel: p <HELP> wird zu 'PROCEDURE' expandiert ...
  470. Beispiel: ew <HELP> wird zu 'END(*WHILE*);' umgewandelt ...
  471.  
  472. Nachfolgend eine Liste der Modula-Schlüsselwörter und ihrer
  473. Abkürzungen:
  474.  
  475. Schlüsselwort         | Kürzel      Schlüsselwort | Kürzel
  476.  -----------------------+--------   --------------+--------
  477. ABS(                  | AB          LONGINT;_     | LI
  478. ADDRESS;_             | AS          LONGREAL;_    | LR
  479. ADR(                  | AD          LOOP_         | L
  480. AND_                  | A           MOD_          | M
  481. ARRAY_                | AR          MODULE_       | MO
  482. BEGIN                 | B           NEW(          | NE
  483. BITSET;_              | BS          NIL_          | NI
  484. BOOLEAN;_             | BL          NOT_          | N
  485. BY_                   | BY          ODD(          | OD
  486. BYTE;_                | BT          OF_           | OF
  487. CAP(                  | CP          OR_           | O
  488. CARDINAL;_            | CD          ORD(          | OR
  489. CASE_                 | CS          POINTER_TO_   | PT
  490. CHAR;_                | C           PROC;_        | PR
  491. CHR(                  | CR          PROCEDURE_    | P
  492. CONST_                | CN          QUALIFIED_    | Q
  493. DEC(                  | DC          REAL;_        | RA
  494. DEFINITION_MODULE_    | DM          RECORD        | RE
  495. DISPOSE(              | DP          REG(          | RG
  496. DIV_                  | DV          REPEAT_       | RP
  497. DO_                   | D           RETURN_       | R
  498. ELSE_                 | E           Read(         | RD
  499. ELSIF_                | ES          ReadCard(     | RC
  500. END_                  | EN          ReadInt(      | RI
  501. END(*CASE*);_         | EC          ReadReal(     | RR
  502. END(*FOR*);_          | EF          ReadStr(      | RS
  503. END(*IF*);_           | EI          SET_OF_       | S
  504. END(*LOOP*);_         | EL          SETREG(       | SR
  505. END(*RECORD*);_       | ER          SHIFT(        | SF
  506. END(*WHILE*);_        | EW          SHORT(        | SH
  507. END(*WITH*);_         | EH          SIZE(         | SI
  508. EXCL(                 | EX          THEN_         | TH
  509. EXIT;_                | ET          TO_           | TO
  510. EXPORT_               | EP          TRUE          | T
  511. FALSE                 | F           TRUNC(        | TC
  512. FLOAT(                | FL          TSIZE(        | TS
  513. FOR_                  | FO          TYPE_         | TY
  514. FROM_                 | FR          UNTIL_        | U
  515. HALT;_                | H           VAL(          | V
  516. HIGH(                 | HI          VAR_          | VR
  517. IF_                   | I           WHILE_        | W
  518. IMPLEMENTATION_MODULE_| IM          WITH_         | WT
  519. IMPORT_               | IP          WORD;_        | WO
  520. IN_                   | IN          Write(        | WE
  521. INC(                  | IC          WriteCard(    | WC
  522. INCL(                 | IL          WriteInt(     | WI
  523. INLINE(               | II          WriteLn;_     | WL
  524. INTEGER;_             | IT          WriteReal(    | WR
  525. LONG(                 | LO          WriteStr(     | WS
  526. LONGCARD;_            | LC                        |
  527.  
  528.  
  529. Compiler aufrufen:
  530.  
  531.  
  532. Um den Zyklus 'bearbeiten, übersetzen, bearbeiten' zu beschleuni-
  533. gen, besteht die Möglichkeit, den Compiler vom Editor aus zu
  534. starten.
  535.  
  536.  
  537. Exit 0........: Altex verlassen und Text speichern
  538. Tastatur......: CTRL + ALT + 0 (Ziffernblock)
  539.  
  540. Altex wird ohne Sicherheitsabfrage verlassen und der aktuelle
  541. Text (nur dieser!) unter seinem augenblicklichen Namen auf
  542. Diskette gespeichert.
  543.  
  544.  
  545. Exit 1........: Altex verlassen und übersetzen
  546. Tastatur......: CTRL + ALT + 1 (Ziffernblock)
  547.  
  548. 'Exit 1' funktioniert wie 'Exit 0', nur daß nach dem Verlassen
  549. des Editors automatisch der Compiler zum Übersetzen des Textes
  550. gestartet wird. Übersetzt wird allerdings nur ein Text, der
  551. bereits in der Shell als aktueller Text angewählt wurde!
  552.  
  553.  
  554. Exit 2........: Altex verlassen, übersetzen und starten
  555. Tastatur......: CTRL + ALT + 2 (Ziffernblock)
  556.  
  557. 'Exit 2' läuft genauso ab wie 'Exit 1'. Zusätzlich wird das
  558. bearbeitete Programm nach dem (fehlerfreien!) Übersetzen sofort
  559. gestartet.
  560.  
  561. Anmerkung: Sollte beim Übersetzen ein Fehler auftreten, so wird
  562. automatisch wieder in den Editor gesprungen.
  563.  
  564. Fehler bearbeiten:
  565.  
  566. Auch bei der sorgfältigsten Programmierung ist man nicht völlig
  567. gegen 'Fehler beim Übersetzen' gefeit. Um das Auffinden der
  568. Fehlerstellen zu erleichtern, erhielt Altex vier spezielle Funk-
  569. tionen.
  570.  
  571. FirstError.: zeige erste Fehlermeldung
  572. Menü.......: Jump / FirstError
  573. Tastatur...: CTRL + F
  574.  
  575. LastError..: zeige letzte Fehlermeldung
  576. Menü.......: Jump / LastError
  577. Tastatur...: CTRL + L
  578.  
  579. NextError..: zeige nächste Fehlermeldung
  580. Menü.......: Jump / NextError
  581. Tastatur...: CTRL + N
  582.  
  583. PrevError..: zeige vorherige Fehlermeldung
  584. Menü.......: Jump / PreviousError
  585. Tastatur...: CTRL + P
  586.  
  587.  
  588.  
  589. Beim Aufruf des Editors mit Angabe eines Dateinamens wird eine
  590. evtl. vorhandene Fehlerdatei automatisch mitgeladen. Diese befin-
  591. det sich dann im Fenster 1, die eigentliche Quellcode-Datei im
  592. Fenster 2.
  593. Sobald in das Fenster 1 eine Datei mit der Endung .ERR geladen
  594. wird, wechselt Altex in den Fehlermodus. Nun erscheint in der
  595. Infozeile von Fenster 2 die aktuelle Zeile aus der Fehlerdatei.
  596. Mit den vorhandenen Funktionen kann man sich nun in der Fehlerda-
  597. tei bewegen, während man die Sourcecode-Datei bearbeitet (ohne
  598. dabei das Fenster wechseln zu müssen!). Wenn sich in der
  599. aktuellen Zeile der Fehlerdatei eine Positionierungsangabe befin-
  600. det, so wird diese Position im Sourcetext automatisch angesprun-
  601. gen.
  602.  
  603.  
  604.  
  605. Versions-Update:
  606.  
  607.  
  608. Für die tägliche Arbeit bei der Programmentwicklung wäre es oft
  609. sehr nützlich, wenn man wüßte, wann man in welchem Programmteil
  610. zuletzt Änderungen vorgenommen hat. Einige Programmierer schrei-
  611. ben sich deshalb einen sauberen Programmkopf, in dem sie das
  612. Datum der letzten Änderung eintragen. Das Problem bei dieser
  613. Methode liegt nun darin, daß man leider in schöner Regelmäßigkeit
  614. vergißt, dieses Datum zu aktualisieren.
  615.  
  616. Um diesem Mißstand wirkungvoll zu begegnen, besitzt Altex eine
  617. spezielle Funktion.
  618.  
  619. Wenn innerhalb der ersten zehn Zeilen eines Programmtextes die
  620. Zeichenfolge
  621.  
  622. 'Version*:'
  623.  
  624. gefunden wird, so ersetzt Altex diese Zeichenfolge durch
  625.  
  626. 'Version*: TT.MM.JJJJ   SS:MM'
  627.  
  628. '*'          steht für beliebig viele beliebige Zeichen.
  629. 'TT.MM.JJJJ' steht für das aktuelle Datum (z.B. 23.05.1989).
  630. 'SS:MM'      steht für die aktuelle Zeit (z.B. 22:17).
  631.  
  632. Achtung: Hinter 'Version*:' sollte genügend Platz vorhanden sein,
  633. da das Datum und die Zeit einfach überschreibend in den Text
  634. plaziert werden.
  635.