home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / extra18 / ide / m2ide.txt < prev    next >
Encoding:
Text File  |  1991-08-29  |  165.4 KB  |  7,010 lines
  1. .topic NoContext=0
  2.  
  3.    Der Editor █
  4.   ▀▀▀▀▀▀▀▀▀▀▀▀▀
  5. Im Edit-Fenster können Sie Ihren Quelltext
  6. editieren. Weitere Aktionen werden über die
  7. Menüleiste durchgeführt. Die einzelnen
  8. Menüpunkte erreichen Sie durch gleichzeitiges
  9. Drücken der Alt-Taste und des rot hervor-
  10. gehobenen Buchstabens.
  11.  
  12. Sie können fast beliebig viele Fenster zum
  13. Editieren öffnen, das oberste davon ist
  14. aktiv. In ein anderes Edit-Fenster gelangen
  15. Sie durch gleichzeitiges Drücken der Alt-Taste
  16. und der Zahl, die Sie in der oberen rechten
  17. Ecke des Edit-Fensters sehen.
  18.  
  19. Da die FST-Benutzeroberfläche mit der
  20. gleichen Software erstellt wurde wie
  21. Turbo Pascal 6.0 (Turbo Vision), verhält sich
  22. auch der Editor weitestgehend wie sein großes
  23. Vorbild.
  24.  
  25.    Editorbefehle █
  26.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  27.  
  28.  Ctrl+S      Zeichen nach links
  29.  Ctrl+D      Zeichen nach rechts
  30.  
  31.  Ctrl+A      Wort nach links
  32.  Ctrl+Links  Wort nach links
  33.  
  34.  Ctrl+F      Wort nach rechts
  35.  Ctrl+Rechts Wort nach rechts
  36.  
  37.  Ctrl+R      Seite nach oben
  38.  Ctrl+C      Seite nach unten
  39.  
  40.  Ctrl+E      Zeile nach oben
  41.  Ctrl+X      Zeile nach unten
  42.  
  43.  Home        Zeilenanfang
  44.  End         Zeilenende
  45.  Ctrl+PgUp   Textbeginn
  46.  Ctrl+PgDn   Textende
  47.  
  48.  
  49.  Ctrl+G      Zeichen unter dem Cursor löschen
  50.  Ctrl+H      Zeichen links vom Cursor löschen
  51.  
  52.  Ctrl+T      Wort löschen
  53.  
  54.  Ctrl+L      Letzes Suchen/Ersetzen wiederholen
  55.  Ctrl+M      Neue Zeile hinter dem Cursor einfügen
  56.  Ctrl+O      Einrücke-Modus umschalten
  57.  
  58.  Ctrl+U      letzte Änderung rückgängig machen
  59.  Ctrl+V      Überschreiben/Einfügen umschalten
  60.  Ctrl+Y      Zeile löschen
  61.  
  62.  Shift+Ins   Text aus {Clipboard:Clipboard} einfügen
  63.  Shift+Del   markierten Text ins Clipboard löschen
  64.  Ctrl+Ins    markierten Text ins Clipboard kopieren
  65.  Ctrl+Del    Clipboard löschen
  66.  
  67.   Ctrl+Q "Quick"-Befehle
  68.   ----------------------
  69.  +A Text ersetzen
  70.  +C Textende
  71.  +D Zeilenende
  72.  +F Text suchen
  73.  +H bis Zeilenanfang löschen
  74.  +R Textbeginn
  75.  +S Zeilenanfang
  76.  +Y bis Zeilenende löschen
  77.  
  78.   Ctrl+K Blockbefehle
  79.   -------------------
  80.  +B Blockbeginn markieren
  81.  +C Block einfügen
  82.  +H Blockmarkierung entfernen
  83.  +K Block kopieren
  84.  +Y Block löschen 
  85.  
  86. .topic Clipboard=100
  87.  
  88.    Clipboard █
  89.   ▀▀▀▀▀▀▀▀▀▀▀▀
  90. Das Clipboard (Zwischenablage) ist ein normalerweise unsichtbares
  91. Edit-Fenster. In der Zwischenablage können immer wieder benötigte
  92. Textpassagen aufbewahrt werden, um sie bei Bedarf in das aktitve
  93. Edit-Fenster einzufügen.
  94. Auch der Transfer von markierten Textblöcken von einem Edit-Fenster
  95. in ein anderes geht über das Clipboard.
  96. Mit {Show Clipboard :EShowClip} können Sie die Zwischablage aktiv machen
  97. und auch den Text des Clipboards mit {SaveAs :FSaveAs} sichern.
  98.  
  99. .topic Make
  100.  
  101.    Make █
  102.   ▀▀▀▀▀▀▀
  103. Unter dem Menüpunkt "Make" sind alle Aufrufe des FST-Modula-2-Compilers
  104. untergebracht.
  105.  
  106. .topic Mbuild
  107.  
  108.    Build █
  109.   ▀▀▀▀▀▀▀▀
  110. Der Compiler wird mit der Option "/M" aufgerufen und compiliert
  111. alle Dateien neu. Der interne Zeitstempel wird aktualisiert.
  112. Voraussetzung für eine erfolgreiche Compilation unter diesem
  113. Menüpunkt ist die vorherige Erzeugung einer "Make-Datei". Sie
  114. können dazu den Menüpunkt {GenMake :MGenMake} verwenden.
  115.  
  116.  
  117. .topic MGenMake
  118.  
  119.    GenMake █
  120.   ▀▀▀▀▀▀▀▀▀▀
  121. GenMake erzeugt die Datei, die zur Recompilierung aller beteiligten
  122. Module notwendig ist. Das Hauptmodul muß zuvor unter dem Menüpunkt
  123. {Primary File :MPrimFile} angewählt sein.
  124.  
  125. .topic MCompile
  126.  
  127.    Compile █
  128.   ▀▀▀▀▀▀▀▀▀▀
  129. Compiliert die Datei im aktiven Fenster. Die Datei muß zuvor gesichert
  130. werden.
  131.  
  132. .topic MLink
  133.  
  134.    Link █
  135.   ▀▀▀▀▀▀▀
  136. Verbindet die compilierten Dateien (.M2O) zu einem lauffähigen (.EXE)
  137. Programm. Das Hauptmodul muß unter dem Menüpunkt {Primary File :MPrimFile}
  138. eingetragen sein.
  139.  
  140. .topic MyFiles
  141.  
  142.    Files █
  143.   ▀▀▀▀▀▀▀▀
  144. Unter diesem Menüpunkt sind alle Dateioperationen untergebracht.
  145.  
  146. .topic FDosShell
  147.  
  148.    DOS Shell █
  149.   ▀▀▀▀▀▀▀▀▀▀▀▀
  150. Sie können unter diesem Menüpunkt vorübergehend die Entwicklungsumgebung
  151. verlassen und ein DOS-Programm starten (vorausgesetzt, der verbleibende
  152. Speicherplatz ist ausreichend).
  153.  
  154. .topic Debug
  155.  
  156.    Debug █
  157.   ▀▀▀▀▀▀▀▀
  158. Unter diesem Menüpunkt sind alle Operationen untergebracht, die Ihr
  159. Programm zum Debuggen mit einem externen Debugger (vorzugsweise
  160. Turbo Debugger) vorbereiten.
  161.  
  162. .topic DMapFile
  163.  
  164.    MAP-File erzeugen █
  165.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  166. Erzeugt eine MAP-Datei, in der alle externen Referenzen (Prozeduren und
  167. Variablen aus anderen Modulen) aufgelistet sind. Der externe Debugger
  168. benötigt diese um zum Beispiel Variableninhalte anzeigen zu können.
  169. Im Hauptmodul muß der Compilerschalter (* $L *)  (generiere Zeilennummern)
  170. gesetzt sein.
  171. Das Programm muß vor dem Erzeugen der Map-Datei fehlerfrei compiliert und
  172. gelinkt werden.
  173.  
  174. .topic DPrepTD
  175.  
  176.    Debugging vorbereiten █
  177.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  178. Hängt die symbolischen Informationen an die erzeugte .EXE-Datei an. Die
  179. meisten Debugger benötigen Variablen- und Prozedurnamen, um sowohl den
  180. Maschinencode des erzeugten Programms als auch den Quelltext darstellen
  181. zu können.
  182. Zuvor muß das Programm fehlerfrei compiliert und gelinkt werden, die
  183. Map-Datei muß ebenfalls bereits erzeugt sein.
  184.  
  185. .topic MBrowse
  186.  
  187.    Error Dateien ansehen █
  188.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  189. Öffnet ein Auswahlfenster mit den von den aufgerufenen Werkzeugen
  190. erzeugten .ERR-Dateien. Diese Dateien zeigen das, was Sie gesehen
  191. hätten, wenn Sie die Programme von der Kommandozeile aus gestartet
  192. hätten.
  193.  
  194. .topic FOpen
  195.  
  196.    Datei öffnen █
  197.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  198. Präsentiert ein Auswahlfenster, in dem Sie die Datei, die Sie editieren
  199. möchten, anwählen können. Die vorgegebene Erweiterung ist .DEF oder
  200.  .MOD, je nachdem, welche {Default Extension :ODefaultExt}
  201. Sie mit dem dem Schalter im {Options}-Menü eingestellt haben.
  202.  
  203. .topic FChangeDir
  204.  
  205.    Verzeichnis wechseln █
  206.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  207. Erzeugt ein Dialogfenster, in dem Sie das aktuelle Verzeichnis neu
  208. bestimmen können.
  209.  
  210. .topic MPrimFile
  211.  
  212.    Hauptmodul wählen █
  213.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  214. Unter diesem Menüpunkt müssen Sie das Hauptmodul angeben.
  215.  
  216. .topic Options
  217.  
  218.    Optionen █
  219.   ▀▀▀▀▀▀▀▀▀▀▀
  220. Dieser Menüpunkt faßt alle festen Einstellungen der Entwicklungsumgebung
  221. zusammen.
  222.  
  223. .topic OSaveOpts
  224.  
  225.    Optionen sichern █
  226.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  227. Sichert die aktuell eingestellten Optionen der Entwicklungsumgebung
  228. in der Datei M2IDE.CFG. Ist die Datei nicht im aktuellen Verzeichnis,
  229. gibt die Entwicklungsumgebung die meisten Einstellungen gemäß der
  230. Installation vor. Sie müssen, wenn die Konfigurationsdatei versehentlich
  231. gelöscht wurde, die Einstellungen neu vornehmen. Besonders wichtig ist
  232. dabei die Vorgabe der {Verzeichnisse :ODirect} für die Programme
  233. des FST-Entwicklungspakets.
  234.  
  235. .topic OLoadOpts
  236.  
  237.    Optionen laden █
  238.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  239. Lädt die gespeicherten Optionen aus der Datei M2IDE.CFG.
  240.  
  241. .topic DRunTD
  242.  
  243.    Turbo Debugger starten █
  244.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  245. Startet den Turbo Debugger. Wenn Sie Ihr Programm ordnungsgemäß zum
  246. Debuggen vorbereitet haben, können Sie den Programmlauf im erzeugten
  247. Maschinencode und im Quelltext Schritt für Schritt nachvollziehen.
  248.  
  249. .topic ODevelop
  250.  
  251.    Entwicklungs-Schalter █
  252.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  253. Ist der Schalter aktiv (√), werden alle zur Erzeugung des lauffähigen
  254. Programms benötigten Dateien nicht gelöscht. Wenn Ihr Programm fehlerfrei
  255. läuft, können Sie den Schalter deaktivieren. Die erzeugte .EXE-Datei
  256. wird etwa 50% kleiner.
  257.   
  258. .topic About
  259.  
  260.    Über das Programm █
  261.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  262. Wie allgemein üblich, haben sich die Programmierer unter diesem Menüpunkt
  263. "verewigt". Bei Problemem mit dem Programm geben Sie bitte die Versionsnummer
  264. an.
  265.  
  266. .topic MySystem
  267.  
  268.    System █
  269.   ▀▀▀▀▀▀▀▀▀
  270. Dieser Menüpunkt faßt zunächst nur das Programmierer-Fenster (About) und
  271. den Wort-Kontext (für die kontext-sensitive Hilfe zu FST Modula 2) zusammen.
  272.  
  273. .topic FQuit
  274.  
  275.    IDE Verlassen █
  276.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  277. Beendet das Programm und bringt Sie sicher zurück zum DOS-Prompt. Sollten
  278. noch ungesicherte Dateien geöffnet sein, werden Sie vor dem endgültigen
  279. Abschied noch einmal gefragt.
  280.  
  281. .topic ODirect
  282.  
  283.    Verzeichnisse █
  284.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  285. Bitte geben Sie hier die Pfade an, in denen Sie die Entwicklungswerkzeuge
  286. des FST-System gespeichert haben.
  287.  
  288. .topic OEraseBat
  289.  
  290.    Batches löschen █
  291.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  292. Ist der Schalter aktiv, werden die von der IDE erzeugten Batch-Dateien
  293. gelöscht. Sie sollten den Schalter so lange deaktiv lassen, bis Ihr
  294. Programm fehlerfrei läuft.
  295.  
  296. .topic OEditBak
  297.  
  298.    .BAK anlegen █
  299.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  300. Der Editor legt von der aktuellen Datei eine Sicherheitskopie mit
  301. der Extension .BAK an, wenn der Schalter aktiv (√) ist.
  302.  
  303. .topic FChDir
  304.  
  305.    Verzeichnis wechseln █
  306.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  307. Es erscheint ein Dialog, in dem Sie auf dem Verzeichnisbaum des aktuellen
  308. Laufwerks ein neues Verzeichnis anwählen können, in dem Sie weiterarbeiten
  309. möchten. Auch das Laufwerk können Sie unter diesem Menüpunkt wechseln.
  310.  
  311. .topic FNew
  312.  
  313.    Neue Datei █
  314.   ▀▀▀▀▀▀▀▀▀▀▀▀▀
  315. Öffnet ein leeres Edit-Fenster mit dem Arbeitstitel "untitled". Sie können
  316. einen Text eingeben und ihn dann mit {SaveAs :FSaveAs} mit einem neuen
  317. Namen versehen.
  318.  
  319. .topic EShowClip
  320.  
  321.    Clipboard ansehen █
  322.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  323. In der Zwischenablage {Clipboard} werden markierte Blöcke zwischengespeichert.
  324. Ist das Clipboard aktiv, können Sie die dort abgelegten Texte editieren.
  325.  
  326. .topic WTile
  327.  
  328.    Fenster nebeneinander █
  329.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  330. Nach dem Anwählen dieses Menüpunkts werden die geöffneten Fenster mit 
  331. Ausnahme des {Clipboard} nebeneinander auf dem Bildschirm "ausgebreitet".
  332. Mit {Zoom :WZoom} können Sie das aktive Fenster (erkennbar an der
  333. Rahmenfarbe) auf volle Größe bringen. 
  334.  
  335. .topic WCascade
  336.  
  337.    Datei sichern als █
  338.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  339. Dieser Menüpunkt fächert die geöffneten Fenster zu einem Stapel auf. Die
  340. Nummern in der rechten oberen Ecke dienen zur Anwahl des Aktiven Fensters.
  341. Mit {Zoom :WZoom} können Sie das aktive Fenster (erkennbar an der
  342. Rahmenfarbe) auf volle Größe bringen. 
  343.  
  344. .topic FSave
  345.  
  346.    Datei sichern █
  347.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  348. Speichert die Datei auf dem Datenträger. Soll die Datei einen anderen 
  349. Namen erhalten oder in einem anderen als dem aktuellen Verzeichnis
  350. abgelegt werden, müssen Sie den Menüpunkt {SaveAs :FSaveAs} wählen.
  351.  
  352. .topic FSaveAs
  353.  
  354.    Datei sichern als █
  355.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  356. Es erscheint ein Dialogfenster, in dem Sie den Namen eingeben können,
  357. unter dem Sie den Text im aktiven Fenster sichern möchten. Sie können
  358. allerdings auch einen Namen aus der Dateiübersicht wählen und eine
  359. bereits vorhandene Datei überschreiben.
  360.  
  361. .topic Edit
  362.  
  363.    Edit █
  364.   ▀▀▀▀▀▀▀
  365. Unter diesem Menüpunkt sind spezielle {Editor:NoContext}-Befehle zu finden.
  366.  
  367. .topic EUndo
  368.  
  369.    Rückgängig machen █
  370.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  371. Macht die letzte Änderung rückgängig.
  372.  
  373. .topic ECut
  374.  
  375.    Block "ausschneiden" █
  376.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  377. Der markierte Block wird aus den aktiven Edit-Fenster ausgeschnitten und
  378. vorerst auf dem {Clipboard} abgelegt. Wenn Sie den Text an einer anderen
  379. Stelle im Text einfügen möchten {Paste :EPaste}, müssen Sie dies vor
  380. dem nächsten Ausschneiden tun, da immer nur ein "Textschnipsel" in
  381. der Zwischenablage Platz findet.
  382.  
  383. .topic ECopy
  384.  
  385.    Block kopieren █
  386.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  387. Kopiert den markierten Block in die Zwischenablage {Clipboard}.
  388. Mit {Paste :EPaste} können Sie den Block an anderer Stelle wieder
  389. einfügen.
  390.  
  391.   Siehe auch : {Editor :NoContext}
  392.  
  393. .topic EPaste
  394.  
  395.    Text "einkleben" █
  396.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  397. Fügt einen Textblock aus der Zwischablage an der Cursorposition
  398. in das aktive Edit-Fenster ein.
  399.  
  400. .topic EClear
  401.  
  402.    Textblock löschen █
  403.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  404. Löscht den markiertene Textblock.
  405.  
  406. .topic Search
  407.  
  408.    Suchen und Ersetzen █
  409.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  410. Unter diesem Menüpunkt sind Operationen zu finden, die es Ihnen ermöglichen,
  411. Textstellen schnell aufzufinden sowie Zeichenketten durch andere zu ersetzen.
  412.  
  413. .topic SFind
  414.  
  415.    Textstelle suchen █
  416.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  417. Öffnet einen Dialog, in dem Sie eine Zeichenkette eigeben können,
  418. die im aktiven Edit-Fenster gesucht werden soll. Die Suche kann
  419. sich auf ganze Worte beziehen (Whole words only [X]) und unabhängig
  420. von der Groß-/Kleinschreibung erfolgen (Case sensitive [ ]).
  421. Die letzten fünf Suchbegriffen können Sie im History-Fenster auswählen,
  422. das sich öffnet, wenn Sie den grünen Pfeil neben der Eingabezeile
  423. anwählen.
  424.  
  425.   Tastatur-Kurzanwahl : Ctrl+Q F
  426.   
  427. .topic SReplace
  428.  
  429.    Suchen und Ersetzen █
  430.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  431. Wie unter dem Menüpunkt {Find :SFind} können Sie eine Zeichenkette
  432. eingeben, die gesucht werden soll. Auf der Eingabezeile "New Text"
  433. tragen Sie den Text ein, der den Suchbegriff ersetzen soll.
  434. Ist "Prompt on Replace" aktiv [X], werden Sie vor jedem Ersetzen
  435. gefragt, "Replace all" [X] ersetzt alle gefundenen Begriffe.
  436.  
  437.   Tastatur-Kurzanwahl : Ctrl+Q A
  438.   
  439. .topic SSearchAgain
  440.  
  441.    Suchen/Ersetzen wiederholen █
  442.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  443.  
  444.   Tastatur-Kurzanwahl : Ctrl+L
  445.   
  446. .topic MyWindows
  447.  
  448.    Fenster █
  449.   ▀▀▀▀▀▀▀▀▀▀
  450. Faßt die Operationen zur Gestaltung der Arbeitsoberfläche (Desktop)
  451. zusammen.
  452.  
  453. .topic WResize
  454.  
  455.    Größe verändern █
  456.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  457. Die Anwahl dieses Menüpunkts ändert die Rahmenfarbe und zeigt eine neue
  458. Statuszeile. Mit den Pfeiltasten können Sie die Größe des aktiven
  459. Fensters verändern und es auf dem Desktop verschieben.
  460.  
  461.   Tastatur-Kurzanwahl : Ctrl-F5
  462.   
  463. .topic WZoom
  464.  
  465.    Vollbild █
  466.   ▀▀▀▀▀▀▀▀▀▀▀
  467. Bringt das aktive Fenster zur vollen Größe. Die Anwahl dieses Menüpunkts
  468. hat die gleiche Funktion wie ein Anklicken des Pfeils in der oberen rechten
  469. Ecke des Fensters.
  470.  
  471.   Tastatur-Kurzanwahl : F5
  472.   
  473. .topic WNext
  474.  
  475.    Nächstes Fenster aktivieren █
  476.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  477. Macht das nächste Fenster im Fensterstapel auf der Arbeitsoberfläche
  478. aktiv.
  479.  
  480.   Tastatur-Kurzanwahl : F6
  481.   
  482. .topic WPrev
  483.  
  484.    Voriges Fenster aktivieren █
  485.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  486. Macht das vorige Fenster im Fensterstapel aktiv.
  487.  
  488.   Tastatur-Kurzanwahl : Shift-F6
  489.   
  490. .topic WClose
  491.  
  492.    Fenster schließen █
  493.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  494. Schließt das aktive Fenster. Ist die Datei nicht gesichert, werden Sie
  495. gefragt, ob Sie den Text speichern wollen. Die Anwahl des Menüpunkts
  496. hat die gleiche Funktion wie ein Anklicken des "Schließen"-Knopfes in der
  497. oberen linken Ecke des Fensters.
  498.  
  499.   Tastatur-Kurzanwahl : Alt-F3
  500.   
  501. .topic SGoto
  502.  
  503.    Cursor auf Zeile/Spalte █
  504.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  505. Öffnet ein Dialogfenster, in dem Sie die Zeile und die Spalte angeben
  506. können, auf die der Cursor gesetzt werden soll. Diese Funktion ist
  507. bei der Bereinigung von syntaktischen Fehlern aus der Datei COMPILER.ERR
  508. nützlich.
  509.  
  510. .topic Context
  511.  
  512.    Wort Context █
  513.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  514. Wenn es zu diesem Wort im Text einen Hilfebegriff gibt, wird das
  515. zugehörige Hilfefenster geöffnet.
  516.  
  517.   Tastatur-Kurzanwahl : Ctrl-F1
  518.   
  519. .topic ODefaultExt
  520.  
  521.    Default Extension █
  522.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  523. Der Schalter setzt die vorgegebene Dateinamen-Erweiterung für die
  524. Dateiauswahldialoge.
  525.  
  526. .topic Index
  527.  
  528.    Hilfe-Index ▄
  529.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  530.  
  531.  Standard-{Module}     Modula-{Schleifentypen}
  532.  {Routinen}            Standard-{Typen}
  533.  {ASCII}-Zeichen       {Tastaturcodes}
  534.  {Compilerschalter}    {Inline-Assembler:IAssembler}
  535.  {Laufzeitfehler}      {Reservierte Worte:ReservedWord}
  536.  {Sprachkonventionen}  {Compiler-Begrenzungen:CompLimits}
  537.  Objekt-{Zeitstempel}  {Environment}-Variablen
  538.  
  539. Ende mit ESC
  540.  
  541. .topic Module
  542.  
  543.    Modul-Index  ▄
  544.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  545.  
  546.  {ASCII}             {Break}
  547.  {Directories}       {Display}
  548.  {DTA}               {Files}
  549.  {FileSpec}          {FileSystem}
  550.  {InOut}             {KeyBoard}
  551.  {Loader}            {LongJump:MLongJump}
  552.  {Menu}              {LMathLib0/MathLib0:MathLib0}
  553.  {NumberConversion}  {Paths}
  554.  {RealConversion}    {RealInOut}
  555.  {Storage}           {Strings}
  556.  {SYSTEM:mSYSTEM}            {System:DOSSystem}
  557.  {TermBase}          {Terminal}
  558.  {TermIO}            {TimeDate}
  559.  {Windows}
  560.  
  561.  
  562. Zurück zum {Index}, Ende mit ESC
  563.  
  564. .topic Routinen
  565.  
  566.   Liste der Standandprozeduren ▄
  567.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  568.   Prozeduren A - E:
  569.  ──────────────────┘
  570.  
  571.  {ADR}               {ALLOCATE}
  572.  {Append}            {arctan}
  573.  {ASCIIZ}            {Assign}
  574.  {AssignGoto}        {AssignRead}
  575.  {AssignWrite}       {Available}
  576.  {CardToString}      {ChDir}
  577.  {Close}             {CloseCurWindow}
  578.  {CloseInput}        {CloseOutput}
  579.  {CloseWindow}       {ClrEOL}
  580.  {ClrEOS}            {ClrScreen}
  581.  {CompareStr}        {Concat}
  582.  {Copy}              {cos}
  583.  {Create}            {CreateNew}
  584.  {CreateTemp}        {DEALLOCATE}
  585.  {Delete}            {DirQuery}
  586.  {DisableBreak}      {DisplayLine}
  587.  {DisplayString}     {DISPOSE}
  588.  {DropExt}           {Dup2}
  589.  {Dup}               {EnableBreak}
  590.  {entier}            {ErrorMessage}
  591.  {ErrorLn}           {Execute}
  592.  {exp}               {ExtractDirPath}
  593.  {ExtractFileName}
  594.  
  595.  {Weiter}
  596.  
  597. Zurück zum {Index}, Ende mit ESC
  598.  
  599. .topic Weiter
  600.  
  601.   Liste der Standandprozeduren ▄
  602.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  603.  
  604.   Prozeduren F - P:
  605.  ──────────────────┘
  606.  {Zurück:Routinen}
  607.  
  608.  {FLAT}              {FLOAT}
  609.  {GetArg}            {GetCurDir}
  610.  {GetCursorPosition} {GetDisplayMode}
  611.  {GetDTA}            {GetEnv}
  612.  {GetFileAttr}       {GetFileTime}
  613.  {GetFirstDir}       {GetFunKey}
  614.  {GetKey}            {GetKeyCh}
  615.  {GetLPos}           {GetNextDir}
  616.  {GetPos}            {GetShiftStatus}
  617.  {GetTime}           {GetVector}
  618.  {Goto}              {HasExt}
  619.  {Insert}            {InstallBreakHandler}
  620.  {IntToString}       {InstallRTErrorHandler}
  621.  {KeyPressed}        {Length}
  622.  {LLength}           {ln}
  623.  {Locate}            {Lock}
  624.  {LongCardToString}  {LongIntToString}
  625.  {LongJump}          {LongNumToString}
  626.  {LongRealToString}  {LookUp}
  627.  {MkDir}             {Move}
  628.  {NEW}               {NEWPROCESS}
  629.  {NewWindowTitle}    {NumToString}
  630.  {OFFSET}            {Open}
  631.  {OpenInput}         {OpenOutPut}
  632.  {OpenWindow}        {ParseFileSpec}
  633.  {PopMenu}           {Pos}
  634.  {PTR}               {PullDownMenu}
  635.  
  636.  {Weiter:Weiter2}
  637.  
  638.  Zurück zum {Index}, Ende mit ESC
  639.  
  640. .topic Weiter2
  641.  
  642.   Liste der Standandprozeduren ▄
  643.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  644.  
  645.   Prozeduren P - T:
  646.  ───────────────────┘
  647.  {Zurück:Weiter}
  648.  
  649.  {real}              {Read}
  650.  {ReadAgain}         {ReadCard}
  651.  {ReadChar}          {ReadCharAttr}
  652.  {ReadInt}           {ReadLine}
  653.  {ReadLongCard}      {ReadLongInt}
  654.  {ReadNBytes}        {ReadReal}
  655.  {ReadScreen}        {ReadString}
  656.  {ReadWord}          {ReadWrd}
  657.  {RealToString}      {RedirectInput}
  658.  {RedirectOutput}    {Rename}
  659.  {Reset}             {ResetVector}
  660.  {Rewrite}           {RmDir}
  661.  {ScrollDown}        {ScrollUp}
  662.  {Seek}              {SEGMENT}
  663.  {SelectWindow}      {SetCursorPosition}
  664.  {SetCursorType}     {SetDisplayMode}
  665.  {SetDTA}            {SetFileAttr}
  666.  {SetFileTime}       {SetJump}
  667.  {SetLPos}           {SetPos}
  668.  {SetTime}           {SetVector}
  669.  {SHORT}             {sin}
  670.  {sqrt}              {StringToInt}
  671.  {StringToLongCard}  {StringToLongInt}
  672.  {StringToLongNum}   {StringToLongReal}
  673.  {StringToNum}       {StringToReal}
  674.  {Terminate}         {TermProcedure}
  675.  {TRANSFER}          {Trap}
  676.  {TRUNC}
  677.  
  678.  {Weiter:Weiter3}
  679.  
  680.  Zurück zum {Index}, Ende mit ESC
  681.  
  682. .topic Weiter3
  683.  
  684.   Liste der Standandprozeduren ▄
  685.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  686.  
  687.   Topics ab U:
  688.  ──────────────┘
  689.  {Zurück:Weiter2}
  690.  
  691.  {UnAssignGoto}      {UnAssignRead}
  692.  {UnAssignWrite}     {UninstallBreakHandler}
  693.  {Unlock}            {UninstallRTErrorHandler}
  694.  {Write}             {WriteCard}
  695.  {WriteChar}         {WriteCharAttr}
  696.  {WriteHex}          {WriteInt}
  697.  {WriteLine}         {WriteLn}
  698.  {WriteLongCard}     {WriteLongInt}
  699.  {WriteNBytes}       {WriteOct}
  700.  {WriteReal}         {WriteScreen}
  701.  {WriteString}       {WriteWord}
  702.  {WriteWrd}          {XTrap}
  703.  
  704.  Zurück zum {Index}, Ende mit ESC
  705.  
  706. .topic IAssembler
  707.  
  708.   der integrierte Assembler ▄
  709.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  710.  
  711. Es ist ein 8086 Inline-Assembler eingebaut.
  712.  
  713. Wenn der {ASSEMBLER} aus {SYSTEM:mSYSTEM} importiert ist, 
  714. können Sie im Quelltext Assembler-Code eingeben.
  715. Dieser muß nur mit den Schlüsselworten {ASM} und END eingeklammert werden.
  716.  
  717. Die Form des Assembler-Codes ist frei. 
  718. Kommentare werden wie in Modula-2 üblich eingegeben.
  719.  
  720. Die Zeilen dürfen nicht mit einem Strichpunkt abgeschlossen werden.
  721.  
  722.  Beispiele:
  723.    loop:  CMP BYTE [SI], 0
  724.            (* String-Ende erreicht? *)
  725.           MOV BYTE [DI], [SI]
  726.           INC SI
  727.           INC DI  (* Zeiger erhöhen *)
  728.           JMP loop
  729.  
  730.   PROCEDURE SHR(in, shifter: CARDINAL): CARDINAL:
  731.   VAR
  732.     out: CARDINAL;
  733.   BEGIN
  734.      ASM
  735.        MOV AX, in
  736.        MOV CX, shifter
  737.        SHR AX, CL
  738.        MOV out, AX
  739.      END;
  740.      RETURN out;
  741.   END SHR;
  742.  
  743. Der Assembler akzeptiert alle 8086/8088-Mnemonics.
  744. Adreß-Operanden können in jeder Form codiert werden, 
  745. die auch andere Assembler verstehen, mit der Einschränkung, 
  746. daß der einzige verfügbare Operator "+" ist.
  747.  
  748. Typ-Bestimmungen sind: {WORD}, {BYTE}, {FAR}, {NEAR}
  749. und sie dürfen nicht von den Schlüsselworten {POINTER}
  750. oder {PTR} gefolgt sein.
  751.  
  752.  Beispiel:
  753.  
  754.    label: MOV  AX, ES:[BX,DI+5]
  755.           MOV  AX, ES:5[DI+BX]
  756.           MOV  WORD [5], 1
  757.           CALL NEAR [DI]
  758.           TEST BYTE i+2, 1
  759.  
  760. Alle Mnemonics und Registernamen müssen in Großbuchstaben geschrieben sein.
  761. Wenn Sie auf einen Modula-2-Bezeichner zugreifen wollen, 
  762. jedoch dabei in Konflikt mit einem im Assembler reservierten Symbol kommen, 
  763. stellen Sie einfach ein "@" voran.
  764.  
  765.  Beispiel:
  766.  
  767.    MOV @AX, AX
  768.  
  769. generiert einen Move von Register AX nach Variable AX.
  770.  
  771. Alle Modula-2-Variablen sind grundsätzlich vom Assembler aus zugänglich. 
  772. Record-Komponenten-Namen sind nicht zugänglich.
  773. Der Assembler tut für Sie nichts automatisch!
  774. Wenn Sie beispielsweise einen VAR-Parameter als Operanden einsetzen, 
  775. müssen Sie über die Zeiger-Adresse auf den tatsächlichen Parameter zugreifen.
  776.  
  777.  Beispiel:
  778.    PROCEDURE p(VAR done: BOOLEAN);
  779.    ...
  780.    ASM
  781.      LES DI, done
  782.      MOV BYTE ES:[DI], TRUE
  783.    END;
  784.  
  785. ist der korrekte Weg, "done" mit TRUE zu besetzen.
  786.  
  787. Auf Konstanten der folgenden Typen kann in Assembler zugegriffen werden:
  788.  
  789.  {INTEGER},
  790.  {CARDINAL},
  791.  {BOOLEAN},
  792.  {CHAR} und
  793.  Aufzählungs-Konstanten.
  794.  
  795. Alle Marken (Labels) eines {ASM}-Abschnitts sind lokal zu diesem Abschnitt.
  796. Andere Namen, die außerhalb deklariert sind und die in der Prozedur
  797. sichtbar sind, dürfen nicht als Label-Namen verwendet werden.
  798. Auf Labels darf nur in Sprung-Befehlen verwiesen werden.
  799.  
  800. Alle Sprünge werden vom Compiler optimiert.
  801. Deshalb braucht die Sprungweite nicht spezifiziert zu werden.
  802.  
  803. Denken Sie daran, daß dies ein Modula-2-Compiler ist, kein Assembler!
  804. Der Inline-Assembler ist nur für den Gebrauch in Ausnahmesituationen gedacht.
  805.  
  806.   8087 Unterstützung
  807.  ════════════════════╝
  808.  
  809. Alle Befehle des Coprozessors 8087 werden vom Inline-Assembler verarbeitet.
  810. Die Zusatzbefehle des 80186 (═ 80286-Realmode) werden nicht verstanden und
  811. müssen im Notfall als Datenbereich mit "DB" eingegeben werden.
  812. Labels können (ohne Deklarierung) eingesetzt werden.
  813.  
  814. Der Assembler besitzt ein paar Einschränkungen.
  815. Nur die folgenden Operandentypen sind bei Load- und Store-Operationen möglich:
  816.  
  817.  {INTEGER}, {LONGINT}, {REAL} und {LONGREAL}.
  818.  
  819. Sie können kein Load/Store mit einem Wert in temporärem Real- oder
  820. Dezimal-Format durchführen.
  821. Die Bedeutung der operandenlosen Form der arithmetischen Befehle
  822. wurde beibehalten:
  823.  
  824.  ■ FADD, FSUB, FMUL und FDIV arbeiten
  825.    mit den beiden oberen Elementen
  826.    des 8087-Stack.
  827.    Sie benutzen ST(1) als Ziel und
  828.    entfernen ST.
  829.  
  830.  ■ FSUBR subtrahiert ST(1) von
  831.    ST (FDIVR dividiert ST durch
  832.    ST(1)), wobei das Ergebnis
  833.    in ST(1) abgelegt und ST entfernt
  834.    wird.
  835.  
  836. Das Zwei-Operanden-Format der arithmetischen Befehle
  837. wurde nicht implementiert.
  838. Daher dürfen Sie kein anderes Zielregister als ST
  839. angeben, außer bei den "und pop"-Versionen der Befehle.
  840.  
  841. Mit einem normalen Assembler können Sie bei Register-Register-Operationen
  842. dasjenige Register angeben, in welchem das Ergebnis der Operation
  843. abgelegt werden soll (das Zielregister). Per Definition ist das Zielregister
  844. auch der erste Operand des Befehls. Mit dem Inline-Assembler ist jedoch
  845. immer ST das Ziel einer Operation. Ausnahme sind die "und pop"-Versionen
  846. der Befehle, bei denen das im jeweiligen Befehl angegebene Register das
  847. Ziel der Operation ist.
  848.  
  849. Um die Konsistenz zu wahren, sollte ST immer der erste Operand sein,
  850. auch wenn die "und pop"-Form benutzt wird.
  851.  
  852. Die Bedeutung von FSUBP, FSUBRP, FDIVP und FDIVRP ist also:
  853.  
  854.  ■ FSUBP ST(1) bedeutet:
  855.  
  856.    FSUBRP ST(1),ST -> ST(1):═ST-ST(1)
  857.  
  858.  ■ FSUBRP ST(1) bedeutet:
  859.  
  860.     FSUBP ST(1),ST -> ST(1):═ST(1)-ST
  861.  
  862.  ■ FDIVP ST(1) bedeutet:
  863.  
  864.    FDIVRP ST(1),ST -> ST(1):═ST/ST(1)
  865.  
  866.  ■ FDIVRP ST(1) bedeutet:
  867.  
  868.    FDIVP ST(1),ST -> ST(1):═ST(1)/ST und ST wird entfernt (pop).
  869.  
  870.  Beispiel:
  871.  ─────────
  872.  
  873.   VAR
  874.     wert: WORD;
  875.   BEGIN
  876.     ASM
  877.       ...
  878.   @wert:
  879.       ...
  880.       MOV wert, BX
  881.       CMP BX, CX
  882.       JNZ @wert
  883.       ...
  884.     END;
  885.  
  886. Eine Liste der Assembler-Befehle der Intel-Prozessorenreihe kann
  887. (mit der jeweiligen Beschreibung) jedem Assembler-Buch entnommen werden).
  888.  
  889. Zurück zum {Index}, Ende mit ESC
  890.  
  891. .topic Schleifentypen, LOOP, FOR, WHILE, BY, CASE, ELSE, ELSIF, WITH
  892.  
  893.   Modula-2-Schleifentypen ▄
  894.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  895.  
  896. Modula bietet mehr Schleifentypen als Pascal.
  897. Die Syntax der Schleifen weicht ebenfalls von Pascal ab.
  898.  
  899.   LOOP-Schleife (Endlosschleife):
  900.  ────────────────────────────────┘
  901.  
  902. Die Abbruchbedingung muß explizit in der Schleife mit "EXIT" erfolgen:
  903.  
  904.   LOOP
  905.     (* mach irgendwas *)
  906.     IF bedingung THEN EXIT;
  907.   END;
  908.  
  909.  ══════════════════════════════════════
  910.  
  911.   FOR-Schleife (einfache Zählschleife):
  912.  ──────────────────────────────────────┘
  913.  
  914.   FOR var1 TO var2 <<BY> <->var3> DO
  915.      (* abarbeiten *)
  916.   END;
  917.  
  918. "BY" ist optional und gibt die Sprungweite beim Schleifendurchgang (identisch zum STEP-Befehl in BASIC) an.
  919.  
  920.  ═══════════════════════════════════════
  921.  
  922.   Einfache Bedingung mit "IF":
  923.  ──────────────────────────────┘
  924.  
  925.   IF bedingung1 THEN
  926.     (* mach irgendwas *)
  927.   <ELSIF bedingung2>
  928.     (* mach irgendwas anderes *)
  929.   <ELSE>
  930.     (* mach irgendwas ganz anderes *)
  931.   END;
  932.  
  933.  ══════════════════════════════════════
  934.  
  935.   Einfache Bedingung mit "CASE":
  936.  ───────────────────────────────┘
  937.  
  938.   CASE var1 OF
  939.     wert1: (* mach was *)
  940.  <| wert2: (* mach was anderes *)>
  941.  <| wert3: (* mach wieder was anderes *)>
  942.   ELSE     (* fang den Rest ab *)
  943.   END;
  944.  
  945.  ══════════════════════════════════════
  946.  
  947.   Kopfgesteuerte "WHILE"-Wiederholanweisung:
  948.  ───────────────────────────────────────────┘
  949.  
  950.   WHILE <NOT> bedingung DO
  951.     (* eine Schleife abarbeiten *)
  952.   END;
  953.  
  954. Die Bedingung muß beim Einsprung erfüllt sein.
  955. Die Schleife wird verlassen, wenn die Bedingung nicht mehr erfüllt ist.
  956.  
  957. Falls die Bedingung anfangs nicht erfüllt wird,
  958. wird die Schleife nicht ausgeführt.
  959.  
  960.  ══════════════════════════════════════
  961.  
  962.   Fußgesteuerte REPEAT-Wiederholanweisung:
  963.  ─────────────────────────────────────────┘
  964.  
  965.   REPEAT
  966.     (* mach was *)
  967.   UNTIL <NOT> bedingung;
  968.  
  969. Die Bedingung darf beim Einsprung erfüllt sein (muß aber nicht).
  970.  
  971. Dieser Schleifentyp wird grundsätzlich mindestens einmal durchlaufen.
  972.  
  973.  ══════════════════════════════════════
  974.  
  975.   Abarbeiten von RECORD-Abweisungen:
  976.  ──────────────────────────────────┘
  977.  
  978.  WITH Persons[i] DO
  979.    IF (Age < 4) THEN
  980.     (* Kleinkind *)
  981.   <ELSEIF (Age < 15) THEN>
  982.     (* Jugendlicher *)
  983.   <ELSE>
  984.     (* Erwachsener *)
  985.    END;
  986.  END;
  987.  
  988. WITH-Anweisungen werden benutzt, damit die Felder eines RECORDs
  989. als Schleifenvariablen genutzt werden können.
  990.  
  991.  
  992. Zurück zum {Index}
  993.  
  994. .topic Sprachkonventionen, DEFINITION, IMPLEMENTATION
  995.  
  996.   Modula kontra Pascal: Konventionen ▄
  997.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  998.  
  999.  ■ Modula ist Case-sensitiv, d.h. Klein-
  1000.    und Großschreibung werden wie in C und
  1001.   im Gegensatz zu Pascal unterschieden.
  1002.  
  1003.  ■ Trennung von DEFINITION (.DEF) und
  1004.    IMPLEMENTATION (.MOD) in getrennten Dateien.
  1005.  
  1006.  ■ Beenden von Prozeduren mit END ModulName.
  1007.    Hinter Prozeduren Ende mit Semikolon (;),
  1008.    am Ende von Modulen mit Punkt (.).
  1009.  
  1010.    Nur das Hauptmodul bekommt die Bezeichnung
  1011.    MODULE ModulName; sonst muß festgelegt
  1012.    werden, ob es sich um ein Definitions-
  1013.    oder Implementationsmodul handelt.
  1014.  
  1015.  ■ In DEFINITION-Modulen dürfen nur Variablen,
  1016.    Typen, Konstanten und Prozedurköpfe stehen.
  1017.    Im Unterschied zu Turbo Pascal-Unit-
  1018.    Implementationen dürfen keine Codeteile
  1019.    eingebunden sein.
  1020.  
  1021. Die Modula-Definitionsdateien dienen nur dem Im- und Export.
  1022. Dieser kann qualifiziert oder unqualifiziert erfolgen.
  1023.  
  1024. Beispiel:
  1025.  
  1026.  IMPORT ASCII; (* Qualifizierter Import       *)
  1027.                (* vergleichbar mit dem Import *)
  1028.                (* von Turbo-Pascal-Objekten.  *)
  1029.  FROM Files IMPORT Write, WriteChar;
  1030.                (* Unqualifizierter Import.    *)
  1031.  FROM FileSpec IMPORT ;
  1032.                (* Import des gesamten Defi-   *)
  1033.                (* nitionsteiles eines Moduls  *)
  1034.                (* äquivalent zum Import von   *)
  1035.                (* Turbo-Pascal Units.         *)
  1036.  
  1037. Der unqualifizierte Import von gleichnamigen Prozeduren
  1038. aus mehreren Modulen ist nicht möglich:
  1039.  
  1040.  FROM Files IMPORT Write;
  1041.  FROM InOut IMPORT Write;
  1042.  
  1043. Der zweite Import wird vom Compiler beanstandet.
  1044. Hier ist es nur möglich, mindestens ein Modul
  1045. qualifiziert zu importieren:
  1046.  
  1047.      IMPORT Files;
  1048.      FROM Inout IMPORT Write;
  1049.  
  1050.  ■ Prozeduren mit Rückgabewert (Funktionsparametern):
  1051.  
  1052. Im Gegensatz zu Pascal gibt es in Modula keine Funktionen (FUNCTION).
  1053. Dies wird dadurch umgangen, daß Prozeduren ebenfalls einen
  1054. Parameter zurückgeben können.
  1055. Allerdings muß dieser ein ordinaler Typ sein.
  1056. Zusammengesetzte Typen dürfen nicht verwendet werden.
  1057.  
  1058.  Die Pascal-Funktion:
  1059.  
  1060.   FUNCTION MessageBack: STRING;
  1061.  
  1062. ist aus diesem Grund nicht möglich.
  1063.  
  1064. Der Typ "ARRAY OF CHAR" der dem Pascal-String entspricht,
  1065. ist kein ordinaler Typ und kann deshalb nicht als
  1066. Funktionsparameter dienen. Die Struktur muß folglich
  1067. mit einem VAR-Parameter zurückgegeben werden:
  1068.  
  1069.  PROCEDURE MessageBack(VAR Back: ARRAY OF CHAR);
  1070.  
  1071. oder mit einem Zeigers auf den String:
  1072.  
  1073.  TYPE
  1074.    String: ARRAY OF CHAR;
  1075.    PtrStr: POINTER TO String;
  1076.  
  1077.  PROCEDURE MessageBack(): PtrStr;
  1078.  
  1079. Bei ordinalen Typen kann die Struktur wie in
  1080. Pascal programmiert werden:
  1081.  
  1082.   Pascal:
  1083.   ──────
  1084.  
  1085.  FUNCTION GetBack: BOOLEAN;
  1086.  BEGIN
  1087.    GetBack :═ FALSE;
  1088.    IF KeyPressed THEN GetBack :═ TRUE;
  1089.  END;
  1090.  
  1091.   Modula:
  1092.   ───────
  1093.  
  1094.  PROCEDURE GetBack(): BOOLEAN;
  1095.  VAR
  1096.    vBack: BOOLEAN;
  1097.  BEGIN
  1098.    vBack :═ FALSE;
  1099.    IF KeyBoard.KeyPressed() THEN
  1100.      vBack :═ TRUE;
  1101.    END;
  1102.    RETURN vBack; (* Rückgabe! *)
  1103.  END GetBack;
  1104.  
  1105. ■ Fremdsprachige Module:
  1106.  
  1107. Um dem Modula-2-Compiler die nötigen Informationen
  1108. über die in anderen Sprachen geschriebenen Module
  1109. verfügbar zu machen, müssen sogenannte
  1110. FOREIGN-DEFINITION(Fremd-Definitions)-Module geschrieben werden.
  1111.  
  1112. Ein FOREIGN-DEFINITION-Modul ist ein normales
  1113. Definitions-Modul mit einem etwas veränderten Modulkopf,
  1114. der folgendermaßen aussieht:
  1115.  
  1116.  FOREIGN [C|PASCAL] DEFINITION MODULE modName;
  1117.  
  1118. wobei der "C"- oder "PASCAL"-Bezeichner optional ist.
  1119.  
  1120. Namen von globalen Variablen und Prozeduren in Fremdmodulen
  1121. werden auf drei Arten codiert:
  1122.  
  1123.  ■ Bei einem normalen (weder C noch
  1124.    PASCAL) FOREIGN-Modul stehen die
  1125.    Bezeichner so in der Object-Datei
  1126.    wie Sie sie geschrieben haben.
  1127.  
  1128.  ■ Bei einem FOREIGN-C-Modul ist vor
  1129.    jeden Bezeichner ein "_"-Zeichen
  1130.    gesetzt.
  1131.  
  1132.  ■ Bei einem FOREIGN-PASCAL Modul werden
  1133.    alle Bezeichner in Großbuchstaben
  1134.    umgewandelt.
  1135.  
  1136. WARNUNG: Bei der vorliegenden Implementierung erzeugt der
  1137. Compiler für Zugriffe auf SET- und STRING-Konstanten, die
  1138. in einem FOREIGN-DEFINITION-Module definiert sind, externe Verweise.
  1139. Für diese "Konstanten" sollte daher der Speicherplatz
  1140. im Fremdmodul liegen und dieser sollte korrekt initialisiert werden.
  1141. Bei FOREIGN-Modulen wird keine Initialisierungs-Prozedur
  1142. erwartet und der Compiler erzeugt die entsprechenden
  1143. Initialisierungs-Aufrufe nur bei normalen Modula-2-Modulen.
  1144.  
  1145. ■ FOREIGN-C-Module:
  1146.  
  1147. Beim Aufruf eines Unterprogramms in einem FOREIGN-C-Modul
  1148. werden die Argumente, wie bei C üblich, in umgekehrter
  1149. Reihenfolge auf den Stack gelegt.
  1150. Bei der Rückkehr vom Unterprogramm entfernt außerdem
  1151. der Aufrufer selbst die Argumente vom Stack.
  1152. Da C im Gegensatz zu Modula-2 die Übergabe einer
  1153. variablen Anzahl von Parametern unterstützt,
  1154. kann in Fitted Modula das Zeichen "." am
  1155. Ende einer Parameterliste benutzt werden,
  1156. um anzuzeigen, daß eine unbestimmte Anzahl von
  1157. Argumenten übergeben wird.
  1158.  
  1159.  Das Beispiel:
  1160.    PROCEDURE sum(n: INTEGER; . ): INTEGER;
  1161.  
  1162. definiert eine Funktion die aus n Integers die
  1163. Summe bildet und zurückgibt.
  1164. Sie könnte in Modula-2 folgendermaßen definiert werden:
  1165.  
  1166.  PROCEDURE sum(n: INTEGER; . ): INTEGER;
  1167.  VAR
  1168.    p:   POINTER TO INTEGER;
  1169.    res: INTEGER;
  1170.  BEGIN
  1171.    res :═ 0;
  1172.    p :═ ADR(n) + 2;
  1173.    WHILE n > 0 DO
  1174.      res :═ res + p^;
  1175.      INC(p, 2);
  1176.      DEC(n);
  1177.    END;
  1178.    RETURN res;
  1179.  END sum;
  1180.  
  1181. ■ Parameter-Übergabe:
  1182.  
  1183. Die Form in der die einzelnen Parameter übergeben
  1184. werden, ist immer gleich, egal ob sich die Prozedur
  1185. in einem Fremdmodul befindet oder nicht.
  1186. Die Ausnahme ist der Gebrauch von ".".
  1187. Bei der Übergabe von Parametern für die im Prozedurkopf
  1188. der "." steht, folgt der Compiler den üblichen Regeln
  1189. von C: Alles wird als Wert übergeben (call by value),
  1190. lediglich für Arrays wird deren Adresse übergeben
  1191. (call by reference), anstatt deren Wert.
  1192.  
  1193. In Modula-2 können Funktionen keine zusammengesetzten
  1194. Typen zurückgeben. Manche C-Compiler ermöglichen dies,
  1195. indem im Registerpaar DX:AX ein Zeiger auf diese Werte
  1196. zurückgegeben wird. Auf die gleiche Art und Weise verfährt
  1197. Fitted Modula-2 mit Zeigern!
  1198.  
  1199. Also könnte man wie folgt definieren:
  1200.  
  1201.  struct someStruct cfunct()
  1202.  
  1203. als
  1204.  
  1205.  TYPE
  1206.    someStructPtr ═ POINTER TO someStruct;
  1207.  
  1208.  PROCEDURE cfunct(): someStructPtr;
  1209.  
  1210.  Zurück zum {Index}
  1211.  
  1212. .topic Zeitstempel
  1213.  
  1214.   Zeitstempel in FST-Modula-2-M2O-Dateien ▄
  1215.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  1216.  
  1217. Der "Module-Header-Record" und die "Import-Records",
  1218. die der Compiler in die Objekt-Datei schreibt,
  1219. werden mit dem Datum der benutzten .DEF-Datei
  1220. markiert - dies ist der Modul-Schlüssel.
  1221. Der Linker stellt sicher, daß die Modul-Schlüssel
  1222. im Module-Header des importierten Moduls und im
  1223. Import-Record übereinstimmen.
  1224. Ist dies nicht der Fall, dann wurde beim Compilieren
  1225. nicht das gleiche Definitions-Modul benutzt.
  1226. Wegen des Gebrauchs dieser Modul-Schlüssel ist
  1227. es zwingend erforderlich, daß das jeweilige
  1228. Datum der .DEF-Dateien nicht verändert wird,
  1229. außer wenn beabsichtigen ist, die Implementierungen
  1230. neu zu compilieren.
  1231.  
  1232.  Wichtig:
  1233.  ────────
  1234.  
  1235. Wenn OBJ-Dateien benutzt werden, besteht dieser
  1236. Schutz durch die Modul-Schlüssel nicht.
  1237.  
  1238. Zurück zum {Index}
  1239.  
  1240. .topic Environment
  1241.  
  1242.   Environment-Variablen ▄
  1243.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  1244.  
  1245. Die grundlegenden Bedingungen des Fitted-Modula-Compilers
  1246. können über Environment-Variablen gesteuert werden:
  1247.  
  1248.   Ausgabeformat der Objektdateien:
  1249.     M2OUTPUT═<M2O|OBJ>
  1250.   Pfad zu den Bibliotheken/Objektdateien:
  1251.     M2LIB═pfad
  1252.   Speichermodell:
  1253.     M2MODEL═<LARGE|HUGE>
  1254.  
  1255. Es muß darauf geachtet werden, daß der
  1256. DOS-Umgebungsbereich ausreicht.
  1257. Falls die DOS-Meldung "Out of Environment Space"
  1258. bzw. "Nicht genug Platz im Umgebungsspeicher"
  1259. erscheint, muß die Größe des Environments  angepaßt werden.
  1260. Dies erfolgt mit dem  /E:-Parameter beim Shell-Aufruf
  1261. in der CONFIG.SYS:
  1262.  
  1263.  SHELL═<pfad>COMMAND.COM /E:<Größe in Bytes> /P
  1264.  
  1265.   M2MODEL:
  1266.  ─────────┘
  1267.  
  1268. Der Compiler erzeugt Code für die Intel 8086 Speichermodelle
  1269. "Huge" und "Large": Beim "Huge"-Speichermodell hat jedes
  1270. Modul sein eigenes Daten- und Codesegment, die jeweils bis
  1271. zu 64k groß sein dürfen; beim "Large"-Speichermodell sind
  1272. die statischen Daten aller Module in einem einzigen Segment
  1273. zusammengefaßt. Pointer sind in beiden Modellen vier Bytes lang.
  1274. Andere Speichermodelle werden zur Zeit nicht unterstützt.
  1275.  
  1276. Die Umgebungsvariable M2MODEL kann auf "HUGE" oder "LARGE"
  1277. gesetzt werden, so daß dem Compiler nicht jedesmal das
  1278. gewünschte Speichermodell mitgeteilt zu werden braucht
  1279. (außer man will sich über diese Voreinstellung hinwegsetzen).
  1280.  
  1281. Falls M2MODEL nicht definiert ist, nimmt der Compiler als
  1282. Standard und wegen der Kompatibilität mit früheren Versionen
  1283. die Einstellung "HUGE" an.
  1284.  
  1285. Die Einstellung des Speichermodells kann aus Sicherheitsgründen
  1286. nicht aus der IDE geändert werden.
  1287.  
  1288.   M2LIB:
  1289.  ───────┘
  1290.  
  1291. Sowohl der Compiler als auch der Linker benutzen die Umgebungsvariable
  1292. M2LIB um auf erforderliche Bibliotheks-Module zuzugreifen
  1293. (das Format für M2LIB entspricht dem für DOS PATH).
  1294.  
  1295.   M2OUTPUT:
  1296.  ──────────┘
  1297.  
  1298. Normalerweise werden M2O-Dateien ("Modula-2-Object") erzeugt.
  1299. Dieses Dateiformat gibt es nur bei diesem Compiler.
  1300. Es ist speziell für die Anforderungen von Modula-2 optimiert.
  1301. Der Benutzer kann jedoch mittels der Umgebungs-Variablen M2OUTPUT
  1302. festlegen, daß stattdessen Standard-OBJ-Dateien erzeugt werden.
  1303.  
  1304. Die IDE arbeitet nur mit M2O-Dateien korrekt zusammen, da der
  1305. Aufruf der beiden Linker M2LINK und LINK nicht kompatibel ist.
  1306. Falls als Ausgabeformat Intel-OBJ-Dateien verwendet werden sollen,
  1307. müssen die Programme auf der Kommandozeile gebunden werden.
  1308. Alle anderen Funktionen der IDE arbeiten auch mit OBJ-Dateien.
  1309.  
  1310. Zurück zum {Index}
  1311.  
  1312. .topic CompLimits
  1313.  
  1314.   Compiler-Begrenzungen: ▄
  1315.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  1316.  
  1317. Der Compiler erlegt Code und Daten die
  1318. folgenden Größenbegrenzungen auf:
  1319.  
  1320.  ■ Eine String-Konstante darf 80 Zeichen
  1321.    nicht überschreiten. Dies ist auch die
  1322.    Größengrenze für jeden Bezeichner.
  1323.  
  1324.  ■ Beim "HUGE"-Speichermodell erhält jedes
  1325.    Modul sein eigenes Datensegment, welches
  1326.    bis zu 64k groß sein kann. Im Datensegment
  1327.    organisiert der Compiler alle globalen
  1328.    Variablen des Moduls und einige seiner
  1329.    Konstanten.
  1330.  
  1331.  ■ Beim "LARGE"-Speichermodell werden die
  1332.    Daten aller Module beim Linken in ein
  1333.    einziges Datensegment (maximal 64 kBytes)
  1334.    gepackt.
  1335.  
  1336.  ■ Die maximale Größe einer Datenstruktur
  1337.    ist 65532 Bytes.
  1338.  
  1339.  ■ Die lokalen Variablen einer Prozedur dürfen
  1340.    höchstens 32000 Bytes Speicherplatz einnehmen.
  1341.  
  1342.  ■ Ein Parameter der durch "Call-by-value" einer
  1343.    Prozedur übergeben wird darf höchstens 65000
  1344.    Bytes groß sein.
  1345.  
  1346.  ■ Interne Grenzen des Compilers:
  1347.  
  1348.   ∙ Die maximale Anzahl namentlich
  1349.     verschiedener Variablen, die der
  1350.     Compiler bei einem Lauf bewältigen
  1351.     kann, ist 2000. Diese Zahl kann
  1352.     beim Aufruf des Compilers geändert
  1353.     werden.
  1354.  
  1355.   ∙ Die Gesamtzahl der Buchstaben in
  1356.     den Variablennamen darf 12000
  1357.     nicht überschreiten. Diese Zahl
  1358.     kann beim Aufruf des Compilers
  1359.     geändert werden.
  1360.  
  1361.   ∙ Eine einzige Prozedur kann nicht
  1362.     mehr als 10k Objektcode umfassen.
  1363.  
  1364.   ∙ Alle initialisierten Daten eines
  1365.     Moduls sind in einem 8k großen
  1366.     Feld organisiert. Dies bewirkt
  1367.     eine Begrenzung der Gesamtzahl an
  1368.     String-, Real- und Long-Konstanten
  1369.     eines Moduls.
  1370.  
  1371. Diese Ausgabe des Compilers übersetzt Programme,
  1372. die in der Sprache Modula-2 geschrieben sind,
  1373. wie sie von Niklaus Wirth in der 3. Auflage seines
  1374. Buches "Programming in Modula-2" definiert ist,
  1375. mit folgenden Ausnahmen:
  1376.  
  1377.  ■ Der arithmetische  Überlauf von {INTEGER}
  1378.    und {CARDINAL} bleibt unentdeckt.
  1379.  
  1380.  ■ {ASM} ist ein reservierter Bezeichner.
  1381.  
  1382.  ■ Für Programmierer, die in der "Hex-Welt"
  1383.    aufgewachsen sind, gibt es eine Möglichkeit,
  1384.    CHAR-Literale ("Literal" ═ direkt im
  1385.    Quelltext stehender Wert) hexadezimal zu
  1386.    definieren: 20X entspricht dem
  1387.    Leerzeichen ("space") in {ASCII}.
  1388.  
  1389. Fitted-Modula-2 Version 2.0 besitzt zwei Bugs,
  1390. die nicht tragisch sind, aber eine Abweichung zur
  1391. Modula-Standardsyntax hervorrufen:
  1392.  
  1393.  ■ Vor dem ersten Zweig einer {CASE}-
  1394.    Verzweigung darf kein Pipezeichen (|) stehen:
  1395.  
  1396.   CASE x OF
  1397.    | 1: ...;
  1398.    | 2: ...;
  1399.    ist nicht zulässig! Es muß heißen:
  1400.  
  1401.   CASE x OF
  1402.      1: ...;
  1403.    | 2: ...;
  1404.  
  1405.  ■ Auch leere Prozeduren müssen
  1406.    mit einem BEGIN anfangen:
  1407.  
  1408.   PROCEDURE p;
  1409.   BEGIN
  1410.   END p;
  1411.  
  1412.   Das in Modula-2 normalerweise erlaubte:
  1413.  
  1414.   PROCEDURE p;
  1415.   END p;
  1416.  
  1417.   ist nicht zulässig.
  1418.  
  1419. Die früheren Auflagen der Wirth'schen Sprachdefinition enthalten
  1420. zusätzlich Ausdrücke wie EXPORT oder EXPORT QUALIFIED. Diese
  1421. Bezeichener werden nicht unterstützt, in der Regel führen sie
  1422. aber nicht zu Fehlermeldungen sondern werden ignoriert.
  1423.  
  1424.  
  1425. Zurück zum {Index}
  1426.  
  1427. .topic Rename
  1428.  
  1429.   Rename ▄
  1430.  ▀▀▀▀▀▀▀▀▀
  1431.  
  1432. Mit Rename werden Dateien umbenannt oder vom einen zum
  1433. anderen Verzeichnispfad verschoben.
  1434.  
  1435. Rename ist mehrfach (mit unterschiedlichen Optionen und
  1436. Fähigkeiten) definiert:
  1437.  
  1438.  {Files.Rename      :Files_Rename}
  1439.  {FileSystem.Rename :FileSystem_Rename}
  1440.  {Directories.Rename:Directories_Rename}
  1441.  
  1442. Zurück zum {Index} oder zu {Routinen}
  1443.  
  1444. .topic Create
  1445.  
  1446.   Create ▄
  1447.  ▀▀▀▀▀▀▀▀▀
  1448.  
  1449. Legt eine neue Datei an:
  1450.  
  1451.  {Files.Create:Files_Create}
  1452.  {FileSystem.Create:FileSystem_Create}
  1453.  
  1454. Zurück zum {Index} oder zu {Routinen}
  1455.  
  1456. .topic WriteLine
  1457.  
  1458.   WriteLine ▄
  1459.  ▀▀▀▀▀▀▀▀▀▀▀▀
  1460.  
  1461.  {Terminal.WriteLine:Terminal_WriteLine}
  1462.  {InOut.WriteLine:InOut_WriteLine}
  1463.  
  1464. identisch mit:
  1465.  
  1466.  {WriteString}(string); {WriteLn};
  1467.  
  1468. Zurück zum {Index} oder zu {Routinen}
  1469.  
  1470. .topic SetFileTime
  1471.  
  1472.   SetFileTime ▄
  1473.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  1474.  
  1475. Setzen des Datum und der Uhrzeit einer Datei.
  1476.  
  1477.  {Files.SetFileTime      :Files_SetFileTime}
  1478.  {Directories.SetFileTime:Directories_SetFileTime}
  1479.  
  1480. Siehe auch: {GetFileTime}.
  1481.  
  1482. Zurück zum {Index} oder zu {Routinen}
  1483.  
  1484. .topic GetFileTime
  1485.  
  1486.   GetFileTime ▄
  1487.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  1488.  
  1489. Lesen von Erstellungsdatum und -uhrzeit einer Datei.
  1490.  
  1491.  {Files.GetFileTime:Files_GetFileTime}
  1492.  {Directories.GetFileTime:Directories_GetFileTime}
  1493.  
  1494. Siehe auch: {SetFileTime}.
  1495.  
  1496. Zurück zum {Index} oder zu {Routinen}
  1497.  
  1498. .topic WriteString
  1499.  
  1500.   WriteString ▄
  1501.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  1502.  
  1503.  Prozeduren:
  1504.  
  1505.   {InOut.WriteString   :InOut_WriteString}
  1506.   {Terminal.WriteString:Terminal_WriteString}
  1507.  
  1508. Zurück zum {Index} oder zu {Routinen}
  1509.  
  1510. .topic Write
  1511.  
  1512.   Write ▄
  1513.  ▀▀▀▀▀▀▀▀
  1514.  
  1515.  Konstanten:
  1516.   {Files.WRITE:WRITEc}
  1517.  
  1518.  Prozeduren:
  1519.   {Files.Write   :Files_Write}
  1520.   {Display.Write :Display_Write}
  1521.   {Terminal.Write:Terminal_Write}
  1522.   {TermIO.Write  :TermIO_Write}
  1523.   {InOut.Write   :InOut_Write}
  1524.   {TermBase.Write:TermBase_Write}
  1525.  
  1526.  siehe auch:
  1527.   {WriteChar}, {WriteWord} und {WriteNBytes};
  1528.  
  1529.  bei den verwandten Prozeduren:
  1530.   {WriteLn}, {WriteString} und {WriteLine}
  1531.  
  1532.  sowie der Komplementärprozedur {Read}
  1533.  
  1534. Zurück zum {Index} oder zu {Routinen}
  1535.  
  1536. .topic WriteChar
  1537.  
  1538.   WriteChar ▄
  1539.  ▀▀▀▀▀▀▀▀▀▀▀▀
  1540.  
  1541.  Schreibt ein Zeichen {CHAR}.
  1542.  
  1543.  {Display.WriteChar   :Display_WriteChar}
  1544.  {FileSystem.WriteChar:FileSystem_WriteChar}
  1545.  
  1546. Zurück zum {Index} oder zu {Routinen}, siehe auch {Write}.
  1547.  
  1548. .topic KeyPressed
  1549.  
  1550.    KeyPressed ▄
  1551.   ▀▀▀▀▀▀▀▀▀▀▀▀▀
  1552.  
  1553. Überprüfung, ob ein Zeichen im Tastaturpuffer liegt.
  1554.  
  1555.  {KeyBoard.KeyPressed:KeyBoard_KeyPressed}
  1556.  {TermBase.KeyPressed:TermBase_KeyPressed}
  1557.  {TermIO.KeyPressed  :TermIO_KeyPressed}
  1558.  {Terminal.KeyPressed:Terminal_KeyPressed}
  1559.   ────────────────────
  1560.   siehe auch: {GetKey}
  1561.  
  1562. Zurück zum {Index} oder zu {Routinen}
  1563.  
  1564. .topic Goto
  1565.  
  1566.   Goto ▄
  1567.  ▀▀▀▀▀▀▀
  1568.  
  1569. Die Prozedur positioniert den Cursor auf dem Textbildschirm.
  1570.  
  1571.  {Display.Goto :Display_Goto}
  1572.  {Terminal.Goto:Terminal_Goto}
  1573.  {TermBase.Goto:TermBase_Goto}
  1574.  {TermIO.Goto  :TermIO_Goto}
  1575.  
  1576. Goto it KEINE Sprunganweisung innerhalb des Programmes auf ein Label!
  1577. Dergleichen gibt es in Modula-2 nicht.
  1578.  
  1579. siehe auch Display.{SetCursorPosition}
  1580.  
  1581. Zurück zum {Index} oder zu {Routinen}
  1582.  
  1583. .topic Close
  1584.  
  1585.   Close ▄
  1586.  ▀▀▀▀▀▀▀▀
  1587.  
  1588. Die Prozedur schließt eine derzeit offene Datei.
  1589.  
  1590.  {Files.Close     :Files_Close}
  1591.  {FileSystem.Close:FileSystem_Close}
  1592.  
  1593. Zurück zum {Index} oder zu {Routinen}
  1594.  
  1595. .topic Read
  1596.  
  1597.   Read ▄
  1598.  ▀▀▀▀▀▀▀
  1599.  
  1600. Liest ein Zeichen (CHAR).
  1601.  
  1602.  Konstante:
  1603.  {Files.READ:READc}
  1604.  
  1605.  Prozeduren:
  1606.  {Files.Read :Files_Read}  {TermBase.Read:TermBase_Read}
  1607.  {InOut.Read :InOut_Read}  {Terminal.Read:Terminal_Read}
  1608.  {TermIO.Read:TermIO_Read}
  1609.  
  1610. Siehe auch bei den verwandten Prozeduren:
  1611.  
  1612. {ReadString}, {ReadLine}, {ReadInt}, {ReadCard}, {ReadWrd}, {ReadLongCard}, {ReadLongInt}, {ReadWord}, {ReadChar}
  1613.  
  1614. und der Komplementärprozedur: {Write}
  1615.  
  1616. Zurück zum {Index} oder zu {Routinen}
  1617.  
  1618. .topic Length
  1619.  
  1620.   Length ▄
  1621.  ▀▀▀▀▀▀▀▀▀
  1622.  
  1623. Die Prozedur gibt die Länge einer Datei bzw.
  1624. die Länge einer Zeichenkette zurück.
  1625.  
  1626.  {Strings.Length   :Strings_Length}
  1627.  {FileSystem.Length:FileSystem_Length}
  1628.  
  1629. Zurück zum {Index} oder zu {Routinen}
  1630.  
  1631. .topic WriteLn
  1632.  
  1633.   WriteLn ▄
  1634.  ▀▀▀▀▀▀▀▀▀▀
  1635.  
  1636. Die Prozedur führt einen Zeilenvorschub durch.
  1637.  
  1638.  {Terminal.WriteLn:Terminal_WriteLn}
  1639.  {InOut.WriteLn   :InOut_WriteLn}
  1640.  
  1641. Siehe auch {WriteLine}
  1642.  
  1643. Zurück zum {Index} oder zu {Routinen}
  1644.  
  1645. .topic ReadLine
  1646.  
  1647.   ReadLine ▄
  1648.  ▀▀▀▀▀▀▀▀▀▀▀
  1649.  
  1650.  {Terminal.ReadLine:Terminal_ReadLine}
  1651.  {InOut.ReadLine   :InOut_ReadLine}
  1652.  
  1653. Siehe auch: {Read}
  1654.  
  1655. Zurück zum {Index} oder zu {Routinen}
  1656.  
  1657. .topic Delete
  1658.  
  1659.   Delete ▄
  1660.  ▀▀▀▀▀▀▀▀▀
  1661.  
  1662.  {Files.Delete      :Files_Delete}
  1663.  {Strings.Delete    :Strings_Delete}
  1664.  {Directories.Delete:Directories_Delete}
  1665.  
  1666. Zurück zum {Index} oder zu {Routinen}
  1667.  
  1668. .topic mSYSTEM
  1669.  
  1670.   MODULE SYSTEM (Laufzeitbibliothek) ▄
  1671.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  1672.  
  1673. Das Pseudomodul SYSTEM ist nicht wie die anderen
  1674. Standardmodule extern definiert.
  1675. Allerdings stehen die Definitionen aus SYSTEM
  1676. auch nur dann zur Verfügung, wenn sie IMPORTed
  1677. werden, obwohl es kein Definitionsmodul gibt.
  1678.  
  1679. SYSTEM ist NICHT identisch mit der Standard-Unit "System".
  1680. Es handelt sich um die DOS-spezifische Laufzeitbibliothek.
  1681.  
  1682. In SYSTEM definierte reservierte Worte (Reserved words):
  1683.  
  1684.   {SEG}, {OFS}, {ASM}, {ASSEMBLER}
  1685.  
  1686. In SYSTEM deklarierte Typen:
  1687.  
  1688.   {ADDRESS}, {BYTE}, {WORD}
  1689.  
  1690. In SYSTEM deklarierte Prozeduren:
  1691.  
  1692.   {NEW}       {DISPOSE}
  1693.   {LONG}      {SHORT}
  1694.   {SEGMENT}   {OFFSET}
  1695.   {ADR}       {FLAT}
  1696.   {PTR}       {NEWPROCESS}
  1697.   {TRANSFER}  {IOTRANSFER}
  1698.   {TRUNC}     {FLOAT}
  1699.  
  1700. Zurück zum {Index} oder zu {Routinen}
  1701.  
  1702. .topic SEG, OFS
  1703.  
  1704.   SYSTEM.SEG / .OFS ▄
  1705.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  1706.  
  1707. SEG und OFS sind Komponenten des POINTER-Typs.
  1708. Wenn diese importiert werden, kann in normaler
  1709. Syntax auf den Segment- oder den Offset-Teil eines Zeigers
  1710. zugegriffen werden.
  1711.  
  1712. Beispiel:
  1713.  
  1714.  pointer.SEG: Segment-Teil des Zeigers "pointer".
  1715.  pointer.OFS: Offset-Teil des Zeigers "pointer".
  1716.  
  1717. Zurück zum Pseudomodul {SYSTEM:mSYSTEM}
  1718.  
  1719. .topic ASM
  1720.  
  1721.   SYSTEM.ASM ▄
  1722.  ▀▀▀▀▀▀▀▀▀▀▀▀▀
  1723.  
  1724. Das in Fitted-Modula-2 reservierte Wort "ASM"
  1725. leitet eine {Assembler}-Anweisung ein.
  1726. Jeder Bereich mit Inline-Assembler muß
  1727. mit ASM / END eingeschlossen sein.
  1728.  
  1729.  Beispiel:
  1730.   PROCEDURE AsmDemo;
  1731.   BEGIN
  1732.     ASM
  1733.       ....
  1734.     END;
  1735.   END AsmDemo;
  1736.  
  1737. Kommentare müssen Modula-üblich eingeklammert werden.
  1738. Alle Assembler-Bezeichner müssen in Großbuchstaben geschrieben sein.
  1739. Der {ASSEMBLER} muß zuvor aus dem Pseudomodul {SYSTEM} importiert werden.
  1740.  
  1741. Zurück zum Pseudomodul {SYSTEM:mSYSTEM}
  1742.  
  1743. .topic Assembler
  1744.  
  1745.   "ASSEMBLER"-Befehl: ▄
  1746.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  1747.  
  1748. Um den Inline-Assembler ({ASM}) verwenden zu können,
  1749. muß vorher der Assembler mit:
  1750.  
  1751.  FROM SYSTEM IMPORT ASSEMBLER;
  1752.  
  1753. importiert werden.
  1754.  
  1755. Zurück zum Pseudomodul {SYSTEM:mSYSTEM}
  1756.  
  1757. .topic ADDRESS
  1758.  
  1759.   TYPE SYSTEM.ADDRESS ▄
  1760.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  1761.  
  1762. Der Typ ADDRESS ist zu allen Zeiger-Typen kompatibel.
  1763. ADDRESS selbst ist als POINTER TO WORD definiert.
  1764.  
  1765. In dieser Implementierung ist der Typ ADDRESS mit keinem
  1766. arithmetischen Typ kompatibel.
  1767. Das liegt an der Tatsache, daß Prozessoren der Intel
  1768. 8086-Serie Adressen in Segment-Offset-Darstellung benutzen.
  1769. Es wäre nicht schwierig gewesen, eine automatische
  1770. Umwandlung zwischen {LONGCARD} und {ADDRESS} zu implementieren.
  1771. Wir glauben, daß es dem Geist der Sprache widersprochen hätte,
  1772. wenn der Compiler irgendwelche "magischen"  Tricks durchführen würde.
  1773. Stattdessen stehen zu diesem Zweck zwei Prozeduren zur
  1774. Verfügung: {FLAT} und {PTR}.
  1775.  
  1776. In der Version 1.2 haben wir diese Regel etwas gelockert:
  1777.  
  1778. ADDRESS + CARDINAL und ADDRESS - CARDINAL sind erlaubte Ausdrücke.
  1779.  
  1780. Der CARDINAL-Wert wird mit dem Offset-Teil der Adresse
  1781. verrechnet und das Ergebnis ist wieder eine Adresse.
  1782.  
  1783. Auch für {INC} und {DEC} ist ADDRESS als erstes Argument erlaubt.
  1784.  
  1785. Die Operation wird nur auf dem Offset-Teil der Adresse ausgeführt!
  1786.  
  1787. Zurück zum Pseudomodul {SYSTEM:mSYSTEM}
  1788.  
  1789. .topic BYTE
  1790.  
  1791.   TYPE SYSTEM.BYTE ▄
  1792.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  1793.  
  1794. 1 Byte Speicherbedarf.
  1795.  
  1796. Für diesen Typ ist nur die Zuweisung definiert.
  1797.  
  1798. Wenn der formale Parameter einer Prozedur vom
  1799. Typ BYTE ist, darf der entsprechende aktuelle
  1800. Parameter von einem beliebigen 1 Byte langen Typ sein.
  1801.  
  1802. Wenn der formale Parameter einer Prozedur vom
  1803. Typ ARRAY OF BYTE ist, dann darf der entsprechende
  1804. aktuelle Parameter von beliebigem kompatiblen Typ sein.
  1805.  
  1806. Zurück zum Pseudomodul {SYSTEM:mSYSTEM}
  1807.  
  1808. .topic WORD
  1809.  
  1810.   TYPE SYSTEM.WORD ▄
  1811.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  1812.  
  1813. 1 Wort (2 Bytes) Speicherbedarf.
  1814.  
  1815. Für diesen Typ ist nur die Zuweisung definiert.
  1816.  
  1817. Wenn der formale Parameter einer Prozedur vom Typ WORD
  1818. ist, dann darf der entsprechende aktuelle Parameter
  1819. von einem beliebigen 1 Wort langen Typ sein.
  1820.  
  1821. Wenn der formale Parameter einer Prozedur vom Typ
  1822. ARRAY OF WORD ist, dann darf der aktuelle Parameter
  1823. von beliebigem kompatiblen Typ sein.
  1824.  
  1825. Vorsicht: Die Größe des übergebenen Parameters wird
  1826. auf gerade Bytezahl aufgerundet!
  1827.  
  1828. Zurück zum Pseudomodul {SYSTEM:mSYSTEM}
  1829.  
  1830. .topic NEW, DISPOSE
  1831.  
  1832.   SYSTEM.NEW und SYSTEM.DISPOSE  ▄
  1833.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  1834.  
  1835. NEW und DISPOSE sind in der Sprach-Definition der 3.
  1836. Auflage von Wirths Buch nicht mehr enthalten.
  1837.  
  1838. Wir haben sie auf folgende Art und Weise implementiert:
  1839.  
  1840.  NEW(p)
  1841.  
  1842. ruft die Prozedur Storage.{ALLOCATE} auf, die dem Typ entsprechen muß:
  1843.  
  1844.  PROCEDURE (VAR ADDRESS, CARDINAL)
  1845.  
  1846. mit der Übergabe des Zeigers p und der Größe des Objekts auf p.
  1847.  
  1848.  DISPOSE(p)
  1849.  
  1850. ruft die Prozedur Storage.{DEALLOCATE} auf, die dem Typ entsprechen muß:
  1851.  
  1852.  PROCEDURE (VAR ADDRESS, CARDINAL)
  1853.  
  1854. mit der Übergabe des Zeigers p und der Größe des Objekts auf p.
  1855.  
  1856. Die Prozeduren {ALLOCATE} und {DISPOSE} müssen also
  1857. in einem Modul welches NEW und/oder DISPOSE benutzt,
  1858. definiert werden, oder von einem anderen Modul (z.B. {Storage})
  1859. importiert werden.
  1860.  
  1861.  
  1862. Zurück zum Pseudomodul {SYSTEM:mSYSTEM}
  1863.  
  1864. .topic LONG
  1865.  
  1866.   SYSTEM.LONG  ▄
  1867.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  1868.  
  1869.  PROCEDURE LONG(INTEGER):  LONGINT;
  1870.  PROCEDURE LONG(CARDINAL): LONGCARD;
  1871.  PROCEDURE LONG(REAL):     LONGREAL;
  1872.  
  1873. LONG wandelt von INTEGER, CARDINAL oder REAL
  1874. nach LONGINT, LONGCARD oder LONGREAL,um.
  1875.  
  1876. Siehe auch: {SHORT}.
  1877.  
  1878. Zurück zum Pseudomodul {SYSTEM:mSYSTEM}
  1879.  
  1880. .topic SHORT
  1881.  
  1882.   SYSTEM.SHORT ▄
  1883.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  1884.  
  1885.  PROCEDURE SHORT(LONGINT):  INTEGER;
  1886.  PROCEDURE SHORT(LONGCARD): CARDINAL;
  1887.  PROCEDURE SHORT(LONGREAL): REAL;
  1888.  
  1889. SHORT wandelt von LONGINT, LONGCARD oder
  1890. LONGREAL nach INTEGER, CARDINAL oder REAL um.
  1891.  
  1892. Siehe auch: {LONG}.
  1893.  
  1894. Zurück zum Pseudomodul {SYSTEM:mSYSTEM}
  1895.  
  1896. .topic ADR
  1897.  
  1898.   SYSTEM.ADR ▄
  1899.  ▀▀▀▀▀▀▀▀▀▀▀▀▀
  1900.  
  1901.  PROCEDURE ADR(VAR adr: ADDRESS);
  1902.  
  1903. ADR(Bezeichner) gibt die Adresse des Objekts "Bezeichner" aus (Typ {ADDRESS}).
  1904.  
  1905. Zurück zum Pseudomodul {SYSTEM:mSYSTEM}
  1906.  
  1907. .topic FLAT
  1908.  
  1909.   SYSTEM.FLAT ▄
  1910.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  1911.  
  1912.  PROCEDURE FLAT(VAR adr: LONGCARD);
  1913.  
  1914. FLAT({ADDRESS}) gibt eine unsegmentierte Adresse aus (LONGCARD).
  1915.  
  1916. Zurück zum Pseudomodul {SYSTEM:mSYSTEM}
  1917.  
  1918. .topic PTR
  1919.  
  1920.   SYSTEM.PTR ▄
  1921.  ▀▀▀▀▀▀▀▀▀▀▀▀▀
  1922.  
  1923.  PROCEDURE PTR(adr: LONGCARD);
  1924.  
  1925. PTR gibt die der unsegmentierten Adresse (LONGCARD)
  1926. entsprechende Adresse in Segment-Offset-Darstellung
  1927. ({ADDRESS}) aus.
  1928.  
  1929. Zurück zum Pseudomodul {SYSTEM:mSYSTEM}
  1930.  
  1931. .topic NEWPROCESS
  1932.  
  1933.   SYSTEM.NEWPROCESS ▄
  1934.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  1935.  
  1936.  PROCEDURE NEWPROCESS(p: PROC;
  1937.                       a: ADDRESS;
  1938.                       n: CARDINAL;
  1939.                  VAR p1: ADDRESS);
  1940.  
  1941. 2NEWPROCESS erzeugt einen neuen Prozeß,
  1942. dessen Startpunkt p ist und dessen n Bytes
  1943. großer Arbeitsspeicher bei a beginnt.
  1944. p1 ist der neue Prozeß-Zeiger.
  1945. Dieser Prozeß ist nicht aktiviert bis ein
  1946. SYSTEM.{TRANSFER} zu p1 vorgenommen wird.
  1947.  
  1948. Die Start-Priorität des neuen Prozesses ist
  1949. die aktuelle Priorität beim Aufruf von NEWPROCESS.
  1950.  
  1951. Zurück zum Pseudomodul {SYSTEM:mSYSTEM}
  1952.  
  1953. .topic TRANSFER
  1954.  
  1955.    SYSTEM.TRANSFER ▄
  1956.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  1957.  
  1958.  PROCEDURE TRANSFER(VAR p1, p2: ADDRESS);
  1959.  
  1960. TRANSFER setzt den laufenden Prozeß außer Kraft,
  1961. weist ihn p1 zu und nimmt p2 auf.
  1962. Der Wert vom laufenden Prozeß wird p1 erst zugewiesen,
  1963. nachdem p2 identifiziert wurde;
  1964. daher kann für p1 und p2 die gleiche Variable verwendet werden.
  1965.  
  1966. Der Prozeß wird mit der gleichen Priorität wieder
  1967. aufgenommen, die er beim Suspendieren hatte.
  1968.  
  1969. Zurück zum Pseudomodul {SYSTEM:mSYSTEM}
  1970.  
  1971. .topic IOTRANSFER
  1972.  
  1973.   SYSTEM.IOTRANSFER ▄
  1974.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  1975.  
  1976.  PROCEDURE IOTRANSFER(VAR p1,
  1977.                           p2: ADDRESS;
  1978.                    intVector: CARDINAL);
  1979.  
  1980. IOTRANSFER nimmt einen TRANSFER von p1 zu p2 vor.
  1981. Ebenso wie es SYSTEM.{TRANSFER} tut,
  1982. nachdem der laufende Prozeß zur Reaktivierung
  1983. vorbereitet wurde, die geschieht wenn über den
  1984. Interrupt-Vektor "intVector" ein Interrupt ausgelöst wird.
  1985. Wenn der Interrupt durchgeführt wird, wird der
  1986. Interrupt-Vektor mit seinem vorherigen Wert geladen
  1987. und ein TRANSFER zum I/O-Prozeß (derjenige welcher den
  1988. IOTRANSFER ausführte) wird durchgeführt.
  1989. Anschließend besitzt p2 den Wert des Prozesses, der lief,
  1990. als der Interrupt auftrat.
  1991.  
  1992. Zurück zum Pseudomodul {SYSTEM:mSYSTEM}
  1993.  
  1994. .topic TRUNC
  1995.  
  1996.   SYSTEM.TRUNC ▄
  1997.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  1998.  
  1999.  PROCEDURE TRUNC(REAL):     CARDINAL;
  2000.  PROCEDURE TRUNC(LONGREAL): LONGCARD;
  2001.  
  2002. Die TRUNC- und {FLOAT}-Prozeduren dienen zur
  2003. Umwandlung zwischen den zwei Integer/Cardinal-Typen
  2004. und Real-Typen.
  2005.  
  2006. Zurück zum Pseudomodul {SYSTEM:mSYSTEM}
  2007.  
  2008. .topic FLOAT
  2009.  
  2010.   SYSTEM.FLOAT ▄
  2011.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2012.  
  2013.  PROCEDURE FLOAT(CARDINAL): REAL;
  2014.  PROCEDURE FLOAT(LONGCARD): LONGREAL;
  2015.  
  2016. Die {TRUNC}- und FLOAT-Prozeduren dienen zur
  2017. Umwandlung zwischen den zwei Integer/Cardinal-Typen und Real-Typen.
  2018.  
  2019. Zurück zum Pseudomodul {SYSTEM:mSYSTEM}
  2020.  
  2021. .topic SEGMENT
  2022.  
  2023.   SYSTEM.SEGMENT ▄
  2024.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2025.  
  2026.  PROCEDURE SEGMENT(adr: ADDRESS):
  2027.                         CARDINAL;
  2028.  
  2029. SEGMENT(Bezeichner) gibt den Segmentteil der
  2030. Adresse des Objekts "Bezeichner"aus.
  2031.  
  2032. Beispiel:
  2033.  
  2034.  DX :═ SEGMENT(buffer);
  2035.  
  2036. weist DX den Segment-Wert von ADR(buffer) zu.
  2037.  
  2038. Zurück zum Pseudomodul {SYSTEM:mSYSTEM}
  2039.  
  2040. .topic OFFSET
  2041.  
  2042.   SYSTEM.OFFSET ▄
  2043.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2044.  
  2045.  PROCEDURE OFFSET(adr: ADDRESS):
  2046.                        CARDINAL;
  2047.  
  2048. OFFSET(Bezeichner) gibt den Offsetteil der
  2049. Adresse des Objekts "Bezeichner" aus.
  2050.  
  2051. Zurück zum Pseudomodul {SYSTEM:mSYSTEM}
  2052.  
  2053. .topic DOSSystem
  2054.  
  2055.   MODULE System ▄
  2056.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2057.  
  2058. Dieses Modul enthält systemspezifische Definitionen.
  2059. Diese Version ist für MS/PC-DOS ab Version 2.0.
  2060.  
  2061.   Definierte Typen:
  2062.  ───────────────────┘
  2063.  TYPE
  2064.    {ErrorProc} ═ PROCEDURE(CARDINAL,
  2065.                          ADDRESS);
  2066.  
  2067.    MemoryModel ═ (tiny,
  2068.                   small,
  2069.                   compact,
  2070.                   medium,
  2071.                   large,
  2072.                   huge);
  2073.  
  2074. Unterstützt werden z. Zt. nur "large" und "huge".
  2075.  
  2076.  In "System" definierte Variablen:
  2077.  ─────────────────────────────────
  2078.  
  2079.  VAR
  2080.   MemModel:    MemoryModel;
  2081.   {DOSVersion}:  CARDINAL;
  2082.   {PSP}:         CARDINAL;
  2083.   {MemTop}:      CARDINAL;
  2084.   {HeapBase}:    CARDINAL;
  2085.   {StackSeg}:    CARDINAL;
  2086.   {StackSize}:   CARDINAL;
  2087.   {HeapTop}:     CARDINAL;
  2088.   Has8087:     BOOLEAN;
  2089.   {AX}, {BX}, {CX},
  2090.   {DX}, {SI}, {DI}:  CARDINAL;
  2091.   {BP}, {DS}, {ES}:  CARDINAL;
  2092.   {FLAGS}:       BITSET;
  2093.  
  2094.  Definierte Konstanten:
  2095.  ──────────────────────
  2096.  
  2097.  CONST
  2098.   {carryFlag} ═ 0; {zeroFlag} ═ 6;
  2099.  
  2100.  
  2101.  Definierte Prozeduren:
  2102.  ──────────────────────
  2103.   {GetArg}        {GetEnv}
  2104.   {Trap}          {XTrap}
  2105.   {Move}          {TermProcedure}
  2106.   {Terminate}     {GetVector}
  2107.   {SetVector}     {ResetVector}
  2108.   {InstallRTErrorHandler}
  2109.   {UninstallRTErrorHandler}
  2110.  
  2111.  
  2112. Zurück zum {Index} oder zu {Routinen}, Ende mit ESC
  2113.  
  2114. .topic DOSVersion
  2115.  
  2116.   VAR System.DOSVersion: CARDINAL ▄
  2117.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2118.  
  2119. Die beim Start der Laufzeitbibliothek belegte Variable
  2120. liefert die verwendete DOS-Version * 100 zurück:
  2121.  
  2122.  z.B.:
  2123.   für DOS 2.10: 210
  2124.   für DOS 3.30: 330
  2125.   für DOS 5.00: 500
  2126.  
  2127. Zurück zum Modul {System:DOSSystem}
  2128.  
  2129. .topic PSP
  2130.  
  2131.   VAR System.PSP: CARDINAL ▄
  2132.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2133.  
  2134. Gibt das PSP (Programm-Segment-Prefix) in Paragraphen zurück.
  2135.  
  2136. Zurück zum Modul {System:DOSSystem}
  2137.  
  2138. .topic MemTop
  2139.  
  2140.   VAR System.MemTop: CARDINAL ▄
  2141.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2142.  
  2143. Gibt das Ende des Speichers (MemTop) in Paragraphen zurück.
  2144.  
  2145. Zurück zum Modul {System:DOSSystem}
  2146.  
  2147. .topic HeapBase
  2148.  
  2149.   VAR System.HeapBase: CARDINAL ▄
  2150.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2151.  
  2152. Gibt den Beginn des Heap in Paragraphen zurück.
  2153.  
  2154. Zurück zum Modul {System:DOSSystem}
  2155.  
  2156. .topic StackSeg
  2157.  
  2158.   VAR System.StackSeg: CARDINAL ▄
  2159.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2160.  
  2161. Gibt die Adresse des Stack-Segments in Paragraphen zurück.
  2162.  
  2163. Zurück zum Modul {System:DOSSystem}
  2164.  
  2165. .topic StackSize
  2166.  
  2167.   VAR System.StackSize: CARDINAL ▄
  2168.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2169.  
  2170. Liefert die Größe des Stacksegments (vorbelegter Stack-Pointer
  2171. (SP-Register)) zurück.
  2172.  
  2173. Zurück zum Modul {System:DOSSystem}
  2174.  
  2175. .topic HeapTop
  2176.  
  2177.   VAR System.HeapTop: CARDINAL ▄
  2178.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2179.  
  2180. Liefert das Ende des Heaps in Paragraphen.
  2181. Das Modul Storage kann diesen Wert anpassen.
  2182.  
  2183. Zurück zum Modul {System:DOSSystem}
  2184.  
  2185. .topic AX, BX, CX, DX, SI, DI, BP, DS, ES, FLAGS
  2186.  
  2187.   CPU-Register: ▄
  2188.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2189.  
  2190. Registervariablen aus dem Modul System:
  2191.  
  2192.  AX, BX, CX, DX, SI, DI: CARDINAL;
  2193.  BP, DS, ES            : CARDINAL;
  2194.  FLAGS                 : BITSET;
  2195.  
  2196. Zurück zum Modul {System:DOSSystem}
  2197.  
  2198. .topic carryFlag, zeroFlag
  2199.  
  2200.   System.carryFlag / .zeroFlag
  2201.  ──────────────────────────────┘
  2202.  
  2203.  CPU-Flags.
  2204.  
  2205. Zurück zum Modul {System:DOSSystem}
  2206.  
  2207. .topic ErrorProc
  2208.  
  2209.   System.ErrorProc ▄
  2210.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2211.  
  2212.  TYPE
  2213.   ErrorProc ═ PROCEDURE(CARDINAL,
  2214.                         ADDRESS);
  2215.  
  2216. Setzt einen Zeiger auf eine benutzerdefinierte
  2217. Fehlerbehandlungsroutine.
  2218. Im Fall eines Laufzeitfehlers werden die Fehlernummer
  2219. und die Fehleradresse geliefert.
  2220.  
  2221.  siehe auch:
  2222.   {Standard-Fehlerroutinen:Laufzeitfehler}
  2223.  
  2224. Die Fehleradresse kann mit der Adresse in der durch
  2225. DBG2MAP erzeugten .MAP-Datei wie folgt verknüpft werden:
  2226.  
  2227.   a.SEG :═ a.SEG - (PSP + 10H);
  2228.  
  2229. Nach der Rückkehr aus der benutzerdefinierten
  2230. Fehlerroutine wird zur Standard-Fehlerroutine
  2231. verzweigt und hiermit das Programm abgebrochen.
  2232.  
  2233. Zurück zum Modul {System:DOSSystem}
  2234.  
  2235. .topic GetArg
  2236.  
  2237.   System.GetArg  ▄
  2238.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2239.  
  2240.  PROCEDURE GetArg(VAR arg: ARRAY OF CHAR;
  2241.                VAR length: CARDINAL );
  2242.  
  2243. Liefert das nächste Argument in der Kommandozeile.
  2244.  
  2245. 1. Leerzeichen trennen Argumente.
  2246.  
  2247. 2. "/" leitet ein neues Argument ein (Option).
  2248.  
  2249. 3. Um die obigen Voreinstellung zu überschreiben,
  2250. kann ein Modula-2-String angegeben werden.
  2251.  
  2252.  Beispiel:
  2253.   COMMAND arg1 "arg 2" /option "command's last arg"
  2254.  
  2255. Zurück zum Modul {System:DOSSystem}
  2256.  
  2257. .topic GetEnv
  2258.  
  2259.   System.GetEnv ▄
  2260.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2261.  
  2262.  PROCEDURE GetEnv(var: ARRAY OF CHAR;
  2263.               VAR val: ARRAY OF CHAR);
  2264.  
  2265. Lädt "val" mit dem Wert der Environmentvariable "var". 
  2266. Wenn "var" nicht gefunden wird, wird ein Null-String
  2267. in "val" zurückgeliefert.
  2268.  
  2269. Zurück zum Modul {System:DOSSystem}
  2270.  
  2271. .topic Trap
  2272.   System.Trap ▄
  2273.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2274.  
  2275.  PROCEDURE Trap(intno: CARDINAL);
  2276.  
  2277. Lädt die CPU-Register mit den Inhalten
  2278. von {AX}..{DI} und führt dann den angegebenen
  2279. Softwareinterrupt "intno" aus.
  2280. Bei der Rückkehr vom Interrupt werden die Register
  2281. in AX..DI und die Prozessorflags in {FLAGS} gesichert.
  2282.  
  2283. siehe auch {XTrap}
  2284.  
  2285. Zurück zum Modul {System:DOSSystem}
  2286.  
  2287. .topic XTrap
  2288.  
  2289.   System.XTrap ▄
  2290.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2291.  
  2292.  PROCEDURE XTrap(intno: CARDINAL);
  2293.  
  2294. Lädt die CPU-Register mit den Inhalten von {AX}..{ES}
  2295. und führt dann den angegebenen Softwareinterrupt "intno" aus.
  2296.  
  2297. Bei der Rückkehr vom Interrupt werden die Register
  2298. in AX..ES und die Prozessorflags in {FLAGS} gesichert.
  2299.  
  2300. siehe auch {Trap}
  2301.  
  2302. Zurück zum Modul {System:DOSSystem}
  2303.  
  2304. .topic Move
  2305.  
  2306.   System.Move ▄
  2307.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2308.  
  2309.  PROCEDURE Move(src: ADDRESS;
  2310.                dest: ADDRESS;
  2311.                size: CARDINAL );
  2312.  
  2313. Bewegt "size" Bytes von "src" nach "dest". 
  2314. Der Pseudocode hierfür sieht folgendermaßen aus:
  2315.  
  2316.  IF FLAT(src) > FLAT(dest) THEN
  2317.    (bewege von der niedrigen zur hohen Adresse)
  2318.  ELSE
  2319.    (bewege von der hohen zur niedrigen Adresse)
  2320.  END
  2321.  
  2322. Zurück zum Modul {System:DOSSystem}
  2323.  
  2324. .topic TermProcedure
  2325.  
  2326.   System.TermProcedure ▄
  2327.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2328.  
  2329.  PROCEDURE TermProcedure(p :PROC);
  2330.  
  2331. Installiert eine Prozedur, die ausgeführt wird,
  2332. wenn das Programm beendet wird.
  2333. Es können bis zu 20 Ende-Prozeduren installiert werden.
  2334.  
  2335. Zurück zum Modul {System:DOSSystem}
  2336.  
  2337. .topic Terminate
  2338.  
  2339.   System.Terminate ▄
  2340.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2341.  
  2342.  PROCEDURE Terminate(exitStatus: CARDINAL);
  2343.  
  2344. Die Prozedur unterbricht die Programmausführung und
  2345. setzt das DOS-Errorlevel auf "exitStatus".
  2346.  
  2347. Zurück zum Modul {System:DOSSystem}
  2348.  
  2349. .topic GetVector
  2350.  
  2351.   System.GetVector ▄
  2352.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2353.  
  2354.  PROCEDURE GetVector(IntNum: CARDINAL;
  2355.                     VAR ISR: ADDRESS);
  2356.  
  2357. Die Prozedur lädt den Wert des Interruptvectors "IntNum"
  2358. aus dem BIOS-Interruptbereich in die Variable "ISR".
  2359.  
  2360. Siehe auch {SetVector}.
  2361.  
  2362. Zurück zum Modul {System:DOSSystem}
  2363.  
  2364. .topic SetVector
  2365.  
  2366.   System.SetVector ▄
  2367.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2368.  
  2369.  PROCEDURE SetVector(IntNum: CARDINAL;
  2370.                         ISR: PROC);
  2371.  
  2372. Installiert eine Interrupt-Subroutine (ISR),
  2373. die dann aufgerufen wird, wenn der Interrupt
  2374. "IntNum" ausgeführt werden soll.
  2375. Die in der Interrupt-Vektor geladene Adresse
  2376. ist die Startadresse der ISR-Prozedur,
  2377. bei der der vom Compiler generierte
  2378. Prozedur-Eintrittscode ausgelassen wird.
  2379. Die Interrupt-Subroutine muß mit abgeschalteter
  2380. Stacküberprüfung (*{$S-:Switches_sS}*) compiliert werden,
  2381. da der Compiler bei eingeschalteter
  2382. Stack-Überprüfung Assembleranweisungen erzeugt,
  2383. die den Stackpointer manipulieren.
  2384.  
  2385. Siehe auch {GetVector}.
  2386.  
  2387. Zurück zum Modul {System:DOSSystem}
  2388.  
  2389. .topic ResetVector
  2390.  
  2391.   System.ResetVector ▄
  2392.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2393.  
  2394.  PROCEDURE ResetVector(IntNum: CARDINAL;
  2395.                           ISR: ADDRESS);
  2396.  
  2397. Lädt den Wert des Interruptvektor
  2398. "IntNum" in die Interrupt-Subroutine (ISR).
  2399.  
  2400. Zurück zum Modul {System:DOSSystem}
  2401.  
  2402. .topic InstallRTErrorHandler
  2403.  
  2404.   System.InstallRTErrorHandler ▄
  2405.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2406.  
  2407.  PROCEDURE InstallRTErrorHandler(errorProc:
  2408.                                  ErrorProc);
  2409.  
  2410. Installiert die Fehlerbehandlungsroutine, die dann
  2411. aufgerufen wird, wenn ein Laufzeitfehler auftritt.
  2412. Es können bis zu zehn Fehlerbehandlungsroutinen
  2413. installiert werden. 
  2414. Es wird jedoch nur die zuletzt installierte im
  2415. Falle eines Laufzeitfehlers ausgeführt.
  2416.  
  2417. Zurück zum Modul {System:DOSSystem}
  2418.  
  2419. .topic UninstallRTErrorHandler
  2420.  
  2421.   System.UnInstallRTErrorHandler ▄
  2422.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2423.  
  2424.  PROCEDURE UninstallRTErrorHandler;
  2425.  
  2426. Deinstalliert die zuletzt mit {InstallRTErrorHandler}
  2427. installierte Fehlerprozedur "errorProc".
  2428.  
  2429. Zurück zum Modul {System:DOSSystem}
  2430.  
  2431. .topic ErrorMessage
  2432.  
  2433.   System.ErrorMessage ▄
  2434.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2435.  
  2436.  PROCEDURE ErrorMessage(msg: ARRAY OF CHAR);
  2437.  
  2438. Schreibt die Meldung msg an die Standard-Fehlerausgabe {StdErr}.
  2439.  
  2440. Zurück zum Modul {System:DOSSystem}
  2441.  
  2442. .topic ErrorLn
  2443.  
  2444.   System.ErrorErrorLn ▄
  2445.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2446.  
  2447.  PROCEDURE ErrorLn;
  2448.  
  2449. Schreibt eine neue Zeile an die Standard-Fehlerausgabe {StdErr}.
  2450.  
  2451. Zurück zum Modul {System:DOSSystem}
  2452.  
  2453. .topic ASCII
  2454.  
  2455.   MODULE ASCII ▄
  2456.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2457.  
  2458. Die Werte für ASCII-Zeichen müssen in Modula oktal angegeben werden.
  2459. Alle Zeichen unter 32 sowie das Zeichen 127 (Backspace)
  2460. sind, da sie normalerweise nicht direkt geschrieben
  2461. werden können, im Modul ASCII vordefiniert:
  2462.  
  2463. Standard ASCII-Steuerzeichen:
  2464.  
  2465.  ┌────┬────────────╥────┬────────────┐
  2466.  │ nul│NUL  ═  00C ║ soh│SOH  ═  01C │
  2467.  │ stx│STX  ═  02C ║ etx│ETX  ═  03C │
  2468.  │ eot│EOT  ═  04C ║ enq│ENQ  ═  05C │
  2469.  │ ack│ACK  ═  06C ║ bel│BEL  ═  07C │
  2470.  │ bs │ BS  ═  10C ║ ht │ HT  ═  11C │
  2471.  │ lf │ LF  ═  12C ║ vt │ VT  ═  13C │
  2472.  │ ff │ FF  ═  14C ║ cr │ CR  ═  15C │
  2473.  │ so │ SO  ═  16C ║ si │ SI  ═  17C │
  2474.  │ dle│DLE  ═  20C ║ dc1│DC1  ═  21C │
  2475.  │ dc2│DC2  ═  22C ║ dc3│DC3  ═  23C │
  2476.  │ dc4│DC4  ═  24C ║ nak│NAK  ═  25C │
  2477.  │ syn│SYN  ═  26C ║ etb│ETB  ═  27C │
  2478.  │ can│CAN  ═  30C ║ em │ EM  ═  31C │
  2479.  │ sub│SUB  ═  32C ║ esc│ESC  ═  33C │
  2480.  │ fs │ FS  ═  34C ║ gs │ GS  ═  35C │
  2481.  │ rs │ RS  ═  36C ║ us │ US  ═  37C │
  2482.  ├────┼────────────╫────┴────────────┤
  2483.  │ del│DEL  ═ 177C ║                 │
  2484.  └────┴────────────╨─────────────────┘
  2485.  
  2486. Was die Steuerzeichenkombinationen erzeugen:
  2487.  
  2488.  ┌─────────────╥─────────────╥─────────────┐
  2489.  │ CtrlA ═ 01C ║ CtrlB ═ 02C ║ CtrlC ═ 03C │
  2490.  │ CtrlD ═ 04C ║ CtrlE ═ 05C ║ CtrlF ═ 06C │
  2491.  │ CtrlG ═ 07C ║ CtrlH ═ 10C ║ CtrlI ═ 11C │
  2492.  │ CtrlJ ═ 12C ║ CtrlK ═ 13C ║ CtrlL ═ 14C │
  2493.  │ CtrlM ═ 15C ║ CtrlN ═ 16C ║ CtrlO ═ 17C │
  2494.  │ CtrlP ═ 20C ║ CtrlQ ═ 21C ║ CtrlR ═ 22C │
  2495.  │ CtrlS ═ 23C ║ CtrlT ═ 24C ║ CtrlU ═ 25C │
  2496.  │ CtrlV ═ 26C ║ CtrlW ═ 27C ║ CtrlX ═ 30C │
  2497.  │ CtrlY ═ 31C ║ CtrlZ ═ 32C ║             │
  2498.  └─────────────╨─────────────╨─────────────┘
  2499.  
  2500. Modula-2 Zeilenende-Zeichen:
  2501.  
  2502.   EOL ═ 36C;
  2503.  
  2504. Modula-2 Textdatei-Endezeichen:
  2505.  
  2506.   EOF ═ CtrlZ;
  2507.  
  2508. Zurück zum {Index}, Ende mit ESC
  2509.  
  2510. .topic InOut
  2511.  
  2512.   MODULE InOut ▄
  2513.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2514.  
  2515. Dies ist das Standardmodul InOut, wie es in dem
  2516. Buch "Programming in Modula-2" von Niklaus
  2517. Wirth definiert wurde.
  2518. Einige Erweiterungen wurden eingebaut, hauptsächlich
  2519. zur Unterstützung der Datentypen {LONGINT} und {LONGCARD}.
  2520.  
  2521.  CONST
  2522.    {EOL}   ═ 36C;
  2523.  
  2524.  VAR
  2525.    {Done}  : BOOLEAN;
  2526.    {termCH}: CHAR;
  2527.  
  2528.   ─────────────────────────────────────
  2529.  
  2530.   definierte Prozeduren:
  2531.  
  2532.    {OpenInput}        {OpenOutPut}
  2533.    {RedirectInput}    {RedirectOutput}
  2534.    {CloseInput}       {CloseOutput}
  2535.    {ReadString}       {Read:InOut_Read}
  2536.    {ReadInt}          {ReadLine:InOut_ReadLine}
  2537.    {ReadWrd}          {Write:InOut_Write}
  2538.    {ReadCard}         {WriteLn:InOut_WriteLn}
  2539.    {WriteInt}         {WriteLine:InOut_WriteLine}
  2540.    {WriteCard}        {WriteString:InOut_WriteString}
  2541.    {WriteOct}         {WriteHex}
  2542.    {WriteWrd}         {ReadLongInt}
  2543.    {ReadLongCard}     {WriteLongInt}
  2544.    {WriteLongCard}
  2545.  
  2546. Zurück zum {Index}, Ende mit ESC
  2547.  
  2548. .topic EOL
  2549.  
  2550.   InOut.EOL
  2551.  ───────────┘
  2552.   CONST
  2553.     EOL ═ 36C;
  2554.  
  2555. Zeilenende-Kennung
  2556.  
  2557. Zurück zum Modul {InOut}
  2558.  
  2559. .topic Done
  2560.  
  2561.   InOut.Done
  2562.  ────────────┘
  2563.  
  2564.  VAR
  2565.    Done  : BOOLEAN;
  2566.  
  2567. "Done" wird von den Prozeduren {OpenInput}, {OpenOutput},
  2568. {RedirectInput}, {RedirectOutput}, {Read:InOut_Read},
  2569. {ReadInt}, {ReadCard}, {ReadLongInt}, {ReadLongCard},
  2570. {ReadWrd} und {WriteWrd} gesetzt, um anzeigen,
  2571. ob der Aufruf der Prozedur erfolgreich war.
  2572.  
  2573. Zurück zum Modul {InOut}
  2574.  
  2575. .topic termCH
  2576.  
  2577.   InOut.termCH
  2578.  ──────────────┘
  2579.  
  2580.   VAR
  2581.     termCH: CHAR;
  2582.  
  2583. In dieser (globalen) Variable wird das letzte gelesene
  2584. Zeichen der Leseprozeduren (ReadXXXX) des Moduls InOut gespeichert.
  2585.  
  2586. Zurück zum Modul {InOut}
  2587.  
  2588. .topic OpenInput
  2589.  
  2590.   InOut.OpenInput ▄
  2591.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2592.  
  2593.  PROCEDURE OpenInput(defext: ARRAY OF CHAR);
  2594.  
  2595. Fragt den Benutzer nach einer Datei für die Eingabeumleitung.
  2596. Wenn das letzte Zeichen der Eingabe ein Punkt ist,
  2597. wird "defext" (default Extension) an den Dateinamen angehängt.
  2598.  
  2599. Zurück zum Modul {InOut}
  2600.  
  2601. .topic OpenOutPut
  2602.  
  2603.   InOut.OpenOutput ▄
  2604.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2605.  
  2606.  PROCEDURE OpenOutput(defext :ARRAY OF CHAR);
  2607.  
  2608. Fragt den Benutzer nach einer Datei,
  2609. in die die Ausgaben umzuleiten sind.
  2610. Falls das letzte Zeichen der Eingabe ein Punkt ist,
  2611. wird "defext" (default Extension) an den Dateinamen angehängt.
  2612.  
  2613. Zurück zum Modul {InOut}
  2614.  
  2615. .topic RedirectInput
  2616.  
  2617.   InOut.RedirectInput ▄
  2618.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2619.  
  2620.  PROCEDURE RedirectInput(from: ARRAY OF CHAR);
  2621.  
  2622. Leitet die Eingabe aus der Datei "from" um.
  2623.  
  2624. Zurück zum Modul {InOut}
  2625.  
  2626. .topic RedirectOutput
  2627.  
  2628.   InOut.RedirectOutput ▄
  2629.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2630.  
  2631.  PROCEDURE RedirectOutput(to: ARRAY OF CHAR);
  2632.  
  2633. Leitet alle Ausgaben in die Datei "to" um.
  2634.  
  2635. Zurück zum Modul {InOut}
  2636.  
  2637. .topic CloseInput
  2638.  
  2639.   InOut.CloseInput ▄
  2640.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2641.  
  2642.  PROCEDURE CloseInput;
  2643.  
  2644. Die mit {OpenInput} oder {RedirectInput} geöffnete Datei
  2645. wird geschlossen und das Terminal als Eingabegerät
  2646. wieder aktiviert.
  2647.  
  2648. Zurück zum Modul {InOut}
  2649.  
  2650. .topic CloseOutput
  2651.  
  2652.   InOut.CloseOutput ▄
  2653.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2654.  
  2655.  PROCEDURE CloseOutput;
  2656.  
  2657. Die mit {OpenOutPut} oder {RedirectOutput} geöffnete
  2658. Datei wird geschlossen und das Terminal als Ausgabegerät
  2659. wieder aktiviert.
  2660.  
  2661. Zurück zum Modul {InOut}
  2662.  
  2663. .topic InOut_Read
  2664.  
  2665.   InOut.Read ▄
  2666.  ▀▀▀▀▀▀▀▀▀▀▀▀▀
  2667.  
  2668.  PROCEDURE Read(VAR ch: CHAR);
  2669.  
  2670. Liest ein Zeichen aus der Standard-Eingabe.
  2671.  
  2672. Zurück zum Modul {InOut} oder zur {Read}-Übersicht.
  2673.  
  2674. .topic ReadString
  2675.  
  2676.   InOut.ReadString ▄
  2677.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2678.  
  2679.  PROCEDURE ReadString(VAR s: ARRAY OF CHAR);
  2680.  
  2681. Liest eine Zeichenkette.
  2682.  
  2683. Die Eingabe wird durch ein Leerzeichen oder jedes
  2684. beliebige Steuerzeichen mit Ausnahme von {ASCII}.BS
  2685. oder ASCII.DEL beendet. Das letzte (beendende)
  2686. Zeichen wird in der Variablen InOut.{termCH} gespeichert.
  2687. Wenn vom Terminal gelesen wird, sind folgende
  2688. Editiermöglichkeiten gegeben:
  2689.  
  2690. ASCII.BS  löscht das letzte Zeichen
  2691.  
  2692. ASCII.DEL löscht die gesamte Eingabe
  2693.  
  2694. ASCII.ESC löscht die gesamte Eingabe und
  2695. beendet die Funktion mit RETURN.
  2696.  
  2697. Zurück zum Modul {InOut}
  2698.  
  2699. .topic InOut_ReadLine
  2700.  
  2701.   InOut.ReadLine ▄
  2702.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2703.  
  2704.  PROCEDURE ReadLine(VAR s: ARRAY OF CHAR);
  2705.  
  2706. Liest eine Zeile "s" aus der Standardeingabe.
  2707. Die Eingabe wird durch EOL, EOF oder ESC
  2708. beendet bzw. abgebrochen. Das letzte (beendende)
  2709. Zeichen wird in der Variablen InOut.{termCH} gespeichert.
  2710.  
  2711. Wenn vom Terminal gelesen wird, sind folgende
  2712. Editiermöglichkeiten gegeben:
  2713.  
  2714. {ASCII}.BS  löscht das letzte Zeichen
  2715.  
  2716. {ASCII}.DEL löscht die gesamte Eingabe
  2717.  
  2718. {ASCII}.ESC löscht die gesamte Eingabe
  2719. und beendet die Funktion mit RETURN.
  2720.  
  2721. Zurück zum Modul {InOut} oder zur {ReadLine}-Übersicht.
  2722.  
  2723. .topic ReadInt
  2724.  
  2725.   InOut.ReadInt ▄
  2726.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2727.  
  2728.  PROCEDURE ReadInt(VAR x: INTEGER);
  2729.  
  2730. Ein Zeichenfeld wird aus dem Eingabegerät
  2731. gelesen und dann in eine INTEGER-Zahl umgewandelt.
  2732.  
  2733. Zurück zum Modul {InOut}
  2734.  
  2735. .topic ReadCard
  2736.  
  2737.   InOut.ReadCard ▄
  2738.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2739.  
  2740.  PROCEDURE ReadCard(VAR x: CARDINAL);
  2741.  
  2742. Eine Zeichenkette wird aus dem Eingabegerät
  2743. gelesen und dann in eine CARDINAL-Zahl konvertiert.
  2744.  
  2745. Zurück zum Modul {InOut}
  2746.  
  2747. .topic ReadWrd
  2748.  
  2749.   InOut.ReadWrd ▄
  2750.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2751.  
  2752.  PROCEDURE ReadWrd(VAR w: WORD);
  2753.  
  2754. Liest ein {WORD} aus der Eingabe-Datei.
  2755.  
  2756.  Achtung:
  2757.  ────────
  2758. ReadWrd ist nur dann erlaubt, wenn die Eingabe
  2759. aus einer Datei umgeleitet wird!
  2760.  
  2761. Zurück zum Modul {InOut}
  2762.  
  2763. .topic InOut_Write
  2764.  
  2765.   InOut.Write ▄
  2766.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2767.  
  2768.  PROCEDURE Write(ch: CHAR);
  2769.  
  2770. Schreibt ein Zeichen an die Standardausgabe.
  2771.  
  2772. Zurück zum Modul {InOut} oder zur {Write}-Übersicht.
  2773.  
  2774. .topic InOut_WriteLn
  2775.  
  2776.   InOut.WriteLn ▄
  2777.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2778.  
  2779.  PROCEDURE WriteLn;
  2780.  
  2781. Identisch zu {Write:InOut_Write} ({ASCII}.EOL).
  2782. Schreibt einen Zeilenumbruch.
  2783.  
  2784. Zurück zum Modul {InOut} oder zur {WriteLn}-Übersicht.
  2785.  
  2786. .topic InOut_WriteString
  2787.  
  2788.   InOut.WriteString ▄
  2789.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2790.  
  2791.  PROCEDURE WriteString(s: ARRAY OF CHAR);
  2792.  
  2793. Schreibt die Zeichenkette "s" in die Standardausgabe.
  2794.  
  2795. Zurück zum Modul {InOut} oder zur {WriteString}-Übersicht.
  2796.  
  2797. .topic WriteInt
  2798.  
  2799.   InOut.WriteInt ▄
  2800.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2801.  
  2802.  PROCEDURE WriteInt(x: INTEGER; n: CARDINAL);
  2803.  
  2804. Schreibt die INTEGER-Zahl "x" rechtsbündig
  2805. in ein Feld mit "n" Zeichen.
  2806.  
  2807. Zurück zum Modul {InOut}
  2808.  
  2809. .topic WriteCard
  2810.  
  2811.   InOut.WriteCard ▄
  2812.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2813.  
  2814.  PROCEDURE WriteCard(x, n: CARDINAL);
  2815.  
  2816. Schreibt die CARDINAL-Zahl "x" rechtsbündig
  2817. in ein Feld mit "n" Zeichen.
  2818.  
  2819. Zurück zum Modul {InOut}
  2820.  
  2821. .topic WriteOct
  2822.  
  2823.   InOut.WriteOct ▄
  2824.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2825.  
  2826.  PROCEDURE WriteOct(x, n: CARDINAL);
  2827.  
  2828. Schreibt "x" in oktaler Form in ein
  2829. rechtsbündiges Feld von mindestens "n" Zeichen.
  2830.  
  2831. Wenn (n <═ 3) und (x < 100H) dann werden
  2832. drei, ansonsten sechs Zeichen geschrieben.
  2833.  
  2834. Zurück zum Modul {InOut}
  2835.  
  2836. .topic WriteHex
  2837.  
  2838.   InOut.WriteHex ▄
  2839.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2840.  
  2841.  PROCEDURE WriteHex(x, n: CARDINAL);
  2842.  
  2843. Schreibt "x" in hexadezimaler Form in
  2844. ein rechtsbündiges Feld von mindestens "n" Zeichen.
  2845.  
  2846. Wenn (n <═ 2) und (x < 100H) dann werden
  2847. zwei, ansonsten vier Zeichen geschrieben.
  2848.  
  2849. Zurück zum Modul {InOut}
  2850.  
  2851. .topic WriteWrd
  2852.  
  2853.   InOut.WriteWrd ▄
  2854.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2855.  
  2856.  PROCEDURE WriteWrd(w: WORD);
  2857.  
  2858. Schreibt "w" in die Ausgabedatei.
  2859.  
  2860. Die Operation ist nur dann erlaubt,
  2861. wenn die Ausgabe in eine Datei umgeleitet wird.
  2862.  
  2863. Zurück zum Modul {InOut}
  2864.  
  2865. .topic ReadLongInt
  2866.  
  2867.   InOut.ReadLongInt ▄
  2868.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2869.  
  2870.  PROCEDURE ReadLongInt(VAR x: LONGINT);
  2871.  
  2872. Eine Zeichenkette wird aus dem Eingabegerät
  2873. gelesen und dann in eine LONGINT-Zahl umgewandelt.
  2874.  
  2875. Zurück zum Modul {InOut}
  2876.  
  2877. .topic ReadLongCard
  2878.  
  2879.   InOut.ReadLongCard ▄
  2880.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2881.  
  2882.  PROCEDURE ReadLongCard(VAR x: LONGCARD);
  2883.  
  2884. Eine Zeichenkette wird aus dem Eingabegerät
  2885. gelesen und dann in eine LONGCARD-Zahl umgewandelt.
  2886.  
  2887. Zurück zum Modul {InOut}
  2888.  
  2889. .topic WriteLongInt
  2890.  
  2891.   InOut.ReadLongInt ▄
  2892.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2893.  
  2894.  PROCEDURE WriteLongInt(x: LONGINT; n: CARDINAL);
  2895.  
  2896. Schreibt die LONGINT-Zahl "x" rechtsbündig in
  2897. ein Feld von mindestens "n" Zeichen.
  2898.  
  2899. Zurück zum Modul {InOut}
  2900.  
  2901. .topic WriteLongCard
  2902.  
  2903.   InOut.WriteLongCard ▄
  2904.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2905.  
  2906.  PROCEDURE WriteLongCard(x: LONGCARD; n: CARDINAL);
  2907.  
  2908. Schreibt die LONGCARD-Zahl "x" rechtsbündig in
  2909. ein Feld von mindestens "n" Zeichen.
  2910.  
  2911. Zurück zum Modul {InOut}
  2912.  
  2913. .topic InOut_WriteLine
  2914.  
  2915.   InOut.WriteLine ▄
  2916.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2917.  
  2918.  PROCEDURE WriteLine(s: ARRAY OF CHAR);
  2919.  
  2920.  identisch mit:
  2921.    {WriteString:InOut_WriteString}(s); {WriteLn:InOut_WriteLn};
  2922.  
  2923. Zurück zum Modul {InOut} oder zur {WriteLine}-Übersicht.
  2924.  
  2925. .topic MLongJump
  2926.  
  2927.   MODULE LongJump ▄
  2928.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  2929.  
  2930. SetJump sichert die Umgebung des
  2931. Vaterprozesses in dem übergebenen Parameter
  2932. und gibt 0 zurück.
  2933.  
  2934. LongJump stellt die gesicherte Umgebung
  2935. eines vorherigen SetJump wieder her.
  2936. Die Ausführung wird als Rückgabe (RETURN)
  2937. von SetJump wieder aufgenommen.
  2938. Der Rückgabewert wird SetJump untergeschoben.
  2939.  
  2940. Logischerweise darf der Zeiger auf die
  2941. zurückgelieferten Parameter nicht NIL (RETURN 0) sein.
  2942.  
  2943. Wenn LongJump aufgerufen wird, muß die Prozedur,
  2944. die den korrespondierenden SetJump
  2945. durchgeführt hat, noch aktiv sein.
  2946.  
  2947.  Beispiel:
  2948.  
  2949.   PROCEDURE main;
  2950.    ...
  2951.    IF SetJump(env) ═ 0 THEN
  2952.      Parse
  2953.    ELSE
  2954.      WriteString("error in Parse")
  2955.    END;
  2956.    ...
  2957.  
  2958.   PROCEDURE Parse;
  2959.    ...
  2960.    IF errorcond THEN
  2961.      LongJump(env, 1)
  2962.    END;
  2963.    ...
  2964.  
  2965.  
  2966. Die Prozedur "main" ruft SetJump auf, um die aktuelle
  2967. Ausführungsumführung in "env" zu sichern.
  2968. SetJump liefert 0 zurück und anschließend
  2969. wird "Parse" aufgerufen.
  2970.  
  2971. Falls Parse einen Fehler entdeckt,
  2972. ruft die Prozedur LongJump mit einem
  2973. Rückgabewert von 1.
  2974. Die Hauptprozedur "main" wird am
  2975. Rückgabe-Punkt von SetJump fortgesetzt,
  2976. die IF-Bedingung Abfrage wird {FALSE} und
  2977. der String ausgegeben.
  2978.  
  2979.  ------------------------
  2980.  
  2981.  deklarierter Typ:
  2982.    {JumpBuffer}
  2983.  
  2984.  deklarierte Prozeduren:
  2985.    {SetJump}    {LongJump}
  2986.  
  2987.  
  2988. Zurück zum {Index} oder zu {Routinen}, Ende mit ESC
  2989.  
  2990. .topic JumpBuffer
  2991.  
  2992.   LongJump.JumpBuffer
  2993.  ─────────────────────┘
  2994.  
  2995.  TYPE
  2996.    JumpBuffer ═ RECORD
  2997.      savPC, savCS,
  2998.      savSP, savBP: CARDINAL;
  2999.    END;
  3000.  
  3001. Globale Pufferung der Routinen des Moduls LongJump.
  3002.  
  3003. Zurück zum Modul {LongJump:MLongJump}
  3004.  
  3005. .topic SetJump
  3006.  
  3007.   LongJump.SetJump ▄
  3008.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3009.  
  3010.  PROCEDURE SetJump(VAR mark: JumpBuffer):
  3011.                              CARDINAL;
  3012.  
  3013. Sichert die Umgebung des aktuellen Vaterprozesses in "MARK".
  3014. Es wird 0 zurückgegeben.
  3015.  
  3016. Zurück zum Modul {LongJump:MLongJump}
  3017.  
  3018. .topic LongJump
  3019.  
  3020.   LongJump.LongJump  ▄
  3021.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3022.  
  3023.  PROCEDURE LongJump(VAR mark: JumpBuffer;
  3024.                       return: CARDINAL);
  3025.  
  3026. Restauriert die in "mark" gesicherte Prozeßumgebung
  3027. und kehrt von {SetJump} mit dem Rückgabewert "return" zurück.
  3028.  
  3029. Zurück zum Modul {LongJump:MLongJump}
  3030.  
  3031. .topic FileSystem
  3032.  
  3033.   MODULE FileSystem ▄
  3034.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3035.  
  3036. Dieses Modul enthält die Dateiroutinen wie sie
  3037. Niklaus Wirth in seinem Buch "Programming in Modula-2" beschrieben hat.
  3038. Alle Prozeduren setzen File.res auf "done" wenn der
  3039. Aufruf erfolgreich war; sonst wird File.res auf "notdone" gesetzt.
  3040. File.eof ist TRUE nachdem eine neue Datei erzeugt wurde
  3041. oder wenn eine Leseoperation (Read????) aufgerufen wurde
  3042. und keine weiteren Daten zur Verfügung stehen.
  3043.  
  3044.  TYPE
  3045.     {FDPtr};  (* Nur für internen Gebrauch *)
  3046.     {Response} ═ (done, notdone);
  3047.     {IOMode}   ═ (read, write, io);
  3048.     {File} ═ RECORD
  3049.         id:    INTEGER;
  3050.         res:   Response;
  3051.         eof:   BOOLEAN;
  3052.         mode:  IOMode;
  3053.         fdptr: FDPtr; (* Nur für internen Gebrauch *)
  3054.     END;
  3055.  
  3056.  deklarierte Prozeduren:
  3057.  
  3058.   {LookUp}      {Create:FileSystem_Create}
  3059.   {Reset}       {Close:FileSystem_Close}
  3060.   {Rewrite}     {Rename:FileSystem_Rename}
  3061.   {ReadWord}    {WriteWord}
  3062.   {ReadChar}    {WriteChar:FileSystem_WriteChar}
  3063.   {GetPos}      {SetPos}
  3064.   {GetLPos}     {SetLPos}
  3065.   {LLength}     {Length:FileSystem_Length}
  3066.   {ReadNBytes}  {WriteNBytes}
  3067.  
  3068. Zurück zum {Index} oder zu {Routinen}, Ende mit ESC
  3069.  
  3070. .topic FDPtr
  3071.  
  3072.   FileSystem.FDPtr
  3073.  ──────────────────┘
  3074.  
  3075.   TYPE
  3076.     FDPtr;
  3077.  
  3078. File-Description-Pointer, nur für internen Gebrauch!
  3079.  
  3080. Zurück zum Modul {FileSystem}
  3081.  
  3082. .topic Response
  3083.  
  3084.   FileSystem.Response
  3085.  ─────────────────────┘
  3086.  
  3087.  TYPE
  3088.    Response ═ (done, notdone);
  3089.  
  3090. Überprüfung, ob die Dateioperation erfolgreich durchgeführt wurde.
  3091.  
  3092. Zurück zum Modul {FileSystem}
  3093.  
  3094. .topic IOMode
  3095.  
  3096.   FileSystem.IOMode
  3097.  ───────────────────┘
  3098.  
  3099.  TYPE
  3100.    IOMode ═ (read, write, io);
  3101.  
  3102. Der Modus in dem die Datei behandelt werden soll:
  3103.  
  3104.  read  ═ nur lesen
  3105.  write ═ nur schreiben
  3106.  io    ═ lesen und schreiben
  3107.  
  3108. Zurück zum Modul {FileSystem}
  3109.  
  3110. .topic File
  3111.  
  3112.   FileSystem.File
  3113.  ─────────────────┘
  3114.  
  3115.  TYPE
  3116.    File ═ RECORD
  3117.      id:    INTEGER;
  3118.      res:   Response;
  3119.      eof:   BOOLEAN;
  3120.      mode:  IOMode;
  3121.      fdptr: FDPtr; ( Nur für internen Gebrauch )
  3122.    END;
  3123.  
  3124. Der Record enthält alle für Dateioperationen wichtigen Daten.
  3125.  
  3126. Zurück zum Modul {FileSystem}
  3127.  
  3128. .topic LookUp
  3129.  
  3130.   FileSystem.LookUp ▄
  3131.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3132.  
  3133.  PROCEDURE Lookup(VAR f: {File};
  3134.               filename: ARRAY OF CHAR;
  3135.                    new: BOOLEAN);
  3136.  
  3137. Öffnet die in "filename" genannte Datei.
  3138. Falls die Datei nicht vorhanden ist, wird sie,
  3139. wenn "new" TRUE ist, neu erstellt, sonst ein Fehler zurückgegeben.
  3140.  
  3141. LookUp versucht immer zu erst eine Datei
  3142. für {io:IOMode} zu öffnen.
  3143. Falls dies fehlschlägt, wird versucht, die Datei zum Lesen zu öffnen.
  3144. f.mode wird äquivalent zum Öffnungsmodus gesetzt.
  3145.  
  3146. Zurück zum Modul {FileSystem}
  3147.  
  3148. .topic FileSystem_Create
  3149.  
  3150.   FileSystem.Create ▄
  3151.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3152.  
  3153. PROCEDURE Create(VAR f: {File};
  3154.             mediumname: ARRAY OF CHAR);
  3155.  
  3156. Erstelle eine neue temporäre Datei.
  3157.  
  3158. Falls "mediumname" mit einer Variable im
  3159. DOS-Environment übereinstimmt, wird diese
  3160. Variable für den Pfad zu der Temporärdatei verwendet.
  3161. Wenn die Operation geklappt hat, wird f.res auf "done"
  3162. gesetzt, sonst auf "notdone".
  3163. f.eof ist nach der Operation TRUE, da eine neue Datei erstellt wurde.
  3164.  
  3165. Zurück zum Modul {FileSystem} oder zur {Create}-Übersicht.
  3166.  
  3167. .topic FileSystem_Close
  3168.  
  3169.   FileSystem.Close ▄
  3170.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3171.  
  3172.  PROCEDURE Close(VAR f: {File});
  3173.  
  3174. Schließt die Datei "f".
  3175.  
  3176. Falls die Datei mit {Rename:FileSystem_Rename})
  3177. umbenannt wurde, wird der Verzeichniseintrag zu
  3178. diesem Zeitpunkt aktualisiert.
  3179.  
  3180. Falls notwendig (die Datei wurde zu einem anderen
  3181. Laufwerk umbenannt), wird die Datei jetzt kopiert.
  3182.  
  3183. Zurück zum Modul {FileSystem} oder zur {Close}-Übersicht.
  3184.  
  3185. .topic Reset
  3186.  
  3187.   FileSystem.Reset ▄
  3188.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3189.  
  3190.  PROCEDURE Reset(VAR f: {File});
  3191.  
  3192. Setzt den Dateizeiger an den Anfang der Datei "f".
  3193.  
  3194. Zurück zum Modul {FileSystem}
  3195.  
  3196. .topic Rewrite
  3197.  
  3198.   FileSystem.ReWrite ▄
  3199.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3200.  
  3201.  PROCEDURE Rewrite(VAR f: {File});
  3202.  
  3203. Setzt den Dateizeiger an den Anfang der Datei und
  3204. schneidet den Rest ab (leert den Inhalt) der Datei.
  3205.  
  3206. Zurück zum Modul {FileSystem}
  3207.  
  3208. .topic FileSystem_Rename
  3209.  
  3210.   FileSystem.Rename ▄
  3211.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3212.  
  3213.  PROCEDURE Rename(VAR f: {File};
  3214.                filename: ARRAY OF CHAR );
  3215.  
  3216. Ändert den Namen der Datei "f" in "filename".
  3217.  
  3218. Die Datei kann zu einem anderen Verzeichnis oder
  3219. auf ein anderes Laufwerk umbenannt (bewegt) werden.
  3220.  
  3221.  Hinweis:
  3222.  
  3223. Der Verzeichniseintrag wird erst geändert,
  3224. wenn die Datei geschlossen ({Close:FileSystem_Close}) wird.
  3225.  
  3226. Zurück zum Modul {FileSystem} oder zur {Rename}-Übersicht.
  3227.  
  3228. .topic ReadWord
  3229.  
  3230.   FileSystem.ReadWord ▄
  3231.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3232.  
  3233.  PROCEDURE ReadWord(VAR f: {File};
  3234.                     VAR w: {WORD});
  3235.  
  3236. Lese einen WORD-Wert aus einer Datei.
  3237.  
  3238. Falls die Leseoperation zum Dateiende gelangt,
  3239. wird File.eof auf TRUE gesetzt.
  3240.  
  3241. Zurück zum Modul {FileSystem}
  3242.  
  3243. .topic WriteWord
  3244.  
  3245.   FileSystem.WriteWord ▄
  3246.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3247.  
  3248.  PROCEDURE WriteWord(VAR f: {File};
  3249.                          w: {WORD});
  3250.  
  3251. Schreibt ein WORD in eine Datei.
  3252.  
  3253. Die Prozedur setzt {File}.res auf "done",
  3254. wenn der Aufruf erfolgreich war, ansonsten wird
  3255. file.res auf "notdone" gesetzt.
  3256. File.eof ist TRUE, nachdem eine neue Datei erstellt wird.
  3257.  
  3258. Zurück zum Modul {FileSystem}
  3259.  
  3260. .topic ReadChar
  3261.  
  3262.   FileSystem.ReadChar ▄
  3263.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3264.  
  3265.  PROCEDURE ReadChar(VAR f : {File};
  3266.                     VAR ch: CHAR);
  3267.  
  3268. Liest einen Zeichen aus der Datei.
  3269. Das Zeichen {ASCII}.CR wird zu {ASCII}.EOL konvertiert.
  3270. {ASCII}.LF wird ignoriert.
  3271.  
  3272. Die Prozedur setzt {File}.res auf "done",
  3273. wenn der Aufruf erfolgreich war,
  3274. ansonsten wird file.res auf "notdone" gesetzt.
  3275.  
  3276. Zurück zum Modul {FileSystem}
  3277.  
  3278. .topic FileSystem_WriteChar
  3279.  
  3280.   FileSystem.WriteChar ▄
  3281.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3282.  
  3283.  PROCEDURE WriteChar(VAR f: {File};
  3284.                         ch: CHAR);
  3285.  
  3286. Schreibt das Zeichen "ch" in die Datei.
  3287.  
  3288. {ASCII}.EOL wird zu der Sequenz ASCII.CR ASCII.LF konvertiert.
  3289.  
  3290. Zurück zum Modul {FileSystem} oder zur {WriteChar}-Übersicht.
  3291.  
  3292. .topic GetPos
  3293.  
  3294.   FileSystem.GetPos ▄
  3295.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3296.  
  3297.  PROCEDURE GetPos(VAR f: {File};
  3298.             VAR highpos,
  3299.                 lowpos : {CARDINAL});
  3300.  
  3301. Liefert die aktuelle Position des Dateizeigers.
  3302.  
  3303. Siehe auch {SetPos}, {SetLPos} und {GetLPos}.
  3304.  
  3305. Zurück zum Modul {FileSystem}.
  3306.  
  3307. .topic SetPos
  3308.  
  3309.   FileSystem.SetPos ▄
  3310.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3311.  PROCEDURE SetPos(VAR f: {File};
  3312.                 highpos,
  3313.                  lowpos: {CARDINAL});
  3314.  
  3315. Bewegt den Dateizeiger zur Position highpos * 65536 + lowpos.
  3316.  
  3317. Siehe auch {SetLPos}, {GetPos} und {GetLPos}.
  3318.  
  3319. Zurück zum Modul {FileSystem}.
  3320.  
  3321. .topic GetLPos
  3322.  
  3323.   FileSystem.GetLPos ▄
  3324.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3325.  PROCEDURE GetLPos(VAR f  : {File};
  3326.                    VAR pos: {LONGCARD});
  3327.  
  3328. Liefert die aktuelle Position des Dateizeigers.
  3329.  
  3330. Siehe auch {GetPos}, {GetLPos} und {SetLPos}.
  3331.  
  3332. Zurück zum Modul {FileSystem}
  3333.  
  3334. .topic SetLPos
  3335.  
  3336.   FileSystem.SetLPos ▄
  3337.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3338.  
  3339.  PROCEDURE SetLPos(VAR f: {File};
  3340.                      pos: {LONGCARD});
  3341.  
  3342. Bewegt den Dateizeiger zur Position highpos * 65536 + lowpos.
  3343.  
  3344. Siehe auch {SetPos}, {GetPos} und {GetLPos}.
  3345.  
  3346. Zurück zum Modul {FileSystem}
  3347.  
  3348. .topic FileSystem_Length
  3349.  
  3350.   FileSystem.Length ▄
  3351.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3352.  
  3353.  PROCEDURE Length(VAR f: {File};
  3354.             VAR highlen,
  3355.                 lowlen : {CARDINAL});
  3356.  
  3357. Gibt die Länge der Datei zurück.
  3358.  
  3359. Siehe auch {LLength}
  3360.  
  3361. Zurück zum Modul {FileSystem} oder zur {Length}-Übersicht.
  3362.  
  3363. .topic LLength
  3364.  
  3365.   FileSystem.LLength ▄
  3366.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3367.  
  3368.  PROCEDURE LLength(VAR f: {File};
  3369.               VAR length: {LONGCARD});
  3370.  
  3371. Gibt die Länge der Datei zurück.
  3372.  
  3373. Siehe auch {Length:FileSystem_Length}.
  3374.  
  3375. Zurück zum Modul {FileSystem}
  3376.  
  3377. .topic ReadNBytes
  3378.  
  3379.   FileSystem.ReadNBytes ▄
  3380.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3381.  
  3382.  PROCEDURE ReadNBytes(VAR f: {File};
  3383.                     buffPtr: {ADDRESS};
  3384.                           n: {CARDINAL};
  3385.                   VAR nRead: CARDINAL);
  3386.  
  3387. Die Prozedur versucht, "n" Bytes zu lesen.
  3388.  
  3389. Bei der Rückkehr wird die Anzahl der gelesenen Bytes
  3390. in "nRead" zurückgeliefert.
  3391. Falls das Dateiende erreicht wird, wird File.eof auf TRUE gesetzt.
  3392.  
  3393. siehe auch {WriteNBytes}.
  3394.  
  3395. Zurück zum Modul {FileSystem}
  3396.  
  3397. .topic WriteNBytes
  3398.  
  3399.   FileSystem.WriteNBytes ▄
  3400.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3401.  
  3402.  PROCEDURE WriteNBytes(VAR f: {File};
  3403.                      buffPtr: {ADDRESS};
  3404.                            n: {CARDINAL};
  3405.                 VAR nWritten: CARDINAL);
  3406.  
  3407. Die Prozedur schreibt "n" Bytes in die Datei.
  3408.  
  3409. Bei der Rückkehr wird die aktuelle Zahl geschriebener
  3410. Bytes in "nWritten" zurückgegeben.
  3411.  
  3412. siehe auch {ReadNBytes}.
  3413.  
  3414. Zurück zum Modul {FileSystem}
  3415.  
  3416. .topic MathLib0
  3417.  
  3418.   MODULEs MathLib0/LMathLib0 ▄
  3419.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3420.  
  3421.   MathLib0:
  3422.  ═══════════╝
  3423.  
  3424. Das MathLib0-Modul wie es von Niklaus Wirth in seinem
  3425. Buch "Programming in Modula-2" definiert wurde.
  3426.  
  3427.   LMathLib0:
  3428.  ════════════╝
  3429.  
  3430. Die LONGREALs-Version von Mathlib0.
  3431.  
  3432. M2Reals, Mathlib0 und LMathLib0 benutzen den
  3433. Coprozessor 8087/80x87, falls vorhanden.
  3434.  
  3435. In MathLib0 und LMathLib0 definierte Prozeduren:
  3436.  
  3437.  {sqrt}      {exp}
  3438.  {ln}        {sin}
  3439.  {cos}       {arctan}
  3440.  {real}      {entier}
  3441.  
  3442. Zurück zum {Index} oder zu {Routinen}, Ende mit ESC
  3443.  
  3444. .topic sqrt
  3445.  
  3446.   (L)MathLib0.sqrt ▄
  3447.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3448.  
  3449.  PROCEDURE MathLib0.sqrt(x: REAL): REAL;
  3450.  PROCEDURE LMathLib0.sqrt(x: LONGREAL): LONGREAL;
  3451.  
  3452. Zurück zum Modul (L){MathLib0}
  3453.  
  3454. .topic exp
  3455.  
  3456.   (L)MathLib0.exp ▄
  3457.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3458.  
  3459.  PROCEDURE MathLib0.exp(x :REAL): REAL;
  3460.  PROCEDURE LMathLib0.exp(x: LONGREAL): LONGREAL;
  3461.  
  3462. Zurück zum Modul (L){MathLib0}
  3463.  
  3464. .topic ln
  3465.  
  3466.   (L)MathLib0.ln ▄
  3467.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3468.  
  3469.  PROCEDURE MathLib0.ln(x: REAL): REAL;
  3470.  PROCEDURE LMathLib0.ln(x: LONGREAL): LONGREAL;
  3471.  
  3472. Zurück zum Modul (L){MathLib0}
  3473.  
  3474. .topic sin
  3475.  
  3476.   (L)MathLib0.sin ▄
  3477.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3478.  
  3479.  PROCEDURE MathLib0.sin(x: REAL): REAL;
  3480.  PROCEDURE LMathLib0.sin(x: LONGREAL): LONGREAL;
  3481.  
  3482. Zurück zum Modul (L){MathLib0}
  3483.  
  3484. .topic cos
  3485.  
  3486.   (L)MathLib0.cos ▄
  3487.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3488.  
  3489.  PROCEDURE MathLib0.cos(x: REAL): REAL;
  3490.  PROCEDURE LMathLib0.cos(x: LONGREAL): LONGREAL;
  3491.  
  3492. Zurück zum Modul (L){MathLib0}
  3493.  
  3494. .topic arctan
  3495.  
  3496.   (L)MathLib0.arctan ▄
  3497.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3498.  
  3499.  PROCEDURE MathLib0.arctan(x: REAL): REAL;
  3500.  PROCEDURE LMathLib0.arctan(x: LONGREAL): LONGREAL;
  3501.  
  3502. Zurück zum Modul (L){MathLib0}
  3503.  
  3504. .topic real
  3505.  
  3506.   (L)MathLib0.real ▄
  3507.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3508.  
  3509.  PROCEDURE MathLib0.real(x: INTEGER): REAL;
  3510.  PROCEDURE LMathLib0.real(x: LONGINT): LONGREAL;
  3511.  
  3512. Zurück zum Modul (L){MathLib0}
  3513.  
  3514. .topic entier
  3515.  
  3516.   (L)MathLib0.entier ▄
  3517.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3518.  
  3519.  PROCEDURE MathLib0.entier(x: REAL): INTEGER;
  3520.  PROCEDURE LMathLib0.entier(x: LONGREAL): LONGINT;
  3521.  
  3522. Zurück zum Modul (L){MathLib0}
  3523.  
  3524. .topic NumberConversion
  3525.  
  3526.    MODULE NumberConversion ▄
  3527.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3528.  
  3529. Das Modul enthält Prozeduren zur Umwandlung von
  3530. Zahlen ({INTEGER}/{CARDINAL}/{LONGINT}/{LONGCARD})
  3531. in Strings und wieder zurück.
  3532.  
  3533.  CONST
  3534.    {MaxBase} ═ 16;
  3535.  
  3536.  TYPE
  3537.    {BASE}    ═ [2..MaxBase];
  3538.  
  3539.  
  3540.  definierte Prozeduren:
  3541.  
  3542.  {StringToCard}       {StringToInt}
  3543.  {StringToNum}        {CardToString}
  3544.  {CardToString}       {NumToString}
  3545.  {StringToLongCard}   {StringToLongInt}
  3546.  {StringToLongNum}    {LongCardToString}
  3547.  {LongIntToString}    {LongNumToString}
  3548.  
  3549. Zurück zum {Index} oder zu {Routinen}, Ende mit ESC
  3550.  
  3551. .topic MaxBase
  3552.  
  3553.   CONST NumberConversion.MaxBase
  3554.  ════════════════════════════════╝
  3555.  
  3556. Basis für die "Num"-Umwandlungen
  3557.  
  3558.  CONST
  3559.    MaxBase ═ 16
  3560.  
  3561.  TYPE
  3562.    BASE    ═ [2..MaxBase];
  3563.  
  3564. Zurück zum Modul {NumberConversion}
  3565.  
  3566. .topic BASE
  3567.  
  3568.   TYPE NumberConversion.BASE
  3569.  ════════════════════════════╝
  3570.  
  3571.  CONST
  3572.    MaxBase ═ 16;
  3573.  
  3574.  TYPE
  3575.    BASE    ═ [2..MaxBase];
  3576.  
  3577. Zurück zum Modul {NumberConversion}
  3578.  
  3579. .topic StringToCard
  3580.  
  3581.   NumberConversion.StringToCard ▄
  3582.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3583.  
  3584. PROCEDURE StringToCard(str: ARRAY OF CHAR;
  3585.                    VAR num: CARDINAL;
  3586.                   VAR done: BOOLEAN);
  3587.  
  3588. Zurück zum Modul {NumberConversion}
  3589.  
  3590. .topic StringToInt
  3591.  
  3592.   NumberConversion.StringToInt ▄
  3593.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3594.  
  3595.  
  3596. PROCEDURE StringToInt(str: ARRAY OF CHAR;
  3597.                   VAR num: INTEGER;
  3598.                  VAR done: BOOLEAN);
  3599.  
  3600. Zurück zum Modul {NumberConversion}
  3601.  
  3602. .topic StringToNum
  3603.  
  3604.   NumberConversion.StringToNum ▄
  3605.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3606.  
  3607. PROCEDURE StringToNum(str: ARRAY OF CHAR;
  3608.                      base: BASE;
  3609.                   VAR num: CARDINAL;
  3610.                  VAR done: BOOLEAN);
  3611.  
  3612. Zurück zum Modul {NumberConversion}
  3613.  
  3614. .topic CardToString
  3615.  
  3616.   NumberConversion.CardToString ▄
  3617.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3618.  
  3619. PROCEDURE CardToString(num: CARDINAL;
  3620.                    VAR str: ARRAY OF CHAR;
  3621.                      width: CARDINAL);
  3622.  
  3623. Zurück zum Modul {NumberConversion}
  3624.  
  3625. .topic IntToString
  3626.  
  3627.   NumberConversion.IntToString ▄
  3628.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3629.  
  3630. PROCEDURE IntToString(num: INTEGER;
  3631.                   VAR str: ARRAY OF CHAR;
  3632.                     width: CARDINAL);
  3633.  
  3634. Zurück zum Modul {NumberConversion}
  3635.  
  3636. .topic NumToString
  3637.  
  3638.   NumberConversion.NumToString ▄
  3639.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3640.  
  3641. PROCEDURE NumToString(num: CARDINAL;
  3642.                      base: BASE;
  3643.                   VAR str: ARRAY OF CHAR;
  3644.                     width: CARDINAL);
  3645.  
  3646. Zurück zum Modul {NumberConversion}
  3647.  
  3648. .topic StringToLongCard
  3649.  
  3650.   NumberConversion.StringToLongCard ▄
  3651.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3652.  
  3653. PROCEDURE StringToLongCard(str: ARRAY OF CHAR;
  3654.                        VAR num: LONGCARD;
  3655.                       VAR done: BOOLEAN);
  3656.  
  3657. Zurück zum Modul {NumberConversion}
  3658.  
  3659. .topic StringToLongInt
  3660.  
  3661.   NumberConversion.StringToLongInt ▄
  3662.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3663.  
  3664. PROCEDURE StringToLongInt(str: ARRAY OF CHAR;
  3665.                       VAR num: LONGINT;
  3666.                      VAR done: BOOLEAN);
  3667.  
  3668. Zurück zum Modul {NumberConversion}
  3669.  
  3670. .topic StringToLongNum
  3671.  
  3672.   NumberConversion.StringToLongNum ▄
  3673.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3674.  
  3675. PROCEDURE StringToLongNum(str: ARRAY OF CHAR;
  3676.                          base: BASE;
  3677.                       VAR num: LONGCARD;
  3678.                      VAR done: BOOLEAN);
  3679.  
  3680. Zurück zum Modul {NumberConversion}
  3681.  
  3682. .topic LongCardToString
  3683.  
  3684.   NumberConversion.LongCardToString ▄
  3685.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3686.  
  3687. PROCEDURE LongCardToString(num: LONGCARD;
  3688.                        VAR str: ARRAY OF CHAR;
  3689.                          width: CARDINAL);
  3690.  
  3691. Zurück zum Modul {NumberConversion}
  3692.  
  3693. .topic LongIntToString
  3694.  
  3695.   NumberConversion.LongIntToString ▄
  3696.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3697.  
  3698. PROCEDURE LongIntToString(num: LONGINT;
  3699.                       VAR str: ARRAY OF CHAR;
  3700.                         width: CARDINAL);
  3701.  
  3702. Zurück zum Modul {NumberConversion}
  3703.  
  3704. .topic LongNumToString
  3705.  
  3706.   NumberConversion.LongNumToString ▄
  3707.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3708.  
  3709. PROCEDURE LongNumToString(num: LONGCARD;
  3710.                          base: BASE;
  3711.                       VAR str: ARRAY OF CHAR;
  3712.                         width: CARDINAL);
  3713.  
  3714. Zurück zum Modul {NumberConversion}
  3715.  
  3716. .topic RealInOut
  3717.  
  3718.    MODULE RealInOut ▄
  3719.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3720.  
  3721. Das Modul ist eine Erweiterung von InOut und
  3722. enthält die Routinen für das Lesen und Schreiben
  3723. von Fließkommazahlen.
  3724. Das Modul erledigt seine Ein- und Ausgaben
  3725. über das Modul {InOut:InOut}.
  3726.  
  3727.  definierte Variable:
  3728.  
  3729.   {Done:RealInOut_Done}
  3730.  
  3731.  definierte Prozeduren:
  3732.  
  3733.   {ReadReal}      {WriteReal}
  3734.   {ReadLongReal}  {WriteLongReal}
  3735.  
  3736. Zurück zum {Index} oder zu {Routinen}, Ende mit ESC
  3737.  
  3738. .topic RealInOut_Done
  3739.  
  3740.   VAR RealInOut.Done
  3741.  ───────────────────┘
  3742.  VAR
  3743.    Done: BOOLEAN;
  3744.  
  3745. Globale Kontrollvariable für die Prozeduren den Moduls RealInOut.
  3746.  
  3747. .topic ReadReal
  3748.  
  3749.   RealInOut.ReadReal ▄
  3750.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3751.  
  3752.  PROCEDURE ReadReal(VAR x: REAL);
  3753.  
  3754. Liest einen String.
  3755. Dieser wird anschließend in eine REAL-Zahl umgewandelt,
  3756. die dann in "x" zurückgegeben wird.
  3757. Eine REAL-Zahl im von Fitted-Modula verarbeitbaren
  3758. Format wird erwarted.
  3759.  
  3760. Die Variable "Done" wird auf TRUE gesetzt,
  3761. wenn eine REAL-Zahl im korrekten Format gelesen wurde.
  3762.  
  3763. Zurück zum Modul {RealInOut}.
  3764.  
  3765. .topic WriteReal
  3766.  
  3767.   RealInOut.WriteReal ▄
  3768.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3769.  
  3770.  PROCEDURE WriteReal(x: REAL;
  3771.                      n: CARDINAL);
  3772.  
  3773. "x" wird in wissenschaftlicher Notation rechtsbündig
  3774. in ein Feld von mindestens n Zeichen geschrieben.
  3775.  
  3776. Zurück zum Modul {RealInOut}.
  3777.  
  3778. .topic ReadLongReal
  3779.  
  3780.   RealInOut.ReadLongReal ▄
  3781.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3782.  
  3783.  PROCEDURE ReadLongReal(VAR x: LONGREAL);
  3784.  
  3785. Siehe auch {ReadReal}.
  3786.  
  3787. Zurück zum Modul {RealInOut}.
  3788.  
  3789. .topic WriteLongReal
  3790.  
  3791.   RealInOut.WriteLongReal ▄
  3792.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3793.  
  3794.  PROCEDURE WriteLongReal(x: LONGREAL;
  3795.                          n: CARDINAL);
  3796.  
  3797. Siehe auch {WriteReal}
  3798.  
  3799. Zurück zum Modul {RealInOut}.
  3800.  
  3801. .topic Storage
  3802.  
  3803.   MODULE Storage ▄
  3804.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3805.  
  3806. Dieses Modul ist für die Bearbeitung des
  3807. Modula-2-Heaps zwischen {System.HeapTop:HeapTop}
  3808. und {System.MemTop:MemTop} verantwortlich.
  3809.  
  3810. Die Prozeduren in Storage verändern
  3811. System.HeapTop je nachdem, wie der Heap
  3812. vergrößert oder verkleinert wird.
  3813.  
  3814. In Storage sind folgende Prozeduren definiert:
  3815.  
  3816.  {ALLOCATE}  {DEALLOCATE}  {Available}
  3817.  
  3818. Zurück zum {Index} oder zu {Routinen}, Ende mit ESC
  3819.  
  3820. .topic ALLOCATE
  3821.  
  3822.   Storage.ALLOCATE ▄
  3823.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3824.  
  3825.  PROCEDURE ALLOCATE(VAR a: ADDRESS;
  3826.                      size: CARDINAL);
  3827.  
  3828. Allokiert "size" Bytes im Heap und gibt einen
  3829. Zeiger auf diesen Bereich in "a" zurück.
  3830.  
  3831. Zurück zum Modul {Storage}
  3832.  
  3833. .topic DEALLOCATE
  3834.  
  3835.   Storage.DEALLOCATE ▄
  3836.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3837.  
  3838.  PROCEDURE DEALLOCATE(VAR a: ADDRESS;
  3839.                        size: CARDINAL);
  3840.  
  3841. Gibt eine vorher allokierten Speicherblock der Größe "size" wieder frei.
  3842. Wenn die Compiler-Option (*{$T:Switches_sT}*) gesetzt ist,
  3843. werden Zeiger vor dem Zugriff auf NIL geprüft.
  3844. Außerdem setzt Storage.DEALLOCATE den übergebenen Zeiger auf NIL.
  3845.  
  3846. Zurück zum Modul {Storage}
  3847.  
  3848. .topic Available
  3849.  
  3850.    Storage.Available ▄
  3851.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3852.  
  3853. PROCEDURE Available(size: CARDINAL): BOOLEAN;
  3854.  
  3855. TRUE falls ein Speicherblock der Größe "size"
  3856. für die Zuweisung verfügbar ist.
  3857.  
  3858. Zurück zum Modul {Storage}
  3859.  
  3860. .topic Strings
  3861.  
  3862.   MODULE Strings ▄
  3863.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3864.  
  3865. Ein String ist ein ARRAY OF CHAR.
  3866.  
  3867. Falls der String nicht komplett in das Array paßt,
  3868. wird er von dem Zeichen 0C abgeschlossen.
  3869.  
  3870. Im Modul Strings sind folgende Prozeduren definiert:
  3871.  
  3872.  {Append}      {Assign}
  3873.  {CompareStr}  {Concat}
  3874.  {Copy}        {Delete:Strings_Delete}
  3875.  {Insert}      {Length:Strings_Length}
  3876.  {Pos}
  3877.  
  3878.  
  3879. Zurück zum {Index} oder zu {Routinen}, Ende mit ESC
  3880.  
  3881. .topic CompareStr
  3882.  
  3883.   Strings.CompareStr ▄
  3884.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3885.  
  3886.  PROCEDURE CompareStr(s1, s2: ARRAY OF CHAR): INTEGER;
  3887.  
  3888. Vergleicht zwei Zeichenketten s1 und s2.
  3889.  
  3890.  Rückgabe:
  3891.      0 falls s1 ═ s2
  3892.     -1 falls s1 < s2
  3893.     +1 falls s1 > s2
  3894.  
  3895. Zurück zum Modul {Strings}.
  3896.  
  3897. .topic Assign
  3898.  
  3899.   Strings.Assign ▄
  3900.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3901.  
  3902.  PROCEDURE Assign(VAR source, dest: ARRAY OF CHAR);
  3903.  
  3904. kopiert den String "source" nach "dest".
  3905.  
  3906. Zurück zum Modul {Strings}.
  3907.  
  3908. .topic Strings_Length
  3909.  
  3910.   Strings.Length ▄
  3911.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3912.  
  3913.  PROCEDURE Length(s :ARRAY OF CHAR ): CARDINAL;
  3914.  
  3915. Liefert die Länge der Zeichenkette "s" zurück.
  3916.  
  3917. Zurück zum Modul {Strings} oder zur {Length}-Übersicht.
  3918.  
  3919. .topic Concat
  3920.  
  3921.   Strings.Concat ▄
  3922.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3923.  
  3924.  PROCEDURE Concat(s1, s2: ARRAY OF CHAR;
  3925.               VAR result: ARRAY OF CHAR);
  3926.  
  3927. Hängt die Zeichenkette "s2" an "s1" und liefert das
  3928. Ergebnis in "result" zurück.
  3929.  
  3930. Siehe auch {Append}.
  3931.  
  3932. Zurück zum Modul {Strings}.
  3933.  
  3934. .topic Pos
  3935.  
  3936.   Strings.Pos ▄
  3937.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3938.  
  3939. PROCEDURE Pos(subs, s: ARRAY OF CHAR): CARDINAL;
  3940.  
  3941. Sucht den SubString "subs" in "s" und liefert die Position zurück.
  3942.  
  3943. Rückgabe:
  3944.  
  3945. Index des ersten Austretens von "subs" in "s"
  3946. oder > HIGH(s) falls kein passender Bereich
  3947. gefunden wurde.
  3948.  
  3949. Zurück zum Modul {Strings}.
  3950.  
  3951. .topic Strings_Delete
  3952.  
  3953.   Strings.Delete ▄
  3954.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3955.  
  3956.  PROCEDURE Delete(VAR s: ARRAY OF CHAR;
  3957.                pos, len: CARDINAL);
  3958.  
  3959. Löscht "len" Zeichen aus der Zeichenkette "s" ab der Position "pos".
  3960.  
  3961. Zurück zum Modul {Strings} oder zur {Delete}-Übersicht.
  3962.  
  3963. .topic Copy
  3964.  
  3965.   Strings.Copy ▄
  3966.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3967.  
  3968.  PROCEDURE Copy(src: ARRAY OF CHAR;
  3969.            pos, len: CARDINAL;
  3970.            VAR dest: ARRAY OF CHAR);
  3971.  
  3972. Kopiert "len" Zeichen ab der Position "pos" von "src" nach "dest".
  3973.  
  3974. Zurück zum Modul {Strings}.
  3975.  
  3976. .topic Append
  3977.  
  3978.   Strings.Append ▄
  3979.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3980.  
  3981. PROCEDURE Append(VAR s1: ARRAY OF CHAR;
  3982.                      s2: ARRAY OF CHAR);
  3983.  
  3984. Hängt s2 an das Ende von s1.
  3985.  
  3986. Die Prozedur arbeitet äquivalent zu {Concat}(s1, s2, s1)
  3987. aber klarer und effizienter.
  3988.  
  3989.  
  3990. Zurück zum Modul {Strings}.
  3991.  
  3992. .topic Insert
  3993.  
  3994.   Strings.Insert ▄
  3995.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  3996.  
  3997. PROCEDURE Insert(subs: ARRAY OF CHAR;
  3998.                 VAR s: ARRAY OF CHAR;
  3999.                    at: CARDINAL);
  4000.  
  4001. Fügt den Substring "subs" an der
  4002. Position "at" in den String "s" ein.
  4003.  
  4004.  
  4005. Zurück zum Modul {Strings}.
  4006.  
  4007. .topic TermBase
  4008.  
  4009.   MODULE TermBase ▄
  4010.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4011.  
  4012. Das Modul {Terminal} erledigt die Arbeit der Prozeduren
  4013. KeyPressed, Read, Write und Goto über dieses Modul.
  4014.  
  4015. Durch das Überschreiben der Methoden AssignRead, AssignWrite
  4016. und AssignGoto mit effizienteren kann der Benutzer
  4017. die Ein- und Ausgaben selbst wesentlich beschleunigen.
  4018.  
  4019.  TYPE
  4020.    {StatusProcedure} ═ PROCEDURE(): BOOLEAN;
  4021.    {ReadProcedure}   ═ PROCEDURE(VAR CHAR);
  4022.    {WriteProcedure}  ═ PROCEDURE(CHAR);
  4023.    {GotoProcedure}   ═ PROCEDURE(CARDINAL, CARDINAL);
  4024.  
  4025.  
  4026.  definierte Prozeduren:
  4027.  
  4028.  {AssignGoto}     {AssignRead}
  4029.  {AssignWrite}    {Goto:TermBase_Goto}
  4030.  {KeyPressed:TermBase_KeyPressed}     {Read:TermBase_Read}
  4031.  {UnAssignGoto}   {UnAssignRead}
  4032.  {UnAssignWrite}  {Write:TermBase_Write}
  4033.  
  4034. Zurück zum {Index} oder zu {Routinen}, Ende mit ESC
  4035.  
  4036. .topic StatusProcedure
  4037.  
  4038.   TermBase.StatusProcedure
  4039.  ─────────────────────────┘
  4040.  
  4041.  TYPE
  4042.    StatusProcedure ═ PROCEDURE(): BOOLEAN;
  4043.  
  4044. Zurück zum Modul {TermBase}.
  4045.  
  4046. .topic ReadProcedure
  4047.  
  4048.   TermBase.ReadProcedure
  4049.  ───────────────────────┘
  4050.  TYPE
  4051.    ReadProcedure ═ PROCEDURE(VAR CHAR);
  4052.  
  4053. Zurück zum Modul {TermBase}.
  4054.  
  4055. .topic WriteProcedure
  4056.  
  4057.   TermBase.WriteProcedure
  4058.  ────────────────────────┘
  4059.  TYPE
  4060.    WriteProcedure  ═ PROCEDURE(CHAR);
  4061.  
  4062.  
  4063. Zurück zum Modul {TermBase}.
  4064.  
  4065. .topic GotoProcedure
  4066.  
  4067.   TermBase.GotoProcedure
  4068.  ───────────────────────┘
  4069.  TYPE
  4070.    GotoProcedure ═ PROCEDURE(CARDINAL, CARDINAL);
  4071.  
  4072.  
  4073. Zurück zum Modul {TermBase}.
  4074.  
  4075. .topic AssignRead
  4076.  
  4077.   TermBase.AssignRead ▄
  4078.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4079.  
  4080.  PROCEDURE AssignRead(rp: ReadProcedure;
  4081.                       sp: StatusProcedure;
  4082.                 VAR done: BOOLEAN);
  4083.  
  4084. Sichert die aktuelle Read- und KeyPressed-Prozeduren
  4085. in einem Prozedur-Stack und installiert die stattdessen
  4086. zu benutzende neue Prozedur.
  4087.  
  4088. Zurück zum Modul {TermBase}.
  4089.  
  4090. .topic AssignWrite
  4091.  
  4092.   TermBase.AssignWrite ▄
  4093.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4094.  
  4095.  PROCEDURE AssignWrite(wp: WriteProcedure;
  4096.                  VAR done: BOOLEAN);
  4097.  
  4098. Sichert die aktuelle Write-Prozedur in einem
  4099. Prozedur-Stack und installiert stattdessen die
  4100. zu benutzende neue Prozedur.
  4101.  
  4102.  
  4103. Zurück zum Modul {TermBase}.
  4104.  
  4105. .topic UnAssignRead
  4106.  
  4107.   TermBase.UnAssignRead ▄
  4108.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4109.  
  4110.  PROCEDURE UnAssignRead(VAR done :BOOLEAN);
  4111.  
  4112. Poppt die von {AssignRead} auf den Prozedur-Stack
  4113. geschriebenen Read- und KeyPressed-Prozeduren zurück
  4114. und macht sie wieder aktiv.
  4115.  
  4116.  
  4117. Zurück zum Modul {TermBase}.
  4118.  
  4119. .topic UnAssignWrite
  4120.  
  4121.   TermBase.UnAssignWrite ▄
  4122.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4123.  
  4124.  PROCEDURE UnAssignWrite(VAR done: BOOLEAN);
  4125.  
  4126. Poppt die von {AssignWrite} auf den Prozedur-Stack
  4127. geschriebene Write-Prozedur zurück und macht
  4128. sie wieder aktiv.
  4129.  
  4130. Zurück zum Modul {TermBase}.
  4131.  
  4132. .topic TermBase_KeyPressed
  4133.  
  4134.   TermBase.Keypressed() ▄
  4135.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4136.  
  4137.  PROCEDURE KeyPressed(): BOOLEAN;
  4138.  
  4139. Fordert den derzeit installierten KeyPressed-Service an.
  4140.  
  4141. Während der Initialisierung von TermBase ist
  4142. {TermIO.KeyPressed:TermIO_KeyPressed} aktiv.
  4143.  
  4144. Zurück zum Modul {TermBase} oder zur {KeyPressed}-Übersicht.
  4145.  
  4146. .topic TermBase_Read
  4147.  
  4148.   TermBase.Read  ▄
  4149.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4150.  
  4151.  PROCEDURE Read(VAR ch: CHAR);
  4152.  
  4153. Fordert die derzeit installierte Read-Prozedur an.
  4154.  
  4155. Während der Initialisierung von TermBase ist
  4156. {TermIO.Read:TermIO_Read} aktiv.
  4157.  
  4158. Zurück zum Modul {TermBase} oder zur {Read}-Übersicht.
  4159.  
  4160. .topic TermBase_Write
  4161.  
  4162.   TermBase.Write ▄
  4163.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4164.  
  4165.  PROCEDURE Write(ch: CHAR);
  4166.  
  4167. Fordert die derzeit installierte Write-Prozedur an.
  4168.  
  4169. Während der Initialisierung von TermBase ist
  4170. {TermIO.Write:TermIO_Write} aktiv.
  4171.  
  4172. Zurück zum Modul {TermBase} oder zur {Write}-Übersicht.
  4173.  
  4174. .topic AssignGoto
  4175.  
  4176.   TermBase.AssignGoto ▄
  4177.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4178.  
  4179.  PROCEDURE AssignGoto(gp: GotoProcedure;
  4180.                 VAR done: BOOLEAN);
  4181.  
  4182. Sichert die aktuelle {Goto}-Prozedur in
  4183. einem Prozedur-Stack und installiert die
  4184. stattdessen zu benutzende neue Prozedur.
  4185.  
  4186.  
  4187. Zurück zum Modul {TermBase}.
  4188.  
  4189. .topic UnAssignGoto
  4190.  
  4191.   TermBase.UnAssignGoto ▄
  4192.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4193.  
  4194.  PROCEDURE UnAssignGoto(VAR done: BOOLEAN);
  4195.  
  4196. Poppt die von {AssignGoto} auf den
  4197. Prozedur-Stack geschriebene Goto-Prozedur
  4198. zurück und aktiviert sie erneut.
  4199.  
  4200. Zurück zum Modul {TermBase}.
  4201.  
  4202. .topic TermBase_Goto
  4203.  
  4204.   TermBase.Goto ▄
  4205.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4206.  
  4207.  PROCEDURE Goto(line, pos: CARDINAL);
  4208.  
  4209. Ruft die aktuell installierte Goto-Prozedur auf.
  4210.  
  4211. Während der Initialisierung von TermBase
  4212. ist {TermIO.Goto:TermIO_Goto} installiert.
  4213.  
  4214. Zurück zum Modul {TermBase} oder zur {Goto}-Übersicht.
  4215.  
  4216. .topic Terminal
  4217.  
  4218.   MODULE Terminal ▄
  4219.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4220.  
  4221. Die gesamten aktuellen Ein- und Ausgaben
  4222. verwenden Prozeduren des Moduls {TermBase}.
  4223. Das aufrufende Programm kann ebenso direkt
  4224. die Prozeduren aus TermBase verwenden.
  4225.  
  4226. In Terminal definierte Prozeduren:
  4227.  
  4228.  {ClrScreen :ClrScreen}   {Goto     :Terminal_Goto}
  4229.  {KeyPressed:Terminal_KeyPressed}   {Read     :Terminal_Read}
  4230.  {ReadLine  :Terminal_ReadLine}   {ReadAgain}
  4231.  {Write     :Terminal_Write}   {WriteString:Terminal_WriteString}
  4232.  {WriteLn   :Terminal_WriteLn}   {WriteLine:Terminal_WriteLine}
  4233.  
  4234. Zurück zum {Index} oder zu {Routinen}, Ende mit ESC
  4235.  
  4236. .topic Terminal_KeyPressed
  4237.  
  4238.   Terminal.KeyPressed ▄
  4239.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4240.  
  4241.  PROCEDURE KeyPressed(): BOOLEAN;
  4242.  
  4243. Die Prozedur gibt {TRUE} zurück, wenn eine
  4244. Taste gedrückt wurde; sonst wird {FALSE} gemeldet.
  4245.  
  4246. Zurück zum Modul {Terminal} oder zur {KeyPressed}-Übersicht.
  4247.  
  4248. .topic Terminal_Read
  4249.  
  4250.   Terminal.Read ▄
  4251.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4252.  
  4253.  PROCEDURE Read(VAR ch: CHAR);
  4254.  
  4255. Liefert das nächste eingegebene Zeichen.
  4256. Hierzu wird {TermBase.Read:TermBase_Read} verwendet.
  4257.  
  4258. Zurück zum Modul {Terminal} oder zur {Read}-Übersicht.
  4259.  
  4260. .topic Terminal_ReadLine
  4261.  
  4262.   Terminal.ReadLine ▄
  4263.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4264.  
  4265.  PROCEDURE ReadLine(VAR string:
  4266.                 ARRAY OF CHAR);
  4267.  
  4268. Lese eine ganze Zeile mithilfe von {Read:Terminal_Read}
  4269. mit Echo mit Ausnahme des Abschlußzeichens (EOL oder ESC).
  4270.  
  4271. {ASCII}.BS} löscht das letzte gelesene Zeichen.
  4272.  
  4273. {ASCII}.DEL löscht alle Zeichen.
  4274.  
  4275. {ASCII}.ESC} löscht alle Zeichen und bricht die Eingabe ab.
  4276.  
  4277. {ReadAgain}, gefolgt von {Read:Terminal_Read} kann
  4278. benutzt werden, um das abschließende Zeichen zu ermitteln (EOL oder ESC).
  4279.  
  4280. Zurück zum Modul {Terminal} oder zur {ReadLine}-Übersicht.
  4281.  
  4282. .topic ReadAgain
  4283.  
  4284.   Terminal.ReadAgain ▄
  4285.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4286.  
  4287.  PROCEDURE ReadAgain;
  4288.  
  4289. Erzwingt beim nächsten Aufruf von Read das zuletzt
  4290. gelesene Zeichen nochmals zurückzugeben.
  4291.  
  4292. Zurück zum Modul {Terminal}.
  4293.  
  4294. .topic Terminal_Write
  4295.  
  4296.   Terminal.Write ▄
  4297.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4298.  
  4299.  PROCEDURE Write(ch: CHAR);
  4300.  
  4301. Schreibt "ch" mithilfe von {TermBase.Write:TermBase_Write}
  4302. in die Standardausgabe.
  4303.  
  4304. Zurück zum Modul {Terminal} oder zur {Write}-Übersicht.
  4305.  
  4306. .topic Terminal_WriteString
  4307.  
  4308.   Terminal.WriteString ▄
  4309.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4310.  
  4311.  PROCEDURE WriteString(string: ARRAY OF CHAR);
  4312.  
  4313. Schreibt unter Benutzung von {Terminal.Write:Terminal_Write}
  4314. eine Zeichenkette "string" an die Standardausgabe.
  4315.  
  4316. Zurück zum Modul {Terminal} oder zur {WriteString}-Übersicht.
  4317.  
  4318. .topic Terminal_WriteLn
  4319.  
  4320.   Terminal.WriteLn ▄
  4321.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4322.  
  4323.  PROCEDURE WriteLn;
  4324.  
  4325. Identisch mit: Write(ASCII.EOL).
  4326.  
  4327. Zurück zum Modul {Terminal} oder zur {WriteLn}-Übersicht.
  4328.  
  4329. .topic ClrScreen
  4330.  
  4331.   Terminal.ClrScreen ▄
  4332.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4333.  
  4334.   PROCEDURE ClrScreen;
  4335.  
  4336. Identisch zu {Write}({ASCII}.FF).
  4337. Die Prozedur benötigt ANSI.SYS!
  4338.  
  4339. Zurück zum Modul {Terminal}.
  4340.  
  4341. .topic Terminal_Goto
  4342.  
  4343.   Terminal.Goto ▄
  4344.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4345.  
  4346.  PROCEDURE Goto(line, pos: CARDINAL);
  4347.  
  4348. Die Prozedur ruft {TermBase.Goto:TermBase_Goto}(line, pos) auf.
  4349.  
  4350. Zurück zum Modul {Terminal} oder zur {Goto}-Übersicht.
  4351.  
  4352. .topic Terminal_WriteLine
  4353.  
  4354.    Terminal.WriteLine ▄
  4355.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4356.  
  4357.  PROCEDURE WriteLine(string: ARRAY OF CHAR);
  4358.  
  4359.  Identisch mit:
  4360.   {WriteString:Terminal_WriteString}(string);
  4361.   {WriteLn:Terminal_WriteLn};
  4362.  
  4363. Zurück zum Modul {Terminal} oder zur {WriteLine}-Übersicht.
  4364.  
  4365. .topic TermIO
  4366.  
  4367.   MODULE TermIO ▄
  4368.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4369.  
  4370. Die Prozeduren dieses Moduls sind die
  4371. Standard Ein- und Ausgabe-Routinen,
  4372. die vom Modul {TermBase:TermBase} genutzt werden.
  4373. Die Prozeduren des Moduls rufen die
  4374. DOS-Funktionen 2, 8 und 0BH auf.
  4375.  
  4376. Für die Bildschirm-Löschroutinen und Goto-Funktion
  4377. muß ANSI.SYS installiert sein!
  4378.  
  4379. In TermIO definierte Prozeduren:
  4380.  
  4381.  {Read      :TermIO_Read}
  4382.  {Write     :TermIO_Write}
  4383.  {KeyPressed:TermIO_KeyPressed}
  4384.  {Goto      :TermIO_Goto}
  4385.  
  4386. Zurück zum {Index} oder zu {Routinen}, Ende mit ESC
  4387.  
  4388. .topic TermIO_Read
  4389.  
  4390.   TermIO.Read ▄
  4391.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4392.  
  4393.  PROCEDURE Read(VAR ch: CHAR);
  4394.  
  4395. Wartet, bis ein Zeichen für das Lesen aus der
  4396. Tastatur bereit steht und liest es dann.
  4397. Das Zeichen wird nicht auf dem Bildschirm angezeigt.
  4398.  
  4399. {ASCII}.CR wird nach {ASCII}.EOL konvertiert.
  4400.  
  4401. Zurück zum Modul {TermIO} oder zur {Read}-Übersicht.
  4402.  
  4403. .topic TermIO_Write
  4404.  
  4405.   TermIO.Write ▄
  4406.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4407.  
  4408.  PROCEDURE Write(ch: CHAR);
  4409.  
  4410. Schreibt ch auf den Bildschirm.
  4411.  
  4412. ■ ASCII.FF löscht den Bildschirm (ANSI.SYS muß installiert sein)
  4413.  
  4414. ■ ASCII.EOL erzeugt auf dem Bildschirm die Ausgabe von CR LF.
  4415.  
  4416. ■ ASCII.DEL erzeugt einen zerstörerischen Backspace.
  4417.  
  4418. Zurück zum Modul {TermIO} oder zur {Write}-Übersicht.
  4419.  
  4420. .topic TermIO_KeyPressed
  4421.  
  4422.   TermIO.KeyPressed ▄
  4423.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4424.  
  4425.  PROCEDURE KeyPressed() :BOOLEAN;
  4426.  
  4427. Gibt TRUE zurück, wenn im Tastaturpuffer ein Zeichen anliegt.
  4428.  
  4429. Zurück zum Modul {TermIO} oder zur {KeyPressed}-Übersicht.
  4430.  
  4431. .topic TermIO_Goto
  4432.  
  4433.   TermIO.Goto ▄
  4434.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4435.  PROCEDURE Goto(line, pos: CARDINAL);
  4436.  
  4437. Positioniert den Cursor an line/pos. Es wird ANSI.SYS benötigt!
  4438.  
  4439. Zurück zum Modul {TermIO} oder zu {Goto}-Übersicht.
  4440.  
  4441. .topic Display
  4442.  
  4443.   MODULE Display ▄
  4444.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4445.  
  4446. TYPE
  4447.   {DisplayBuffer} ═ ARRAY [0..24]
  4448.                OF ARRAY [0..79] OF CARDINAL;
  4449.  
  4450. VAR
  4451.   {line0}:         CARDINAL;
  4452.   {col0}:          CARDINAL;
  4453.   {lineN}:         CARDINAL;
  4454.   {colN}:          CARDINAL;
  4455.   {snowy}:         BOOLEAN;
  4456.   {displayMode}:   CARDINAL;
  4457.   {displayPage}:   CARDINAL;
  4458.   {displayAttr}:   CARDINAL;
  4459.   {displayLines}:  CARDINAL;
  4460.   {displayCols}:   CARDINAL;
  4461.   {displayPtr}:    POINTER TO DisplayBuffer;
  4462.  
  4463.  definierte Prozeduren:
  4464.  
  4465.   {GetDisplayMode}    {SetDisplayMode}
  4466.   {SetCursorType}     {GetCursorPosition}
  4467.   {SetCursorPosition} {ScrollUp}
  4468.   {ScrollDown}        {ReadCharAttr}
  4469.   {WriteCharAttr}     {WriteChar:Display_WriteChar}
  4470.   {ClrEOL}            {Goto:Display_Goto}
  4471.   {ClrEOS}            {Write:Display_Write}
  4472.   {DisplayString}     {DisplayLine}
  4473.   {WriteScreen}       {ReadScreen}
  4474.  
  4475. Zurück zum {Index} oder zu {Routinen}, Ende mit ESC
  4476.  
  4477. .topic displayMode
  4478.  
  4479.   Display.displayMode
  4480.  ─────────────────────┘
  4481.  VAR
  4482.    displayMode: CARDINAL;
  4483.  
  4484. Wird beim Aufruf mit dem aktuellen Bildschirmmodus initialisiert.
  4485.  
  4486. Zurück zum Modul {Display}
  4487.  
  4488. .topic displayPage
  4489.  
  4490.   Display.displayPage
  4491.  ─────────────────────┘
  4492.  VAR
  4493.    displayPage :CARDINAL;
  4494.  
  4495. Die Bildschirmseite.
  4496.  
  4497. Wird abhängig vom aktuellen Bildschirmmodus initialisiert.
  4498.  
  4499. Zurück zum Modul {Display}
  4500.  
  4501. .topic displayAttr
  4502.  
  4503.   Display.displayAttr
  4504.  ─────────────────────┘
  4505.  
  4506.   VAR
  4507.     displayAttr :CARDINAL;
  4508.  
  4509. Das Bildschirmattribut. Wird mit 07H initialisiert.
  4510.  
  4511. Zurück zum Modul {Display}
  4512.  
  4513. .topic displayLines
  4514.  
  4515.   Display.displayLines
  4516.  ──────────────────────┘
  4517.  
  4518.   VAR
  4519.     displayLines:CARDINAL;
  4520.  
  4521. Die Anzahl der Bildschirmzeilen. Wird auf 25 initialisiert.
  4522.  
  4523. Zurück zum Modul {Display}
  4524.  
  4525. .topic displayCols
  4526.  
  4527.   Display.displayCols
  4528.  ─────────────────────┘
  4529.  
  4530.   VAR
  4531.     displayCols :CARDINAL;
  4532.  
  4533. Die Anzahl der Bildschirmfarben.
  4534.  
  4535. Wird abhängig vom aktuellen Bildschirmmodus initialisiert.
  4536.  
  4537. Zurück zum Modul {Display}
  4538.  
  4539. .topic snowy
  4540.  
  4541.   Display.snowy
  4542.  ───────────────┘
  4543.  
  4544.   VAR
  4545.     snowy       :BOOLEAN;
  4546.  
  4547. Die Variable dient der Überprüfung von "Schneetreiben" auf dem Bildschirm.
  4548. Wenn TRUE: Warte auf Bildschirm-Retrace.
  4549.  
  4550. snowy wird automatisch auf TRUE gesetzt, wenn der Bildschirmmodus <> 7 ist.
  4551.  
  4552. Zurück zum Modul {Display}
  4553.  
  4554. .topic line0, col0, lineN, colN
  4555.  
  4556.    aktuelle Fensterkoordinaten
  4557.   ─────────────────────────────┘
  4558.  
  4559.  VAR
  4560.    line0: CARDINAL;
  4561.           oberste Zeile, Startwert 0
  4562.  
  4563.    col0:  CARDINAL;
  4564.           Spalte links, Startwert 0
  4565.  
  4566.    lineN: CARDINAL;
  4567.           letzte Zeile im Fenster
  4568.  
  4569.    colN:  CARDINAL;
  4570.           letzte Spalte im Fenster
  4571.  
  4572. Zurück zum Modul {Display}
  4573.  
  4574. .topic displayPtr
  4575.  
  4576.   Display.displayPtr
  4577.  ────────────────────┘
  4578.  
  4579. Zeiger auf den Bildschirmpuffer.
  4580. Wird zur Initialisierungszeit geladen.
  4581.  
  4582.  TYPE
  4583.    DisplayBuffer ═ ARRAY [0..24] OF
  4584.                    ARRAY [0..79] OF CARDINAL;
  4585.  
  4586.  VAR
  4587.    displayPtr: POINTER TO DisplayBuffer;
  4588.  
  4589. Zurück zum Modul {Display}
  4590.  
  4591. .topic GetDisplayMode
  4592.  
  4593.   Display.GetDisplayMode ▄
  4594.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4595.  
  4596.  PROCEDURE GetDisplayMode(VAR mode, nCols,
  4597.                     activePage: CARDINAL);
  4598.  
  4599.  
  4600. Gibt den aktuellen Bildschirmmodus zurück.
  4601.  
  4602. BIOS Interface-Routine.
  4603.  
  4604. Zurück zum Modul {Display}
  4605.  
  4606. .topic SetDisplayMode
  4607.  
  4608.   Display.SetDisplayMode ▄
  4609.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4610.  
  4611. PROCEDURE SetDisplayMode(mode: CARDINAL);
  4612.  
  4613. Setzt den Bildschirm-Modus.
  4614.  
  4615. BIOS Interface-Routine.
  4616.  
  4617. Zurück zum Modul {Display}
  4618.  
  4619. .topic SetCursorType
  4620.  
  4621.   Display.SetCursorType ▄
  4622.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4623.  
  4624.  PROCEDURE SetCursorType(start, end: CARDINAL );
  4625.  
  4626. Setzt die Cursor Start- und Endzeile.
  4627.  
  4628. BIOS Interface-Routine.
  4629.  
  4630. Zurück zum Modul {Display}
  4631.  
  4632. .topic GetCursorPosition
  4633.  
  4634.   Display.GetCursorPosition ▄
  4635.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4636.  
  4637.  PROCEDURE GetCursorPosition(VAR line: CARDINAL;
  4638.                              VAR pos: CARDINAL);
  4639.  
  4640. Meldet die aktuelle Cursorposition zurück.
  4641.  
  4642. BIOS Interface-Routine.
  4643.  
  4644. Zurück zum Modul {Display}
  4645.  
  4646. .topic SetCursorPosition
  4647.  
  4648.   Display.SetCursorPosition ▄
  4649.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4650.  
  4651.  PROCEDURE SetCursorPosition(line: CARDINAL;
  4652.                               pos: CARDINAL);
  4653.  
  4654. Bewegt den Cursor nach line/pos.
  4655.  
  4656. BIOS Interface-Routine.
  4657.  
  4658. Siehe auch bei der {Goto}-Übersicht.
  4659. Zurück zum Modul {Display}.
  4660.  
  4661. .topic ScrollUp
  4662.  
  4663.   Display.ScrollUp ▄
  4664.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4665.  PROCEDURE ScrollUp(n,
  4666.           line1, pos1,
  4667.           line2, pos2: CARDINAL;
  4668.                  attr: CARDINAL);
  4669.  
  4670. Scrollt das Fenster um n Zeilen nach oben.
  4671.  
  4672. ■ line1, pos1 ═ linke obere Ecke des Scrollfensters.
  4673.  
  4674. ■ line2, pos2 ═ rechte untere Ecke des Scrollfensters.
  4675.  
  4676. ■ attr        = Farbattribut für neue Leerzeilen.
  4677.  
  4678. ■ Falls n ═ 0 ist, wird das Fenster gelöscht.
  4679.  
  4680. BIOS Interface-Routine.
  4681.  
  4682. Siehe auch {ScrollDown}
  4683.  
  4684. Zurück zum Modul {Display}
  4685.  
  4686. .topic ScrollDown
  4687.  
  4688.   Display.ScrollDown ▄
  4689.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4690.  
  4691.  PROCEDURE ScrollDown(n,
  4692.             line1, pos1,
  4693.             line2, pos2: CARDINAL;
  4694.                    attr: CARDINAL);
  4695.  
  4696. Scrollt ein Window Scrolls um "n" Zeilen nach unten.
  4697.  
  4698. BIOS Interface-Routine.
  4699. Für die Beschreibung der Variablen siehe {ScrollUp}
  4700.  
  4701. Zurück zum Modul {Display}
  4702.  
  4703. .topic ReadCharAttr
  4704.  
  4705.   Display.ReadCharAttr ▄
  4706.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4707.  
  4708.  PROCEDURE ReadCharAttr(VAR ch: CHAR;
  4709.                       VAR attr: CARDINAL);
  4710.  
  4711. Liest das Zeichen und Bildschirmattribut unter dem Cursor.
  4712.  
  4713. BIOS Interface-Routine.
  4714.  
  4715. Zurück zum Modul {Display}
  4716.  
  4717. .topic WriteCharAttr
  4718.  
  4719.   Display.WriteCharAttr ▄
  4720.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4721.  
  4722.  PROCEDURE WriteCharAttr(ch: CHAR;
  4723.                        attr: CARDINAL);
  4724.  
  4725. Schreibt das Zeichen "ch" und das Bildschirm-Attribut
  4726. "attr" an die aktuelle Cursorposition.
  4727. Der Cursor wird nicht bewegt.
  4728.  
  4729. BIOS Interface-Routine.
  4730.  
  4731. Zurück zum Modul {Display}
  4732.  
  4733. .topic Display_WriteChar
  4734.  
  4735.   Display.WriteChar ▄
  4736.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4737.  
  4738.  PROCEDURE WriteChar(ch: CHAR);
  4739.  
  4740. Schreibt das Zeichen ch an die aktuelle Cursorposition.
  4741.  
  4742. BIOS Interface-Routine.
  4743.  
  4744. Zurück zum Modul {Display} oder zur {WriteChar}-Übersicht.
  4745.  
  4746. .topic Display_Goto
  4747.  
  4748.   Display.Goto ▄
  4749.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4750.  
  4751.  PROCEDURE Goto(line, col: CARDINAL);
  4752.  
  4753. Bewegt den Cursor an line/pos innerhalb des 
  4754. von line0, col0 - lineN, colN definierten
  4755. aktuellen Fensters.
  4756.  
  4757. Zurück zum Modul {Display} oder zur {Goto}-Übersicht.
  4758.  
  4759. .topic Display_Write
  4760.  
  4761.   Display.Write ▄
  4762.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4763.  
  4764.  PROCEDURE Write(ch: CHAR);
  4765.  
  4766. Schreibt ein Zeichen an die aktuelle Bildschirmposition,
  4767. für die Farbe wird displayAttr verwendet.
  4768. Der Cursor wird weiterbewegt.
  4769. Die Prozedur arbeitet innerhalb der von line0, col0 - lineN, colN
  4770. definierten Fenster-Koordinaten.
  4771.  
  4772. Die folgenden Steuerzeichen werden ausgeführt:
  4773.  
  4774.  BEL, EOL, CR, LF, FF, DEL, BS, HT.
  4775.  
  4776. Zurück zum Modul {Display} oder zur {Write}-Übersicht.
  4777.  
  4778. .topic ClrEOL
  4779.  
  4780.   Display.ClrEOL ▄
  4781.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4782.  
  4783.  PROCEDURE ClrEOL;
  4784.  
  4785. Löscht bis zum Zeilenende.
  4786. Hierzu wird {displayAttr} benutzt.
  4787.  
  4788. Die Prozedur arbeitet in den Grenzen des aktuellen Windows.
  4789.  
  4790. Zurück zum Modul {Display}.
  4791.  
  4792. .topic ClrEOS
  4793.  
  4794.   Display.ClrEOS ▄
  4795.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4796.  
  4797.   PROCEDURE ClrEOS;
  4798.  
  4799. Löscht bis zum Ende des aktuellen Windows.
  4800. Hierzu wird {displayAttr} benutzt.
  4801.  
  4802. Zurück zum Modul {Display}.
  4803.  
  4804. .topic DisplayString
  4805.  
  4806.   Display.DisplayString ▄
  4807.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4808.  
  4809.  PROCEDURE DisplayString(s: ARRAY OF CHAR;
  4810.                  line, pos: CARDINAL;
  4811.                       attr: CARDINAL);
  4812.  
  4813. Die Prozedur schreibt eine Zeichenkette direkt in den Bildschirmpuffer.
  4814.  
  4815. "line" und "pos" beziehen sich auf die relativen Koordinaten
  4816. des aktuellen Bildschirmfensters (Window).
  4817. Der Cursor wird NICHT weiterbewegt und Steuerzeichen
  4818. werden NICHT ausgeführt.
  4819.  
  4820. DisplayString arbeitet in den Fensterkoordinaten,
  4821. wie sie in {line0}, {col0} - {lineN}, {colN} festgelegt sind.
  4822. Die Prozedur arbeitet nur im Textmodus. Sie ist sehr schnell,
  4823. da direkt in den Bildschirmspeicher geschrieben wird.
  4824.  
  4825. Zurück zum Modul {Display}
  4826.  
  4827. .topic DisplayLine
  4828.  
  4829.   Display.DisplayLine ▄
  4830.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4831.  
  4832.  PROCEDURE DisplayLine(line: ARRAY OF CHAR;
  4833.                      lineno: CARDINAL;
  4834.                        attr: CARDINAL);
  4835.  
  4836. Schreibt eine 80 Zeichen lange Zeile direkt in den Bildschirmspeicher.
  4837. "attr" das zu verwendende Bildschirmattribut (Farbe).
  4838. Falls die Länge des Strings kleiner als 80 ist, wird
  4839. der Rest mit Leerzeichen aufgefüllt.
  4840.  
  4841. Die Prozedur arbeitet in den Fensterkoordinaten,
  4842. wie sie in {line0}, {col0} - {lineN}, {colN} festgelegt sind.
  4843. Sie arbeitet nur im Textmodus. Sie ist sehr schnell,
  4844. da direkt in den Bildschirmspeicher geschrieben wird.
  4845.  
  4846. Zurück zum Modul {Display}
  4847.  
  4848. .topic WriteScreen
  4849.  
  4850.   Display.WriteScreen ▄
  4851.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4852.  
  4853.  PROCEDURE WriteScreen(src, dest: ADDRESS;
  4854.                           nWords: CARDINAL);
  4855.  
  4856. Bewegt "nWords" "src" nach "dest".
  4857.  
  4858. dest muß innerhalb des Bildschirmspeichers liegen.
  4859. Falls {snowy} auf TRUE gesetzt ist, wird das
  4860. vertikale Retrace-Signal des Monitors berücksichtigt.
  4861.  
  4862. Zurück zum Modul {Display}
  4863.  
  4864. .topic ReadScreen
  4865.  
  4866.   Display.ReadScreen ▄
  4867.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4868.  
  4869.  PROCEDURE ReadScreen(src, dest: ADDRESS;
  4870.                          nWords: CARDINAL);
  4871.    
  4872. Bewegt "nWords" "src" nach "dest".
  4873. "src" muß sich innerhalb des Bildschirmspeichers befinden.
  4874. Falls {snowy} ═ TRUE gesetzt ist, wird
  4875. das vertikale Retrace-Signal des Monitors berücksichtigt.
  4876.  
  4877. Die Prozedur arbeitet im Rahmen des aktuellen Bildschirmfensters.
  4878.  
  4879. Zurück zum Modul {Display}
  4880.  
  4881. .topic DisplayBuffer
  4882.  
  4883.    Display.Buffer
  4884.  ═════════════════╝
  4885.  
  4886.  TYPE
  4887.    DisplayBuffer ═ ARRAY [0..24] OF
  4888.                    ARRAY [0..79] OF CARDINAL;
  4889.  VAR
  4890.    {displayPtr}: POINTER TO DisplayBuffer;
  4891.  
  4892. Die Variable wird zu Initialisierungszeit geladen.
  4893.  
  4894. Zurück zum Modul {Display}
  4895.  
  4896. .topic Windows
  4897.  
  4898.   MODULE Windows ▄
  4899.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4900.  
  4901. Das Modul stellt eine einfache Implementation von
  4902. Routinen für überlappende Text-Windows zur Verfügung.
  4903. Alle Prozeduren dieses Moduls erwarten, daß sich die
  4904. Bildschirmanzeige im Textmodus befindet.
  4905.  
  4906. Das Modul installiert die Prozeduren {Write} und {Goto}
  4907. aus dem Modul {Display} nach {TermBase}.
  4908.  
  4909.  definierter Typ:
  4910.  
  4911.   {Window}
  4912.  
  4913.  definierte Prozeduren:
  4914.  
  4915.   {OpenWindow}      {SelectWindow}
  4916.   {CloseWindow}     {CloseCurWindow}
  4917.   {NewWindowTitle}
  4918.  
  4919. Zurück zum {Index} oder zu {Routinen}, Ende mit ESC
  4920.  
  4921. .topic Window
  4922.  
  4923.   Windows.Window
  4924.  ════════════════╝
  4925.  
  4926.  TYPE Window;
  4927.  
  4928. opaker Datentyp für die Steuerung der Fensterroutinen.
  4929.  
  4930. Zurück zum Modul {Windows}.
  4931.  
  4932. .topic OpenWindow
  4933.  
  4934.   Windows.OpenWindow ▄
  4935.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4936.  
  4937.  PROCEDURE OpenWindow(VAR w: Window;
  4938.              l1, c1, l2, c2: CARDINAL;
  4939.                       frame: BOOLEAN;
  4940.                      header: ARRAY OF CHAR);
  4941.  
  4942. Öffne ein neues Fenster mit der oberen linken
  4943. Ecke bei "l1", "c1" und der rechten unteren Ecke bei "l2", "c2".
  4944. Wenn die Variable "frame" TRUE ist, wird ein Rahmen um das
  4945. Window gezeichnet.
  4946. Die Fenster-Überschrift wird automatisch in der
  4947. obersten Fensterzeile zentriert.
  4948.  
  4949. Zurück zum Modul {Windows}.
  4950.  
  4951. .topic SelectWindow
  4952.  
  4953.   Windows.SelectWindow ▄
  4954.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4955.  
  4956.  PROCEDURE SelectWindow(w: Window;
  4957.                  mustSave: BOOLEAN);
  4958.  
  4959. Mache das Fenster "w" zum aktuellen Fenster,
  4960. indem "w" an den Top des Windowstack gelegt wird.
  4961.  
  4962. Die Variable "mustSave" dient dazu, schnellere
  4963. Fensterumschaltungen zu erlauben, wenn sich die
  4964. Fenster nicht überlappen.
  4965. Wenn "mustSave" {FALSE} ist, wird der Inhalt des
  4966. aktuellen Fensters nicht gesichert und der Inhalt
  4967. des neuen Fensters nicht restauriert
  4968.  
  4969. Zurück zum Modul {Windows}.
  4970.  
  4971. .topic CloseWindow
  4972.  
  4973.   Windows.CloseWindows ▄
  4974.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4975.  
  4976.  PROCEDURE CloseWindow(w: Window);
  4977.  
  4978. Schließe (zerstöre) Window "w".
  4979.  
  4980. Zurück zum Modul {Windows}.
  4981.  
  4982. .topic CloseCurWindow
  4983.  
  4984.   Windows.CloseCurWindows ▄
  4985.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4986.  
  4987.  PROCEDURE CloseCurWindow;
  4988.  
  4989. Schließe das oberste Fenster.
  4990. Das vorher aktive Window wird zum aktuellen Fenster.
  4991.  
  4992. Zurück zum Modul {Windows}.
  4993.  
  4994. .topic NewWindowTitle
  4995.  
  4996.   Windows.NewWindowTitle ▄
  4997.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  4998.  
  4999.  PROCEDURE NewWindowTitle(header: ARRAY OF CHAR);
  5000.  
  5001. Zeigt einen neuen Fenstertitel an.
  5002.  
  5003. Zurück zum Modul {Windows}.
  5004.  
  5005. .topic Break
  5006.  
  5007.   MODULE Break ▄
  5008.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5009.  
  5010. Dieses Modul erlaubt dem Benutzer, den
  5011. Ctrl-Break (Vektor 1BH) und den von DOS generierten
  5012. Ctrl-C Interrupt (Vektor 23H) auszulösen oder zu sperren.
  5013. Bei der Initialisierung wird BREAK automatisch abgeschaltet.
  5014. Das Anwendungsprogramm muß {EnableBreak} aufrufen, um die
  5015. Verarbeitung von Abbruchtasten zuzulassen.
  5016. Der Breakinterrupt-Handler prüft das DOS Busy-Flag
  5017. um die Ausführung von Ctrl-Break während Aktivitäten
  5018. von DOS zu verhüten.
  5019. Der voreingestellte Break-Handler bricht einfach das
  5020. Programm mit einem ErrorLevel von 6 ab.
  5021. {DisableBreak} wird immer aufgerufen, bevor die
  5022. Kontrolle an eine benutzerdefinierte
  5023. Breakhandler-Routine übergeben wird.
  5024. Sollte die benutzerdefinierte Breakhandlerroutine ins
  5025. Programm zurückkehren, wird das Programm mit
  5026. einem Errorlevel von 6 beendet.
  5027.  
  5028. Benutzung:
  5029.  
  5030. Um zu verhindern, daß ein Benutzer das Programm mit Ctrl-Break oder Ctrl-C beendet, muß nur das Modul importiert werden.
  5031. Während der Testphase eines Programms kann es sinnvoll sein, das Modul zu importieren und EnableBreak aufzurufen.
  5032. Dies erlaubt ein Programm auch dann zu beenden, wenn es in einer Endlosschleife hängt.
  5033.  
  5034.  definierte Prozeduren:
  5035.  
  5036.   {EnableBreak}  {InstallBreakHandler}
  5037.   {DisableBreak} {UninstallBreakHandler}
  5038.  
  5039. Zurück zum {Index} oder zu {Routinen}, Ende mit ESC
  5040.  
  5041. .topic DisableBreak
  5042.  
  5043.   Break.DisableBreak ▄
  5044.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5045.  
  5046.  PROCEDURE DisableBreak;
  5047.  
  5048. Schaltet die Überwachung von Crt-Break aus.
  5049. Das Drücken von Ctrl-Break bleibt so ohne Wirkung.
  5050.  
  5051. Zurück zum Modul {Break}
  5052.  
  5053. .topic EnableBreak
  5054.  
  5055.   Break.EnableBreak ▄
  5056.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5057.  
  5058.  PROCEDURE EnableBreak;
  5059.  
  5060. Erlaubt die Ausführung von Ctrl-Break.
  5061. Der voreingestellte Break-Handler beendet das Programm.
  5062.  
  5063. Zurück zum Modul {Break}
  5064.  
  5065. .topic InstallBreakHandler
  5066.  
  5067.   Break.InstallBreakHandler ▄
  5068.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5069.  
  5070.  PROCEDURE InstallBreakHandler(breakHandler: PROC);
  5071.  
  5072. Installation eines eigenen Break-Handlers -
  5073. die Breaküberwachung muß eingestellt sein.
  5074.  
  5075. Zurück zum Modul {Break}
  5076.  
  5077. .topic UninstallBreakHandler
  5078.  
  5079.   Break.UninstallBreakHandler ▄
  5080.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5081.  
  5082.  PROCEDURE UninstallBreakHandler;
  5083.  
  5084. Deinstalliert die Benutzer-definierte Break-Handler-Prozedur.
  5085.  
  5086. Zurück zum Modul {Break}
  5087.  
  5088. .topic Directories
  5089.  
  5090.    MODULE Directories ▄
  5091.   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5092.  
  5093. In diesem Modul sind ein großer Teil der Verzeichnisoperationen definiert.
  5094.  
  5095.   definierte Typen:
  5096.    {DirEntry}     {QueryProc}
  5097.  
  5098.   definierte Variable:
  5099.    {DirStatus}
  5100.  
  5101.   definierte Konstanten:
  5102.    {NORMAL}       {READONLY}
  5103.    {HIDDEN}       {SYSTEM}
  5104.    {DIRECTORY}    {ARCHIVE}
  5105.  
  5106.   definierte Prozeduren:
  5107.    {GetFirstDir}  {GetNextDir}
  5108.    {DirQuery}     {Delete:Directories_Delete}
  5109.    {MkDir}        {Rename:Directories_Rename}
  5110.    {RmDir}        {GetFileTime:Directories_GetFileTime}
  5111.    {ChDir}        {GetFileAttr}
  5112.    {SetFileAttr}  {SetFileTime:Directories_SetFileTime}
  5113.    {GetCurDir}    {ASCIIZ}
  5114.  
  5115. Zurück zum {Index} oder zu {Routinen}, Ende mit ESC
  5116.  
  5117. .topic DirEntry
  5118.  
  5119.   Directories.DirEntry
  5120.  ══════════════════════╝
  5121.  
  5122.  TYPE
  5123.   DirEntry ═ RECORD
  5124.                name      :ARRAY [0..65] OF CHAR;
  5125.                attribute :BITSET;
  5126.                time      :CARDINAL;
  5127.                date      :CARDINAL;
  5128.                size      :LONGCARD;
  5129.              END;
  5130.  
  5131. Zurück zum Modul {Directories}
  5132.  
  5133. .topic QueryProc
  5134.  
  5135.   Directories.QueryProc
  5136.  ══════════════════════╝
  5137.  
  5138.  TYPE
  5139.    QueryProc ═ PROCEDURE(DirEntry);
  5140.  
  5141.  PROCEDURE {DirQuery}(path: ARRAY OF CHAR;
  5142.            attributes: BITSET;
  5143.                     p: QueryProc);
  5144.  
  5145. Zurück zum Modul {Directories}
  5146.  
  5147. .topic READONLY, HIDDEN, SYSTEM, DIRECTORY, ARCHIVE, NORMAL
  5148.  
  5149.   Dateiattribute
  5150.  ═══════════════╝
  5151.  
  5152.  Attributbits:
  5153.  
  5154.   NORMAL    ═  ();  READONLY  ═ (0);
  5155.   HIDDEN    ═  (1); SYSTEM    ═ (2);
  5156.   DIRECTORY ═  (4); ARCHIVE   ═ (5);
  5157.  
  5158. Zurück zum Modul {Directories}
  5159.  
  5160. .topic GetFirstDir
  5161.  
  5162.   Directories.GetFirstDir ▄
  5163.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5164.  
  5165.  PROCEDURE GetFirstDir(Path: ARRAY OF CHAR;
  5166.                   Attribute: BITSET;
  5167.                     VAR Dir: DirEntry;
  5168.                     VAR ok : BOOLEAN);
  5169.  
  5170.  Bei der Rückgabe:
  5171.   IF ok THEN
  5172.     ...
  5173.   END;
  5174.  
  5175. "Dir" ist der erste Verzeichniseintrag der
  5176. "Path" und "Attribute" besitzt.
  5177.  
  5178. Zurück zum Modul {Directories}
  5179.  
  5180. .topic GetNextDir
  5181.  
  5182.   Directories.GetNextDir ▄
  5183.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5184.  
  5185.  PROCEDURE GetNextDir(VAR Dir:DirEntry;
  5186.                       VAR ok :BOOLEAN);
  5187.  
  5188.  Bei der Rückgabe:
  5189.     IF ok THEN
  5190.       ...
  5191.     END;
  5192.  
  5193. "Dir" ist der nächste Verzeichniseintrag bei
  5194. dem "Path" und "Attribute" des letzten {GetFirstDir}
  5195. oder GetNextDir übereinstimmen.
  5196.  
  5197. Zurück zum Modul {Directories}
  5198.  
  5199. .topic DirQuery
  5200.  
  5201.   Directories.DirQuery ▄
  5202.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5203.  
  5204.  TYPE
  5205.   {QueryProc} ═ PROCEDURE({DirEntry});
  5206.  
  5207.  PROCEDURE DirQuery(path: ARRAY OF CHAR;
  5208.               attributes: BITSET;
  5209.                        p: QueryProc);
  5210.  
  5211. Führt die Prozedur "p" für jeden Verzeichniseintrag
  5212. aus, der mit der Suchmaske und dem
  5213. angegebenen Attribut übereinstimmt.
  5214.  
  5215. Zurück zum Modul {Directories}
  5216.  
  5217. .topic MkDir
  5218.  
  5219.   Directories.MkDir ▄
  5220.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5221.  
  5222.  PROCEDURE MkDir(dirName: ARRAY OF CHAR);
  5223.  
  5224. Erstellt ein neues Verzeichnis.
  5225.  
  5226. "dirName" kann jeder beliebige Pfadname inklusive
  5227. einer optionalen Laufwerksbezeichnung sein.
  5228.  
  5229. Zurück zum Modul {Directories}
  5230.  
  5231. .topic RmDir
  5232.  
  5233.   Directories.RmDir ▄
  5234.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5235.  
  5236.  PROCEDURE RmDir(dirName: ARRAY OF CHAR);
  5237.  
  5238. Löscht das Verzeichnis dirName.
  5239.  
  5240. "dirName" kann jeder beliebige Pfadname inklusive einer
  5241. optionalen Laufwerksbezeichnungs sein.
  5242.  
  5243. Zurück zum Modul {Directories}
  5244.  
  5245. .topic ChDir
  5246.  
  5247.   Directories.ChDir ▄
  5248.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5249.  
  5250.  PROCEDURE ChDir(dirName: ARRAY OF CHAR);
  5251.  
  5252. Wechselt das aktuelle Verzeichnis zu "dirName".
  5253.  
  5254. "dirName" kann jeder beliebige Pfadname inklusive
  5255. einer optionalen Laufwerksbezeichnung sein.
  5256.  
  5257. Wird ein anderes als das aktuelle Laufwerk angegeben,
  5258. wird nur auf dem anderen Laufwerk der Pfad gewechselt.
  5259. Außerdem wird zum anderen Laufwerk als aktuelles Laufwerk gewechselt
  5260.  
  5261. Zurück zum Modul {Directories}
  5262.  
  5263. .topic GetFileAttr
  5264.  
  5265.   Directories.GetFileAttr ▄
  5266.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5267.  
  5268.  PROCEDURE GetFileAttr(fileName: ARRAY OF CHAR;
  5269.                        VAR attr: BITSET);
  5270.  
  5271. Liest die Attribut-Bits der Datei "fileName".
  5272.  
  5273. "fileName" und "dirName" sind jeder beliebige Pfadname
  5274. inklusive einer optionalen Laufwerksbezeichnung.
  5275.  
  5276. Zurück zum Modul {Directories}
  5277.  
  5278. .topic SetFileAttr
  5279.  
  5280.   Directories.SetFileAttr ▄
  5281.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5282.  
  5283.  PROCEDURE SetFileAttr(fileName: ARRAY OF CHAR;
  5284.                            attr: BITSET);
  5285.  
  5286. Setzt die Dateiattribut-Bits der Datei "fileName".
  5287.  
  5288. "fileName" und "dirName" sind jeder beliebige
  5289. Pfadname inklusive einer optionalen Laufwerksbezeichnung.
  5290.  
  5291. Zurück zum Modul {Directories}
  5292.  
  5293. .topic GetCurDir
  5294.  
  5295.   Directories.GetCurDir ▄
  5296.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5297.  
  5298.  PROCEDURE GetCurDir(drive: CARDINAL;
  5299.                 VAR curDir: ARRAY OF CHAR);
  5300.  
  5301. Liefert das aktuelle Verzeichnis des  angegebenen Laufwerks wobei gilt:
  5302.  
  5303.   drive ═ 0     - aktuelles Laufwerk
  5304.         ═ 1     - Laufwerk A
  5305.         ═ 2     - Laufwerk B
  5306.    ...
  5307.  
  5308. Zurück zum Modul {Directories}
  5309.  
  5310. .topic Directories_Delete
  5311.  
  5312.   Directories.Delete ▄
  5313.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5314.  
  5315.  PROCEDURE Delete(fileName: ARRAY OF CHAR);
  5316.  
  5317.  Löscht die Datei "fileName" vom Datenträger.
  5318.  
  5319. "fileName" kann jeder beliebige Pfad- und Dateiname
  5320. inklusive einer optionalen Laufwerksbezeichnung sein.
  5321.  
  5322. Zurück zum Modul {Directories} oder zur {Delete}-Übersicht.
  5323.  
  5324. .topic Directories_Rename
  5325.  
  5326.   Directories.Rename ▄
  5327.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5328.  
  5329.  PROCEDURE Rename(oldName,
  5330.                   newName: ARRAY OF CHAR);
  5331.  
  5332. Benennt die Datei "oldName" in "newName" um.
  5333.  
  5334. Rename kann benutzt werden, um eine Datei vom
  5335. einen in anderes Verzeichnis auf dem selben Laufwerk zu verschieben.
  5336.  
  5337. "oldName" und "newName" sind jeder beliebige
  5338. Pfadname inklusive einer optionalen Laufwerksbezeichnung.
  5339.  
  5340. Zurück zum Modul {Directories} oder zur {Rename}-Übersicht.
  5341.  
  5342. .topic Directories_GetFileTime
  5343.  
  5344.   Directories.GetFileTime ▄
  5345.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5346.  
  5347.  PROCEDURE GetFileTime(fileName: ARRAY OF CHAR;
  5348.                        VAR time: LONGCARD);
  5349.  
  5350. Liefert das Datum die Uhrzeit der letzten Änderung der Datei "fileName".
  5351.  
  5352.  ■ time DIV 65536L ═ Datum der letzten Änderung
  5353.  ■ time MOD 65536L ═ Uhrzeit der letzten Änderung
  5354.  
  5355. "fileName" kann jeder beliebige Pfadname inklusive
  5356. einer optionalen Laufwerksbezeichnung sein.
  5357.  
  5358. Zurück zum Modul {Directories} oder zur {GetFileTime}-Übersicht.
  5359.  
  5360. .topic Directories_SetFileTime
  5361.  
  5362.   Directories.SetFileTime ▄
  5363.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5364.  
  5365.  PROCEDURE SetFileTime(fileName: ARRAY OF CHAR;
  5366.                            time: LONGCARD);
  5367.  
  5368. Setzt Datum und Uhrzeit einer Datei.
  5369.  
  5370. "fileName" kann jeder beliebige Pfadname
  5371. inklusive einer optionalen Laufwerksbezeichnung sein.
  5372.  
  5373. Zurück zum Modul {Directories} oder zur {SetFileTime}-Übersicht.
  5374.  
  5375. .topic ASCIIZ
  5376.  
  5377.   Directories.ASCIIZ ▄
  5378.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5379.  
  5380.  PROCEDURE ASCIIZ(VAR src,
  5381.                      dest: ARRAY OF CHAR);
  5382.  
  5383. Konvertiert die Zeichenkette "src" in einen
  5384. Null-terminierten String in "dest"
  5385. wie er von Dateiprozeduren verlangt wird.
  5386.  
  5387. Zurück zum Modul {Directories}
  5388.  
  5389. .topic DirStatus
  5390.  
  5391.   Directories.DirStatus ▄
  5392.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5393.  
  5394.  VAR
  5395.    DirStatus: CARDINAL;
  5396.  
  5397. DOS-Status nach dem letzten Aufruf eines Datei-Prozeduraufrufs.
  5398.  
  5399. Zurück zum Modul {Directories}
  5400.  
  5401. .topic DTA
  5402.  
  5403.   MODULE DTA ▄
  5404.  ▀▀▀▀▀▀▀▀▀▀▀▀▀
  5405.  
  5406. Lesen und Setzen der DOS-Disk-Transfer-Adress (DTA).
  5407.  
  5408. In "DTA" definierte Prozeduren:
  5409.  
  5410.  {SetDTA} {GetDTA}
  5411.  
  5412. Zurück zum {Index} oder zu {Routinen}, Ende mit ESC
  5413.  
  5414. .topic SetDTA
  5415.  
  5416.   DTA.SetDTA ▄
  5417.  ▀▀▀▀▀▀▀▀▀▀▀▀▀
  5418.  
  5419.  PROCEDURE SetDTA(adrs: ADDRESS);
  5420.  
  5421. setzt die DTA nach "adrs".
  5422.  
  5423. Zurück zum Modul {DTA}.
  5424.  
  5425. .topic GetDTA
  5426.  
  5427.   DTA.GetDTA ▄
  5428.  ▀▀▀▀▀▀▀▀▀▀▀▀▀
  5429.  
  5430.  PROCEDURE GetDTA(VAR adrs :ADDRESS);
  5431.  
  5432. Liest die aktuelle DAT und setzt den Zeiger nach "adrs".
  5433.  
  5434. Zurück zum Modul {DTA}.
  5435.  
  5436. .topic Files
  5437.  
  5438.   MODULE Files ▄
  5439.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5440.  
  5441. Modul für das DOS-Dateiverwaltungs-Interface.
  5442.  
  5443. Weitere Informationen über diese Routinen
  5444. sollten dem technischen Handbuch für DOS entnommen werden.
  5445.  
  5446.  definierte Konstanten:
  5447.   {StdIn} {StdOut} {StdErr} {StdCom} {StdPrn}
  5448.   {NORMAL:Files_NORMAL}
  5449.   {READONLY:Files_READONLY}
  5450.   {HIDDEN:Files_HIDDEN}
  5451.   {SYSTEM:Files_SYSTEM}
  5452.   {READ:READc}
  5453.   {WRITE:WRITEc}
  5454.   {IO}
  5455.   {NOINHERIT}
  5456.   {DENYWRITE}
  5457.   {DENYREAD}
  5458.   {DENYNONE}
  5459.  
  5460.  definierter Typ:
  5461.   {SeekMode}
  5462.  
  5463.  definierte Variable:
  5464.   {FileStatus}
  5465.  
  5466.  definierte Prozeduren:
  5467.   {Open}        {Create:Files_Create}
  5468.   {CreateTemp}  {Rename:Files_Rename}
  5469.   {CreateNew}   {Delete:Files_Delete}
  5470.   {Seek}        {Close:Files_Close}
  5471.   {Dup}         {Read:Files_Read}
  5472.   {Lock}        {Write:Files_Write}
  5473.   {Unlock}      {GetFileTime:Files_GetFileTime}
  5474.   {Dup2}        {SetFileTime:Files_SetFileTime}
  5475.  
  5476.  
  5477. Zurück zum {Index} oder zu {Routinen}, Ende mit ESC.
  5478.  
  5479. .topic StdIn, StdOut, StdErr, StdCom, StdPrn
  5480.  
  5481.   DOS-Standard-Handles
  5482.  ══════════════════════╝
  5483.  
  5484.  CONST
  5485.    StdIn  ═ 0;  StdOut ═ 1
  5486.    StdErr ═ 2   StdCom ═ 3;
  5487.    StdPrn ═ 4
  5488.  
  5489. Zurück zum Modul {Files}
  5490.  
  5491. .topic Files_NORMAL, Files_READONLY, Files_HIDDEN, Files_SYSTEM
  5492.  
  5493.   Dateiattribut-Bits
  5494.  ═══════════════════╝
  5495.  
  5496. Diese Bits werden benötigt, um Dateien zu erzeugen.
  5497.  
  5498. Es dürfen mehrere der Bits gleichzeitig verwendet werden.
  5499.  
  5500.  CONST
  5501.    NORMAL ═  (); READONLY ═ (0);
  5502.    HIDDEN ═ (1); SYSTEM   ═ (2);
  5503.  
  5504. Zurück zum Modul {Files}
  5505.  
  5506. .topic READc, WRITEc, IO, NOINHERIT, DENYWRITE, DENYREAD, DENYNONE
  5507.  
  5508.   Flags für die Datei-Zugriffsrechte
  5509.  ════════════════════════════════════╝
  5510.  
  5511. Flags für die Zugriffsrechte beim Öffnen von Dateien.
  5512.  
  5513. Es muß eines aus der ersten Gruppe ausgewählt werden
  5514. oder eines oder mehrere aus der zweiten Gruppe gewählt
  5515. und diese dann zusammenaddiert werden.
  5516.  
  5517. ■ READ  ═  (); Öffnet die Datei zum Lesen.
  5518.  
  5519. ■ WRITE ═ (0); Öffnet die Datei zum Schreiben.
  5520.  
  5521. ■ IO    ═ (1); Öffnet die Datei zum Lesen und Schreiben.
  5522.  
  5523.  
  5524. Datei-Zugriffsrechte ab DOS 3.1:
  5525.  
  5526. ■ DENYALL   ═ (4); Zurückweisung aller anderen Prozesse.
  5527.  
  5528. ■ DENYWRITE ═ (5); Zurückweisen der
  5529. Schreibfunktion für alle anderen Prozesse.
  5530.  
  5531. ■ DENYREAD  ═ (4,5); Zurückweisern des Lesens für alle anderen Prozesse.
  5532.  
  5533. ■ DENYNONE  ═ (6); Freier Zugriff für andere Prozesse.
  5534.  
  5535. ■ NOINHERIT ═ (7); Kein Zugriff für Tochterprozesse.
  5536.  
  5537.  
  5538. Zurück zum Modul {Files}
  5539.  
  5540. .topic SeekMode
  5541.  
  5542.   Files.SeekMode
  5543.  ═══════════════╝
  5544.  
  5545. Suchmodus - für die Benutzung mit "Seek".
  5546.  
  5547.  TYPE
  5548.    SeekMode ═ (SEEKABS, SEEKCUR, SEEKEND);
  5549.  
  5550. ■ SEEKABS: Angabe der absoluten Suchposition.
  5551.  
  5552. ■ SEEKCUR: Relative Angabe der Suchposition zum aktuellen Dateizeiger.
  5553.  
  5554. ■ SEEKEND: Angabe der absoluten Suchposition vom Dateiende aus.
  5555.  
  5556.  
  5557. Zurück zum Modul {Files}
  5558.  
  5559. .topic FileStatus
  5560.  
  5561.   Files.FileStatus
  5562.  ═════════════════╝
  5563.  
  5564.  VAR
  5565.    FileStatus: CARDINAL;
  5566.  
  5567. DOS-Fehlercode für die letzten Dateifunktionen.
  5568.  
  5569. Liefert 0 zurück, wenn der letzte Dateiaufruf erfolgreich war.
  5570.  
  5571. Zurück zum Modul {Files}
  5572.  
  5573. .topic Open
  5574.  
  5575.   Files.Open ▄
  5576.  ▀▀▀▀▀▀▀▀▀▀▀▀▀
  5577.  
  5578.  PROCEDURE Open(VAR fd: INTEGER;
  5579.                   name: ARRAY OF CHAR;
  5580.                   mode: BITSET);
  5581.  
  5582. Öffnet eine Datei abhängig vom angegebenen Dateimodus.
  5583.  
  5584. Bei der Rückkehr enthät der Datei-Deskriptor den
  5585. von DOS zurückgegebenen Wert oder -1 wenn ein Fehler aufgetreten ist.
  5586.  
  5587. Zurück zum Modul {Files}
  5588.  
  5589. .topic Files_Create
  5590.  
  5591.   Files.Create ▄
  5592.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5593.  
  5594.  PROCEDURE Create(VAR fd: INTEGER;
  5595.                     name: ARRAY OF CHAR;
  5596.                     attr: BITSET);
  5597.  
  5598. Erstellt eine neue Datei oder schneidet eine bestehende Datei ab.
  5599.  
  5600. Falls Create erfolgreich war, wird die Datei für
  5601. Lesen und Schreiben geöffnet.
  5602. "fd" erhält den Datei-Deskriptorwert, der von DOS zurückgeliefert wurde.
  5603. Falls Create fehlgeschlagen ist, enthält "fd" den Wert -1.
  5604.  
  5605. Zurück zum Modul {Files} oder zur {Create}-Übersicht.
  5606.  
  5607. .topic CreateTemp
  5608.  
  5609.   Files.CreateTemp ▄
  5610.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5611.  
  5612.  PROCEDURE CreateTemp(VAR fd: INTEGER;
  5613.                     VAR path: ARRAY OF CHAR;
  5614.                         attr: BITSET);
  5615.  
  5616. Erstellt ab DOS 3.x eine neue Datei mit einmalig vergebenem Namen.
  5617.  
  5618. Beim Eintritt in die Prozedur sollte die Variable "path"
  5619. den Namen des Verzeichnisses enthalten,
  5620. in dem die Temporärdatei angelegt wird und
  5621. genügend Platz (14 Bytes), damit DOS den Namen anhängen kann.
  5622.  
  5623. Bei der Rückkehr aus der Prozedur enthält
  5624. die Variable "path" den kompletten Namen der Temporärdatei.
  5625.  
  5626. Hinweis: DOS löscht die Temporärdatei nicht automatisch.
  5627. Falls die Datei nicht mehr benötigt wird,
  5628. muß sie vom Benutzer gelöscht werden.
  5629.  
  5630. Zurück zum Modul {Files}
  5631.  
  5632. .topic CreateNew
  5633.  
  5634.   Files.CreateNew ▄
  5635.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5636.  
  5637.  PROCEDURE CreateNew(VAR fd: INTEGER;
  5638.                        name: ARRAY OF CHAR;
  5639.                        attr: BITSET);
  5640.  
  5641. Entspricht {Create:Files_Create}.
  5642. CreateNew schlägt jedoch fehl, wenn die Datei bereits existiert (DOS 3.x).
  5643.  
  5644. Zurück zum Modul {Files}
  5645.  
  5646. .topic Files_Close
  5647.  
  5648.   Files.Close ▄
  5649.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5650.  
  5651.  PROCEDURE Close(fd: INTEGER);
  5652.  
  5653. Schließt die Datei.
  5654. Jede weitere Ein- oder Ausgabe auf diesen Datei-Deskriptor schlägt fehl.
  5655.  
  5656. Zurück zum Modul {Files} oder zur {Close}-Übersicht.
  5657.  
  5658. .topic Files_Read
  5659.  
  5660.   Files.Read ▄
  5661.  ▀▀▀▀▀▀▀▀▀▀▀▀▀
  5662.  
  5663. PROCEDURE Read(fd: INTEGER;
  5664.            buffer: ADDRESS;
  5665.             bytes: CARDINAL;
  5666.         VAR nread: CARDINAL);
  5667.  
  5668. Lese die angegebene Anzahl von Bytes aus der Datei.
  5669.  
  5670. Bei der Rückkehr enthält "nwritten" die aktuelle Anzahl gelesener Bytes.
  5671.  
  5672. Zurück zum Modul {Files} oder zur {Read}-Übersicht.
  5673.  
  5674. .topic Files_Write
  5675.  
  5676.   Files.Write ▄
  5677.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5678.  
  5679.  PROCEDURE Write(fd: INTEGER;
  5680.              buffer: ADDRESS;
  5681.               bytes: CARDINAL;
  5682.        VAR nwritten: CARDINAL);
  5683.  
  5684. Schreibe die angegebene Anzahl von Bytes in die Datei.
  5685.  
  5686. Bei der Rückkehr enthält "nwritten" die aktuelle
  5687. Anzahl geschriebener Bytes.
  5688.  
  5689. Zurück zum Modul {Files} oder zur {Write}-Übersicht.
  5690.  
  5691. .topic Seek
  5692.  
  5693.   Files.Seek ▄
  5694.  ▀▀▀▀▀▀▀▀▀▀▀▀▀
  5695.  
  5696.  PROCEDURE Seek(fd: INTEGER; 
  5697.               mode: SeekMode; 
  5698.         VAR offset: LONGCARD);
  5699.  
  5700. Die Prozedur bewegt den Dateizeiger zu der mit "offset"
  5701. angegebenen Adresse in der Datei,
  5702. je nach der in Mode angegebenen Startegie
  5703.  
  5704. Bei der Rückkehr enthält "offset" die neue Dateizeigerposition.
  5705.  
  5706. Zurück zum Modul {Files}
  5707.  
  5708. .topic Lock
  5709.  
  5710.   Files.Lock ▄
  5711.  ▀▀▀▀▀▀▀▀▀▀▀▀▀
  5712.  
  5713.  PROCEDURE Lock(fd: INTEGER;
  5714.             offset: LONGCARD;
  5715.             length: LONGCARD);
  5716.  
  5717. Sperrt den Dateibereich ab dem Offset "offset" für "length" Bytes.
  5718.  
  5719. Erst ab DOS 3.1!
  5720.  
  5721. Zurück zum Modul {Files}
  5722.  
  5723. .topic Unlock
  5724.  
  5725.   Files.Unlock ▄
  5726.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5727.  
  5728.  PROCEDURE Unlock(fd: INTEGER;
  5729.              offset: LONGCARD; 
  5730.              length: LONGCARD);
  5731.  
  5732. Hebt die Sperrung des Dateibereichs ab "offset" für "length"
  5733. Bytes wieder auf. Die Prozedur benötigt DOS ab 3.1
  5734.  
  5735. Zurück zum Modul {Files}
  5736.  
  5737. .topic Dup
  5738.  
  5739.   Files.Dup ▄
  5740.  ▀▀▀▀▀▀▀▀▀▀▀▀
  5741.  
  5742.  PROCEDURE Dup(fd: INTEGER; 
  5743.         VAR newfd: INTEGER);
  5744.  
  5745. Erzeugt einen neuen Datei-Handle für "fd" in "newfd".
  5746.  
  5747. Zurück zum Modul {Files}
  5748.  
  5749. .topic Dup2
  5750.  
  5751.   Files.Dup2 ▄
  5752.  ▀▀▀▀▀▀▀▀▀▀▀▀▀
  5753.  
  5754.  PROCEDURE Dup2(fd, fd2 :INTEGER);
  5755.  
  5756. Dupliziert den Dateihandle fd auf fd2.
  5757.  
  5758. Zurück zum Modul {Files}
  5759.  
  5760. .topic Files_GetFileTime
  5761.  
  5762.   Files.GetFileTime ▄
  5763.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5764.  
  5765.  PROCEDURE GetFileTime(fd: INTEGER;
  5766.                  VAR time: LONGCARD);
  5767.  
  5768. Liefert die Zeit und das Datum der letzten Änderung der Datei.
  5769.  
  5770. ■ time DIV 65536L ═ Datum der letzten Änderung
  5771.  
  5772. ■ time MOD 65536L ═ Zeit der letzten Änderung
  5773.  
  5774. Zurück zum Modul {Files} oder zur {GetFileTime}-Übersicht.
  5775.  
  5776. .topic Files_SetFileTime
  5777.  
  5778.   Files.SetFileTime ▄
  5779.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5780.  
  5781.  PROCEDURE SetFileTime(fd: INTEGER;
  5782.                      time: LONGCARD);
  5783.  
  5784. Setzt das Datum und die Uhrzeit der Datei.
  5785.  
  5786. Zurück zum Modul {Files} oder zur {SetFileTime}-Übersicht.
  5787.  
  5788. .topic Files_Rename
  5789.  
  5790.   Files.Rename ▄
  5791.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5792.  
  5793. PROCEDURE Rename(oldname,
  5794.                  newname: ARRAY OF CHAR);
  5795.  
  5796. Ändert den Dateinamen von "oldname" in "newname".
  5797.  
  5798. Files.Rename kann dazu verwendet werden,
  5799. eine Datei vom einen in anderes Verzeichnis zu verschieben,
  5800. allerdings nur auf dem selben Laufwerk.
  5801.  
  5802. Zurück zum Modul {Files} oder zur {Rename}-Übersicht.
  5803.  
  5804. .topic Files_Delete
  5805.  
  5806.   Files.Delete ▄
  5807.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5808.  
  5809.  PROCEDURE Delete(name: ARRAY OF CHAR);
  5810.  
  5811. Löscht die in "name" angegebene Datei.
  5812.  
  5813. Zurück zum Modul {Files} oder zur {Delete}-Übersicht.
  5814.  
  5815. .topic FileSpec
  5816.  
  5817.   MODULE FileSpec ▄
  5818.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5819.  
  5820. Die Prozeduren dieses Moduls erlauben dem Benutzer,
  5821. komplette Dateinamen zu manipulieren.
  5822.  
  5823. Keine der Prozeduren führt eine Überprüfung auf die
  5824. Richtigkeit der Pfadnamen durch. Sie trennen nur
  5825. die einzelnen Komponenten auf der Grundlage der DOS-Sytax für Pfadnamen.
  5826.  
  5827. Beispiel:
  5828.  
  5829. ParseFileSpec gibt für "\m2\comp" ein
  5830. Verzeichnis "m2" und einen Dateinamen "comp"
  5831. zurück - auch dann, wenn "\m2\comp" der Name eines
  5832. vorhandenen Unterverzeichnisses ist.
  5833.  
  5834. Definierte Prozeduren:
  5835.  
  5836.  {ParseFileSpec}    {ExtractDirPath}
  5837.  {ExtractFileName}  {DropExt}
  5838.  {HasExt}
  5839.  
  5840. Zurück zum {Index} oder zu {Routinen}, Ende mit ESC
  5841.  
  5842. .topic ParseFileSpec
  5843.  
  5844.   FileSpec.ParseFileSpec ▄
  5845.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5846.  
  5847.  PROCEDURE ParseFileSpec(
  5848.            filespec: ARRAY OF CHAR;
  5849.           VAR drive: CHAR;
  5850.             VAR dir: ARRAY OF CHAR;
  5851.            VAR name: ARRAY OF CHAR;
  5852.             VAR ext: ARRAY OF CHAR);
  5853.  
  5854.  
  5855. Nur belegte Teile aus "filespec" werden wieder zurückgeliefert.
  5856. Die anderen Felder werden mit einer Null in ersten Feld geladen.
  5857.  
  5858. ■ drive: das angegebene Laufwerk
  5859.  
  5860. ■ dir:   der angegebene Verzeichnispfad
  5861.  
  5862. ■ name:  der Dateiname ohne die Extension
  5863.  
  5864. ■ ext:   die Dateiendung
  5865.  
  5866.  Beispiel:
  5867.   ParseFileName("d:m2\comp\mc.mod", drive, dir, name, ext);
  5868.  
  5869.  würde zurückliefern:
  5870.  
  5871.   drive   ═ "d"
  5872.   dir     ═ "m2\comp"
  5873.   name    ═ "mc"
  5874.   ext     ═ "mod"
  5875.  
  5876. Zurück zum Modul {FileSpec}
  5877.  
  5878. .topic ExtractDirPath
  5879.  
  5880.   FileSpec.ExtractDirPath ▄
  5881.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5882.  
  5883.  PROCEDURE ExtractDirPath(
  5884.            filespec: ARRAY OF CHAR;
  5885.             VAR dir: ARRAY OF CHAR);
  5886.  
  5887. Liefert die Dateibezeichnung ohne den Dateinamen in "dir".
  5888.  
  5889.  Das Beispiel:
  5890.   ExtractDirName("d:m2\comp\mc.mod", dir);
  5891.  liefert zurück:
  5892.   dir ═ "d:m2\comp"
  5893.  
  5894. Zurück zum Modul {FileSpec}
  5895.  
  5896. .topic ExtractFileName
  5897.  
  5898.   FileSpec.ExtractFileName ▄
  5899.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5900.  
  5901.  PROCEDURE ExtractFileName(
  5902.              filespec: ARRAY OF CHAR;
  5903.              VAR name: ARRAY OF CHAR);
  5904.  
  5905. Gibt in "name" den Dateinamen von "filespec" zurück.
  5906.  
  5907.  Beispiel:
  5908.   ExtractFileName("d:m2\comp\mc.mod", name);
  5909.  
  5910.  gibt zurück:
  5911.   name ═ "mc.mod"
  5912.  
  5913. Zurück zum Modul {FileSpec}
  5914.  
  5915. .topic DropExt
  5916.  
  5917.   FileSpec.DropExt ▄
  5918.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5919.  
  5920.  PROCEDURE DropExt(
  5921.            filespec: ARRAY OF CHAR;
  5922.         VAR newspec: ARRAY OF CHAR);
  5923.  
  5924. Die Prozedur liefert in "newspec" den Dateinamen mit
  5925. der vollen Pfadangabe zurück.
  5926.  
  5927.  Beispiel:
  5928.   ExtractFileName("d:m2\comp\mc.mod", newspec);
  5929.  
  5930.  gibt zurück:
  5931.   newspec ═ "d:m2\comp\mc"
  5932.  
  5933. Zurück zum Modul {FileSpec}
  5934.  
  5935. .topic HasExt
  5936.  
  5937.   FileSpec.HasExt ▄
  5938.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5939.  
  5940.  PROCEDURE HasExt(filespec: ARRAY OF CHAR): BOOLEAN;
  5941.  
  5942. TRUE, falls die Dateiangabe eine Dateiendung besitzt.
  5943.  
  5944. Zurück zum Modul {FileSpec}
  5945.  
  5946. .topic KeyBoard
  5947.  
  5948.   MODULE KeyBoard ▄
  5949.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5950.  
  5951. Dieses Modul liefert die Schnittstelle zu den BIOS-Tastatur-Routinen.
  5952.  
  5953.  definierte Typen:
  5954.   {ShiftKeys}    {ShiftStatus}
  5955.  
  5956.  definierte Prozeduren:
  5957.   {GetKey}       {GetKeyCh}
  5958.   {GetFunKey}    {GetShiftStatus}
  5959.   {KeyPressed:Keyboard_KeyPressed}
  5960.  
  5961. Außerdem sind in KeyBoard alle {Tastaturcodes} als Konstanten definiert.
  5962.  
  5963. Zurück zum {Index} oder zu {Routinen}, Ende mit ESC
  5964.  
  5965. .topic Tastaturcodes
  5966.  
  5967.   Tabelle der Tastaturcodes █
  5968.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  5969.  
  5970. CONST
  5971.  Break ═ 80X; ShiftTab ═ 81X;
  5972.  AltQ  ═ 82X; AltW     ═ 83X;
  5973.  AltE  ═ 84X; AltR     ═ 85X;
  5974.  AltT  ═ 86X; AltY     ═ 87X;
  5975.  AltU  ═ 88X; AltI     ═ 89X;
  5976.  AltO  ═ 8AX; AltP     ═ 8BX;
  5977.  
  5978.  AltA  ═ 90X; AltS     ═ 91X;
  5979.  AltD  ═ 92X; AltF     ═ 93X;
  5980.  AltG  ═ 94X; AltH     ═ 95X;
  5981.  AltJ  ═ 96X; AltK     ═ 97X;
  5982.  AltL  ═ 98X; AltZ     ═ 09EX;
  5983.  
  5984.  AltX  ═ 09FX; AltC    ═ 0A0X;
  5985.  AltV  ═ 0A1X; AltB    ═ 0A2X;
  5986.  AltN  ═ 0A3X; AltM    ═ 0A4X;
  5987.  
  5988.  F1    ═ 0ADX; F2      ═ 0AEX;
  5989.  F3    ═ 0AFX; F4      ═ 0B0X;
  5990.  F5    ═ 0B1X; F6      ═ 0B2X;
  5991.  F7    ═ 0B3X; F8      ═ 0B4X;
  5992.  F9    ═ 0B5X; F10     ═ 0B6X;
  5993.  
  5994.  Home  ═ 0B9X; Up      ═ 0BAX;
  5995.  PgUp  ═ 0BBX; Left    ═ 0BDX;
  5996.  Right ═ 0BFX; End     ═ 0C1X;
  5997.  Down  ═ 0C2X; PgDn    ═ 0C3X;
  5998.  Ins   ═ 0C4X; Del     ═ 0C5X;
  5999.  
  6000.  SF1   ═ 0C6X; SF2     ═ 0C7X;
  6001.  SF3   ═ 0C8X; SF4     ═ 0C9X;
  6002.  SF5   ═ 0CAX; SF6     ═ 0CBX;
  6003.  SF7   ═ 0CCX; SF8     ═ 0CDX;
  6004.  SF9   ═ 0CEX; SF10    ═ 0CFX;
  6005.  CF1   ═ 0D0X; CF2     ═ 0D1X;
  6006.  CF3   ═ 0D2X; CF4     ═ 0D3X;
  6007.  CF5   ═ 0D4X; CF6     ═ 0D5X;
  6008.  CF7   ═ 0D6X; CF8     ═ 0D7X;
  6009.  CF9   ═ 0D8X; CF10    ═ 0D9X;
  6010.  AF1   ═ 0DAX; AF2     ═ 0DBX;
  6011.  AF3   ═ 0DCX; AF4     ═ 0DDX;
  6012.  AF5   ═ 0DEX; AF6     ═ 0DFX;
  6013.  AF7   ═ 0E0X; AF8     ═ 0E1X;
  6014.  AF9   ═ 0E2X; AF10    ═ 0E3X;
  6015.  
  6016.  CtrlPrtSc ═ 0E4X; CtrlLeft  ═ 0E5X;
  6017.  CtrlRight ═ 0E6X; CtrlEnd   ═ 0E7X;
  6018.  CtrlPgDn  ═ 0E8X; CtrlHome  ═ 0E9X;
  6019.  
  6020.  Alt1     ═ 0EAX;  Alt2      ═ 0EBX;
  6021.  Alt3     ═ 0ECX;  Alt4      ═ 0EDX;
  6022.  Alt5     ═ 0EEX;  Alt6      ═ 0EFX;
  6023.  Alt7     ═ 0F0X;  Alt8      ═ 0F1X;
  6024.  Alt9     ═ 0F2X;  Alt0      ═ 0F3X;
  6025.  AltMinus ═ 0F4X;  AltEquals ═ 0F5X;
  6026.  
  6027.  CtrlPgUp ═ 0F6X;
  6028.  
  6029. Zurück zum {Index}
  6030. Ende mit ESC
  6031.  
  6032. .topic ShiftKeys, ShiftStatus
  6033.  
  6034.   KeyBoard.ShiftKeys / .ShiftStatus
  6035.  ═══════════════════════════════════╝
  6036.  
  6037.  TYPE
  6038.    ShiftKeys  ═ (rightShift,
  6039.                  leftShift,
  6040.                  Ctrl,
  6041.                  Alt,
  6042.                  ScrollLock,
  6043.                  NumLock);
  6044.  
  6045.   ShiftStatus ═ SET OF ShiftKeys;
  6046.  
  6047. Zurück zum Modul {KeyBoard}
  6048.  
  6049. .topic KeyBoard_KeyPressed
  6050.  
  6051.   KeyBoard_KeyPressed ▄
  6052.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  6053.  
  6054.  PROCEDURE KeyPressed(): BOOLEAN;
  6055.  
  6056. Wartet da ein Zeichen im Tastaturpuffer?
  6057.  
  6058. Zurück zum Modul {KeyBoard} oder zur {KeyPressed}-Übersicht.
  6059.  
  6060. .topic GetKey
  6061.  
  6062.   KeyBoard.GetKey ▄
  6063.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  6064.  
  6065.  PROCEDURE GetKey(VAR k: CHAR);
  6066.  
  6067. Entspricht der "INKEY"-Funktion in BASIC.
  6068.  
  6069. Es wird entweder ein Zeichen oder 0C oder mit dem
  6070. nächsten Aufruf der erweiterte Tastaturcode zurückgeliefert.
  6071.  
  6072. Zurück zum Modul {KeyBoard}
  6073.  
  6074. .topic GetKeyCh
  6075.  
  6076.   KeyBoard.GetKeyCh ▄
  6077.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  6078.  
  6079.  PROCEDURE GetKeyCh(VAR ch: CHAR);
  6080.  
  6081. Erweiterte Tastaturcodes werden in die oberen 128 ASCII-Zeichen übertragen,
  6082. wie sie in der Tabelle der {Tastaturcodes} zusammengefaßt sind.
  6083.  
  6084. Zurück zum Modul {KeyBoard}
  6085.  
  6086. .topic GetFunKey
  6087.  
  6088.   KeyBoard.GetFunKey ▄
  6089.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  6090.  
  6091.  PROCEDURE GetFunKey(VAR ch: CARDINAL);
  6092.  
  6093. Diese Prozedur unterstützt den internationalen Zeichensatz,
  6094. der das obere Bit von CHAR benützt.
  6095. Der Ordinalwert der regulären Zeichen wird zurückgegeben.
  6096. Erweiterte Zeichen werden in die oberen 128 ASCII-Zeichen umgelagert.
  6097. Anschließend wird 100H dazuaddiert.
  6098. So wird von <F1> der Wert 01ADH zurückgegeben.
  6099.  
  6100. Zurück zum Modul {KeyBoard}
  6101.  
  6102. .topic GetShiftStatus
  6103.  
  6104.   KeyBoard.GetShiftStatus ▄
  6105.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  6106.  
  6107.  PROCEDURE GetShiftStatus(VAR st: ShiftStatus);
  6108.  
  6109. Liefert den Status der Shift/Control-Tasten
  6110.  
  6111. Zurück zum Modul {KeyBoard}
  6112.  
  6113. .topic Menu
  6114.  
  6115.   MODULE Menu ▄
  6116.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  6117.  
  6118. In diesem Modul sind nur die beiden Menütypen {PopMenu}
  6119. und {PullDownMenu} definiert.
  6120.  
  6121. Das Modul verwendet das Modul {Windows}, um die Menüfenster zu erzeugen.
  6122.  
  6123. Zurück zum {Index} oder zu {Routinen}, Ende mit ESC
  6124.  
  6125. .topic PopMenu
  6126.  
  6127.   Menu.PopMenu ▄
  6128.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  6129.  
  6130.  PROCEDURE PopMenu(line,
  6131.                    col:   CARDINAL;
  6132.                    menu:  ARRAY OF CHAR;
  6133.                    width: CARDINAL;
  6134.                    clear: BOOLEAN;
  6135.                VAR cmd:   CARDINAL );
  6136.  
  6137. Klappt ein Menü bei line, col auf.
  6138.  
  6139. "menu" ist eine Zeichenkette von Menüs, die durch
  6140. das Zeichen "|" getrennt werden.
  6141. Der erste Eintrag enthält den Titel des Menüs.
  6142. "width" ist die minimale Breite für das Menü-Window.
  6143. Falls "clear" TRUE ist, wird das Menü nach der Menüauswahl
  6144. zerstört, sonst bleibt es auf dem Bildschirm.
  6145. Dann muß es mit Windows.{CloseCurWindow} entfernt werden.
  6146. "cmd" ist 0, falls kein Menüpunkt ausgewählt wurde (ESC),
  6147. ansonsten wird die Nummer des Menüpunktes zurückgegeben.
  6148.  
  6149. Falls bei der Rückgabe cmd ═ 0 ist, wird das Fenster auf
  6150. alle Fälle geschlossen, egal welcher Wert in clear abgegeben wurde.
  6151.  
  6152.  Beispiel:
  6153.   PopMenu(5, 10, "Hauptmenü|Hallo|Bye|Ende", 0, TRUE, cmd);
  6154.  
  6155. Siehe auch {PullDownMenu}
  6156.  
  6157. Zurück zum Modul {Menu}
  6158.  
  6159. .topic PullDownMenu
  6160.  
  6161.   Menu.PullDownMenu ▄
  6162.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  6163.  
  6164.  PROCEDURE PullDownMenu(line    : CARDINAL;
  6165.                         frame   : BOOLEAN;
  6166.                         MainMenu: ARRAY OF CHAR;
  6167.                         SubMenus: ARRAY OF CHAR;
  6168.                         clear   : BOOLEAN;
  6169.                     VAR cmd1,
  6170.                         cmd2    : CARDINAL);
  6171.  
  6172. Erstellt ein Pulldown-Menü in der Zeile "line".
  6173.  
  6174. In "frame" wird angegeben, ob der Pulldownbalken einen Rahmen bekommt.
  6175. "MainMenu" ist eine Zeichenkette, in der die Menüpunkt,
  6176. getrennt von einem "|" angegeben werden.
  6177. "SubMenus" ist eine Zeichenkette mit Untermenüs, getrennt
  6178. von "&"; jedes der Untermenüs enthält eine Liste von Auswahlpunkte,
  6179. getrennt von "|".
  6180. Bei der Rückgabe enthält "cmd1" die Nummer des gewählten
  6181. Hauptmenüpunkts und "cmd2" die Nummer des entspechenden
  6182. Untermenüpunkts. Falls der Benutzer ESC drückt, liefert cmd1 0 zurück.
  6183.  
  6184. Alle Menüfenster werden vor der Rückkehr geschlossen.
  6185.  
  6186. siehe auch {PopMenu}
  6187.  
  6188. Zurück zum Modul {Menu}
  6189.  
  6190. .topic Loader
  6191.  
  6192.   MODULE Loader ▄
  6193.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  6194.  
  6195. In diesem Modul ist nur die Prozedur {Execute} definiert,
  6196. die dazu dient, andere Programme nachzuladen.
  6197. Sie entspricht der Turbo-Pascal Prozedur "Exec".
  6198.  
  6199. Zurück zum {Index} oder zu {Routinen},
  6200.  
  6201. Ende mit ESC
  6202.  
  6203. .topic Execute
  6204.  
  6205.   Loader.Execute ▄
  6206.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  6207.  
  6208.  PROCEDURE Execute(pgm: ARRAY OF CHAR;
  6209.                   args: ARRAY OF CHAR;
  6210.           VAR exitcode: CARDINAL);
  6211.  
  6212. Die Prozedur startet das externe Programm "pgm" mit der Argument "args".
  6213. Es muß der volle Pfadname des externen Programms angegeben werden.
  6214.  
  6215. Bei der Rückkehr aus der Prozedur:
  6216.  
  6217.  ■ exitcode < 32768:
  6218.    Die Ausführung konnte nicht stattfinden.
  6219.    Der DOS-Exitcode wird zurückgegeben.
  6220.  
  6221.  ■ exitcode >═ 32768:
  6222.    exitcode MOD 256 ist der Exitcode
  6223.    des Programms "pgm"
  6224.  
  6225.  ■ (exitcode-32768) DIV 256
  6226.    ist der Grund für die Beendigung
  6227.    des Programms:
  6228.  
  6229.    0 ═ normal
  6230.    1 ═ durch Ctrl-C
  6231.    2 ═ Kritischer Gerätefehler
  6232.    3 ═ DOS-Funktion 31H (TSR)
  6233.  
  6234. Execute versucht, dem aufgerufenen Programm möglichst
  6235. viel Speicher zuzuweisen, indem der Speicher über System.{HeapTop}
  6236. freigegeben wird.
  6237. Das aufgerufene Programm darf nicht speicherresident verbleiben (TSR)!!!
  6238.  
  6239. Zurück zum Modul {Loader}
  6240.  
  6241. .topic Paths
  6242.  
  6243.   MODULE Paths ▄
  6244.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  6245.  
  6246. Im Modul Paths ist nur die Prozedur {Locate} definiert.
  6247.  
  6248. Zurück zum {Index} oder zu {Routinen}, Ende mit ESC
  6249.  
  6250. .topic Locate
  6251.  
  6252.   Paths.Locate ▄
  6253.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  6254.  
  6255.  PROCEDURE Locate(fileName: ARRAY OF CHAR;
  6256.                    envPath: ARRAY OF CHAR;
  6257.            VAR PathAndName: ARRAY OF CHAR;
  6258.                  VAR found: BOOLEAN);
  6259.  
  6260. Es wird versucht, die im Environment-String "envPath" angebenen
  6261. Pfade nach der Datei "filename" zu durchsuchen.
  6262. Falls die Datei gefunden wird, wird der vollständige Name
  6263. inklusive des Pfades in PathAndName zurückgegeben.
  6264.  
  6265.  Beispiel:
  6266.    Locate("M2IDE.CFG", "PATH", pathName, found);
  6267.    IF found THEN
  6268.      Lookup(f, pathName);
  6269.      ...
  6270.  
  6271. Zurück zum Modul {Paths}
  6272.  
  6273. .topic RealConversion
  6274.  
  6275.    MODULE RealConversion ▄
  6276.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  6277.  
  6278.  definierte Prozeduren:
  6279.  
  6280.   {RealToString}     {StringToReal}
  6281.   {LongRealToString} {StringToLongReal}
  6282.  
  6283. Zurück zum {Index} oder zu {Routinen}, Ende mit ESC
  6284.  
  6285. .topic RealToString
  6286.  
  6287.   RealConversion.RealToString ▄
  6288.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  6289.  
  6290.  PROCEDURE RealToString(x: REAL;
  6291.              decDigits, n: INTEGER;
  6292.                     VAR s: ARRAY OF CHAR;
  6293.                    VAR ok: BOOLEAN);
  6294.  
  6295. Konvertiert "x" in ein Zeichenfeld. "n" ist die Breite des Zeichenfeldes.
  6296. ABS(decDigits) ist die Zahl der gewünschten Stellen.
  6297. Das Ergebnis wird in "s" zurückgegeben.
  6298. "ok" wird auf TRUE gesetzt, wenn die Umwandlung erfolgreich
  6299. durchgeführt wurde.
  6300.  
  6301. Die Ausgabe von "s" erfolgt im Fixkomma-Format,
  6302. wenn "decDigits" positiv ist,
  6303. sonst erfolgt die Ausgabe in wissenschaftlicher Notation.
  6304. Falls "n" größer als die Zahl der benötigten Zeichen für die
  6305. Umwandlung ist, wird s links mit Leerzeichen aufgefüllt.
  6306.  
  6307. Falls decDigits > 0 ist, muß "n" >═ decDigits + 2 sein,
  6308. sonst muß n  >═ ABS(decDigits) + 7 sein.
  6309.  
  6310. Beispiele:
  6311.  
  6312. RealToString(1.148, 2, 6, s, ok) würde  "  1.15" in s zurückgeben.
  6313.  
  6314. RealToString(1.148, -2, 10, s, ok) würde "  1.15E+00" in s zurückgeben.
  6315.  
  6316.  
  6317. Zurück zum Modul {RealConversion}
  6318.  
  6319. .topic StringToReal
  6320.  
  6321.   RealConversion.StringToReal ▄
  6322.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  6323.  
  6324.  PROCEDURE StringToReal(s: ARRAY OF CHAR;
  6325.                    VAR  x: REAL;
  6326.                    VAR ok: BOOLEAN);
  6327.  
  6328. Konvertiert die Zeichenkette s in eine Real-Zahl.
  6329. Es wird eine Realzahl im Modula-2-Fließkommazahlenformat erwartet.
  6330.  
  6331. Zurück zum Modul {RealConversion}
  6332.  
  6333. .topic LongRealToString
  6334.  
  6335.   RealConversion.LongRealToString ▄
  6336.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  6337.  
  6338.  PROCEDURE LongRealToString(x: LONGREAL;
  6339.                  decDigits, n: INTEGER;
  6340.                        VAR  s: ARRAY OF CHAR;
  6341.                        VAR ok: BOOLEAN);
  6342.  
  6343. Arbeitet identisch wie {RealToString}.
  6344.  
  6345. Zurück zum Modul {RealConversion}
  6346.  
  6347. .topic StringToLongReal
  6348.  
  6349.   RealConversion.StringToLongReal ▄
  6350.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  6351.  
  6352.  PROCEDURE StringToLongReal(s: ARRAY OF CHAR;
  6353.                        VAR  x: LONGREAL;
  6354.                        VAR ok: BOOLEAN);
  6355.  
  6356. Arbeitet identisch wie {StringToReal}.
  6357.  
  6358. Zurück zum Modul {RealConversion}
  6359.  
  6360. .topic TimeDate
  6361.  
  6362.   MODULE TimeDate ▄
  6363.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  6364.  
  6365. In diesem Modul sind der Typ {Time} und die beiden
  6366. Prozeduren {GetTime} und {SetTime} definiert.
  6367.  
  6368. Zurück zum {Index} oder zu {Routinen}, Ende mit ESC
  6369.  
  6370. .topic Time
  6371.  
  6372.   TYPE TimeDate.Time ▄
  6373.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  6374.  TYPE
  6375.    Time ═ RECORD
  6376.             day,
  6377.             minute,
  6378.             millisec: CARDINAL;
  6379.           END;
  6380.  
  6381.   day      ═ ((Jahr - 1900) * 16
  6382.              + Monat * 32
  6383.              + Tag_des_Monats)
  6384.   minute   ═ Minuten seit
  6385.              Mitternacht
  6386.  
  6387.   millisec ═ Millisekunden der
  6388.              letzten vollen Minute
  6389.  
  6390. Zurück zum Modul {TimeDate}
  6391.  
  6392. .topic GetTime
  6393.  
  6394.   TimeDate.GetTime ▄
  6395.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  6396.  
  6397.  PROCEDURE GetTime(VAR time: Time);
  6398.  
  6399. Liefert die Systemzeit.
  6400.  
  6401. Zurück zum Modul {TimeDate}
  6402.  
  6403. .topic SetTime
  6404.  
  6405.   TimeDate.SetTime ▄
  6406.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  6407.  
  6408.  PROCEDURE SetTime(time: Time);
  6409.  
  6410. Setzt die Systemzeit.
  6411.  
  6412. Zurück zum Modul {TimeDate}
  6413.  
  6414. .topic Compilerschalter
  6415.  
  6416.   Compilerschalter ▄
  6417.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  6418.  
  6419. Durch im Programmtext enthaltene Befehle können verschiedene
  6420. Compiler-Schalter gesetzt werden, die die Code-Erzeugung
  6421. beeinflussen.
  6422.  
  6423. Diese Befehle müssen am Anfang eines Kommentars stehen;
  6424. mehrere Compiler-Befehle können durch Kommata getrennt
  6425. in einem Kommentar aufgereiht werden.
  6426.  
  6427.  Beispiel:
  6428.  
  6429.   (* $S-, $R+ *)
  6430.  
  6431. Ein "+" setzt den Schalter auf {TRUE}, ein "-" setzt ihn
  6432. auf {FALSE} und ein "=" setzt den Wert auf den
  6433. vorausgegangenen Wert zurück.
  6434.  
  6435. Von Fitted Modula-2 Version 2.0 unterstützte Compilerschalter:
  6436.  
  6437.  {(*$A+/$A-*):Switches_sA}
  6438.  {(*$S+/$S-*):Switches_sS}
  6439.  {(*$R+/$R-*):Switches_sR}
  6440.  {(*$T+/$T-*):Switches_sT}
  6441.  {(*$L+/$L-*):Switches_sL}
  6442.  
  6443. Zurück zum {Index}, Ende mit ESC
  6444.  
  6445. .topic Switches_sA
  6446.  
  6447.   Befehl: $A, Vorbelegung: +
  6448.  ════════════════════════════╝
  6449.  
  6450.  Ausrichtung
  6451.  -----------
  6452.  
  6453. Bei  "+" werden alle neu deklarierten Variablen an Wortgrenzen
  6454. (1 Wort ═ 2 Bytes) aus gerichtet.
  6455. Record-Komponenten werden ungeachtet dieses Befehls gepackt
  6456. (jedoch nicht ausgerichtet).
  6457.  
  6458. Zurück zur Übersicht: {Compilerschalter}.
  6459.  
  6460. .topic Switches_sS
  6461.  
  6462.   Befehl: $S, Vorbelegung: +
  6463.  ════════════════════════════╝
  6464.  
  6465.  Stack-Überlauf-Kontrolle
  6466.  ------------------------
  6467.  
  6468. Bei "+" wird bei Eintritt in ein Unterprogramm geprüft,
  6469. ob der verfügbare Platz auf dem Stack ausreicht. Diese
  6470. Prüfung wird auch beim Kopieren von offenen Arrays in
  6471. den lokalen Stack-Rahmen eines Unterprogramms durchgeführt.
  6472.  
  6473. Zurück zur Übersicht: {Compilerschalter}.
  6474.  
  6475. Zurück zum Menü {Compilerschalter}
  6476.  
  6477. .topic Switches_sR
  6478.  
  6479.   Befehl: $R, Vorbelegung: +
  6480.  ════════════════════════════╝
  6481.  
  6482.  Bereichs-Prüfung
  6483.  ----------------
  6484.  
  6485. Bei  "+"  wird vor jeder Zuweisung auf eine Variable
  6486. eines Teilbereichs-Typs (Subrange) geprüft, ob der
  6487. zuzuweisende Wert wirklich innerhalb der erlaubten
  6488. Bereichsgrenzen liegt.
  6489.  
  6490. Wenn die Compiler-Option $R gesetzt ist, erzeugt der
  6491. Compiler Code zur Bereichsprüfung ("range check code")
  6492. bei Zuweisungen zwischen {INTEGER}s und {CARDINAL}s.
  6493. Der Wert ist unabhängig von der Zuweisungsrichtung außerhalb
  6494. des zugelassenen Bereiches, wenn das höchstwertige Bit 1
  6495. ist.
  6496.  
  6497. Zurück zum Menü {Compilerschalter}
  6498.  
  6499. .topic Switches_sT
  6500.  
  6501.   Befehl $T, Vorbelegung: +
  6502.  ═══════════════════════════╝
  6503.  
  6504.  Feld-Index-Prüfung
  6505.  ------------------
  6506.  
  6507. Bei  "+" wird bei jedem  Zugriff auf ein Feld (Array)
  6508. über Index zuvor geprüft, ob der Index nicht außerhalb
  6509. der definierten Feldgrenzen liegt.
  6510.  
  6511. Wenn die Compiler-Option $T gesetzt ist, werden Zeiger
  6512. vor dem Zugriff auf NIL geprüft. Außerdem setzt
  6513. Storage.{DEALLOCATE} den übergebenen Zeiger auf NIL.
  6514.  
  6515. Zurück zum Menü {Compilerschalter}
  6516.  
  6517. .topic Switches_sL
  6518.  
  6519.   Befehl $L, Vorbelegung -
  6520.  ══════════════════════════╝
  6521.  
  6522.  Erzeuge Zeilennummer-Information
  6523.  --------------------------------
  6524.  
  6525. Bei "+" erzeugt der Compiler eine Liste der
  6526. Quelltext-Zeilennummern und der entsprechenden
  6527. Objectcode-Adressen in der Ausgabedatei.
  6528. Diese Liste wird beim Linken mit der /L-Option
  6529. in die .DBG-Datei geschrieben.
  6530. Mit DBG2MAP kann anschließend eine Standard-MAP-Datei
  6531. geschrieben werden, die mit TDMAP an das EXE-Programm
  6532. angehängt werden kann, um die Bearbeitung mit dem
  6533. Turbo-Debugger zu ermöglichen.
  6534.  
  6535.  
  6536. Zurück zum Menü {Compilerschalter}
  6537.  
  6538. .topic Laufzeitfehler
  6539.  
  6540.   Laufzeitfehler ▄
  6541.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  6542.  
  6543. Wenn während der Ausführung eines Programms ein
  6544. Laufzeitfehler auftritt, wird das Programm von der
  6545. Laufzeitfehler-Behandlungsroutine abgebrochen und
  6546. eine Nachricht über Art und Stelle (Adresse) des
  6547. Fehlers ausgegeben.
  6548.  
  6549.  {Stack Overflow         :eStack}
  6550.  {Range Overflow         :eRange}
  6551.  {Integer Overflow       :eIntOver}
  6552.  {Floating Point Overflow:eFloatOver}
  6553.  {No RETURN              :eNoRet}
  6554.  {HALT                   :eHALT}
  6555.  
  6556. Zurück zum {Index}, Ende mit ESC
  6557.  
  6558. .topic eStack
  6559.  
  6560.   Runtime-Error 0
  6561.  ─────────────────┘
  6562.  
  6563. Stack-Überlauf ($S Option)
  6564.  
  6565. Zurück zum Menü {Laufzeitfehler}
  6566.  
  6567. .topic eRange
  6568.  
  6569.   Runtime-Error 1
  6570.  ─────────────────┘
  6571.  
  6572. Bereichs-Fehler ($R oder $T Option)
  6573.  
  6574. Zurück zum Menü {Laufzeitfehler}
  6575.  
  6576. .topic eIntOver
  6577.  
  6578.   Runtime-Error 2
  6579.  ─────────────────┘
  6580.  
  6581. Integer/Cardinal-Überlauf (Division durch Null)
  6582.  
  6583. Zurück zum Menü {Laufzeitfehler}
  6584.  
  6585. .topic eFloatOver
  6586.  
  6587.   Runtime-Error 3
  6588.  ─────────────────┘
  6589.  
  6590. Fehler bei einer Fließkomma-Operation
  6591.  
  6592. Zurück zum Menü {Laufzeitfehler}
  6593.  
  6594. .topic eNoRET
  6595.  
  6596.   Runtime-Error 4
  6597.  ─────────────────┘
  6598.  
  6599. Funktion hat kein RETURN ausgeführt.
  6600.  
  6601. Zurück zum Menü {Laufzeitfehler}
  6602.  
  6603. .topic eHALT
  6604.  
  6605.   Runtime-Error 5
  6606.  ─────────────────┘
  6607.  
  6608. HALT wurde aufgerufen.
  6609.  
  6610. Zurück zum Menü {Laufzeitfehler}
  6611.  
  6612. .topic Typen
  6613.  
  6614.   MODULA Standard-Typen ▄
  6615.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  6616.  
  6617.   Datentyp-Darstellung:
  6618.  ──────────────────────┘
  6619.  
  6620.  {CHAR}       1 Byte
  6621.  {INTEGER}    2 Bytes 2er-Komplement
  6622.  {CARDINAL}   2 Bytes
  6623.  {LONGCARD}   4 Bytes
  6624.  {LONGINT}    4 Bytes 2er-Komplement
  6625.  {BOOLEAN}    1 Byte (1 ═ TRUE, 0 ═ FALSE)
  6626.  {REAL:TREAL}       4 Bytes im Intel-8087-Format.
  6627.  {LONGREAL}   8 Bytes im Intel-8087-Format.
  6628.  {BITSET}     1 Wort. 0 ═ low Order Bit, 15 ═ high Order Bit.
  6629.  {SET}        1 bis 8 Worte (Mengen bis zu 256 Elemente)
  6630.  {POINTER}    4 Bytes im Intel-8086/88-Format
  6631.  {PROCEDURE}  4 Bytes POINTER zur Prozedur-Startadresse
  6632.  
  6633. Adressen sind im Intel-8086-Format dargestellt:
  6634.  
  6635.  1 Wort    {BYTE} {OFFSET}
  6636.  1 Wort    {SEGMENT}
  6637.  
  6638. Numerische Werte sind gleichfalls so dargestellt,
  6639. wie bei der Intel 8086-Prozessor-Familie üblich:
  6640. niederwertiges Byte zuerst, höherwertiges Byte zuletzt.
  6641.  
  6642. Zurück zum {Index}, Ende mit ESC
  6643.  
  6644. .topic CHAR
  6645.  
  6646.   CHAR ▄
  6647.  ▀▀▀▀▀▀▀
  6648.  
  6649. Einfacher vorzeichenloser 8-Bit Datentyp.
  6650.  
  6651. CHAR implementiert den {ASCII}-Zeichensatz,
  6652. kann aber auch als normaler Datentype verwendet werden.
  6653. CHARs müssen in oktaler Schreibweise angegeben werden.
  6654. CHAR-Konstanten werden durch ein nachstehendes C gekennzeichnet.
  6655. Das Modul {ASCII} vereinfacht die Zuweisung von ASCII-Zeichen,
  6656. da dort alle Steuerzeichen als Konstante definiert sind.
  6657.  
  6658.  Zuweisungen von CHARs wären:
  6659.  
  6660.  CONST
  6661.    ch    = 36C;       (* oktal ! *)
  6662.    Space = ' ';       (* direkt zugewiesen *)
  6663.    Qote  = "'";       (* Hochkomma in Anführungszeichen *)
  6664.    Enter = ASCII.EOL; (* importiert! *)
  6665.  
  6666.  VAR
  6667.    c: CHAR;
  6668.  ...
  6669.  BEGIN
  6670.    c := '"';           (* Anführungszeichen in Hochkommas *)
  6671.    ...
  6672.  
  6673. CHAR ist zuweisungskompatibel mit SYSTEM.{BYTE},
  6674. muß aber im Gegensatz zu BYTE nicht importiert werden.
  6675. CHAR-Konstanten werden mit einfachem (') oder
  6676. doppeltem (") Hochkomma eingerahmt.
  6677. Die in Pascal mögliche Notierung eines Hochkommas
  6678. in einer Zeichenkette oder als CHAR ist nicht möglich.
  6679. Stattdessen können genauso wie Assembler die beiden
  6680. Kennungen gemischt werden:
  6681.  
  6682. '"' wird für Anführungsstriche, "'" für Hochkomma verwendet.
  6683.  
  6684. Der Typ String ist in Modula-2 nicht vordefiniert.
  6685.  
  6686. Ein "String" ist ein ARRAY OF CHAR, beispielsweise:
  6687.  
  6688.  TYPE
  6689.    String: ARRAY [0..79] OF CHAR;
  6690.  
  6691. Da Modula-Strings als normale Arrays im Gegensatz
  6692. zu Turbo-Pascal Strings kein Längenbyte besitzen,
  6693. kann das ARRAY bei 0 beginnen.
  6694.  
  6695. Zurück zum {Typen}-Menü.
  6696.  
  6697. .topic INTEGER
  6698.  
  6699.   INTEGER ▄
  6700.  ▀▀▀▀▀▀▀▀▀▀
  6701.  
  6702. Vorzeichenabhängiger 16-Bit Datentyp.
  6703.  
  6704. Wertebereich:  -32768 bis 32767
  6705.  
  6706. Zurück zum {Typen}-Menü.
  6707.  
  6708. .topic CARDINAL
  6709.  
  6710.   CARDINAL ▄
  6711.  ▀▀▀▀▀▀▀▀▀▀▀
  6712.  
  6713. Vorzeichenloser 16-Bit Datentyp.
  6714.  
  6715. CARDINAL entspricht dem Turbo-Pascal Datentyp
  6716. Word und ist zuweisungskompatibel zu dem
  6717. systemabhängigen 16-Bit-Datentype SYSTEM.{WORD}.
  6718.  
  6719. Wertebereich: 0 bis 65535.
  6720.  
  6721. Zurück zum {Typen}-Menü.
  6722.  
  6723. .topic LONGINT, LONGCARD
  6724.  
  6725.   LONGINT/LONGCARD ▄
  6726.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  6727.  
  6728. Der Fitted-Modula-2-Compiler implementiert
  6729. die 32-Bit Standard-Typen LONGINT und LONGCARD.
  6730.  
  6731. Operanden des Typs LONGINT oder LONGCARD
  6732. dürfen wie INTEGER oder CARDINAL in jedem Ausdruck auftauchen.
  6733. Aber das ist auch schon alles!
  6734.  
  6735. Teilbereiche (Subranges) dieser Typen sind nicht möglich.
  6736.  
  6737. Keine Standard-Prozeduren akzeptieren Operanden
  6738. dieser Typen (außer INC, DEC und verwandten).
  6739. Eine Variable vom Typ LONGINT oder LONGCARD
  6740. darf weder als Steuerungs-Variable einer FOR-Schleife,
  6741. noch als CASE-Marke vorkommen.
  6742. LONGINT- oder LONGCARD-Konstanten können nur
  6743. dezimal geschrieben werden und enden mit
  6744. einem "L", falls der Wert kleiner als 65536 ist.
  6745.  
  6746.  Beispiel:
  6747.  
  6748. ■ 123L und 123567 sind korrekte LONGCARD- oder LONGINT-Konstanten,
  6749.  
  6750. ■ -1L  und -348762 sind korrekte LONGINT-Konstanten
  6751.  
  6752. Wertebereich für LONGINT: -2147483648 bis 2147483647.
  6753.  
  6754. Wertebereich für LONGCARD:  0 bis 4294967297.
  6755.  
  6756. Zurück zum {Typen}-Menü.
  6757.  
  6758. .topic BOOLEAN, TRUE, FALSE
  6759.  
  6760.   Boolescher Datentyp ▄
  6761.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  6762.  
  6763. Variablen vom Typ BOOLEAN können ausschließlich einen der vordefinierten Werte FALSE ( # 0) oder TRUE ( ═ 0) annehmen.
  6764. Tatsächlich handelt es sich bei Boolean um einen Aufzählungstyp, der folgendermaßen deklariert ist:
  6765. Zuweisungen wie PRED und SUCC sind möglich. FALSE ist ein SUCC oder PRED von TRUE.
  6766.  
  6767.  TYPE
  6768.    BOOLEAN = (FALSE, TRUE);
  6769.  
  6770. Die Anwendung der Operatoren = <> > < >= <= IN innerhalb
  6771. eines Ausdrucks erzeugt Ergebnisse vom Typ BOOLEAN.
  6772.  
  6773. Zurück zum {Typen}-Menü.
  6774.  
  6775. .topic TREAL
  6776.   REAL ▄
  6777.  ▀▀▀▀▀▀▀
  6778.  
  6779. Fließkommazahlen. Der Datentyp entspricht dem Turbo-Pascal (ab 5.0)
  6780. Datentyp Single und ist vier Bytes groß.
  6781.  
  6782. REAL arbeitet mit sieben bis acht Stellen Genauigkeit. Für
  6783. genauere Operation kann {LONGREAL} verwendet werden.
  6784. Für Ein- und Ausgaben steht das Modul {RealInOut}, für
  6785. mathematische Opertionen das Modul {MathLib0} zur Verfügung.
  6786. String-Konvertierungen werden in {RealConversion} durchgeführt.
  6787.  
  6788. Wertebereich für REAL: 1.5E-45 bis 3.4E38.
  6789.  
  6790. Zurück zum {Typen}-Menü.
  6791.  
  6792. .topic LONGREAL
  6793.  
  6794.   LONGREAL ▄
  6795.  ▀▀▀▀▀▀▀▀▀▀▀
  6796.  
  6797. Ab der Version 2.0 von Fitted Modula-2 besteht eine Wahlmöglichkeit
  6798. bei der Größe des REAL-Typs. Version 1.x unterstützte nur das
  6799. 4-Byte-Format, mit dem eine Genauigkeit von etwa sieben Stellen
  6800. erreicht wird, während mit dem acht Bytes langen LONGREAL-Format
  6801. etwa 15 bis 16 Stellen möglich sind.
  6802.  
  6803. Die Typen {REAL} and LONGREAL sind nicht kompatibel
  6804. und es gibt keinerlei automatische Umwandlung zwischen
  6805. diesen Typen. Stattdessen stehen für diese Umwandlungen
  6806. die Standard-Prozeduren {SHORT} und {LONG} zur Verfügung.
  6807. Konstanten vom Typ LONGREAL unterscheiden sich nicht von
  6808. REAL-Konstanten. Der Typ wird durch den Kontext bestimmt.
  6809. Sie können eine Konstante jedoch durch den Gebrauch der
  6810. SHORT- oder der LONG-Procedure "typisieren".
  6811.  
  6812.  Beispiel:
  6813.    CONST
  6814.      longreal1 ═ LONG(1.0);
  6815.  
  6816. Für Ein- und Ausgaben steht das Modul {RealInOut},
  6817. für mathematische Opertionen das Modul {LMathLib0:MathLib0}
  6818. zur Verfügung. String-Konvertierungen werden in {RealConversion}
  6819. durchgeführt.
  6820.  
  6821. Wertebereich für LONGREAL: 5.0E-324 bis 1.7E308.
  6822.  
  6823. Zurück zum {Typen}-Menü.
  6824.  
  6825. .topic BITSET
  6826.  
  6827.   BITSET ▄
  6828.  ▀▀▀▀▀▀▀▀▀
  6829.  
  6830. Zusammengesetzter Datentyp der ein BYTE aufschlüsselt.
  6831.  
  6832. Bitset-Werte werden in geschweiften Klammern geschrieben.
  6833.  
  6834. Ein Bitset sind beispielsweise die {FLAGS} oder die
  6835. Dateiattribute des Moduls {Directories}.
  6836.  
  6837. Aufgeschüsselt werden Bitsets über eine sehr einfache Abfrage:
  6838.  
  6839.  IF FLAGS = (carryFlag) THEN ...
  6840.  
  6841. Ist nur dann TRUE, wenn das CarryFlag (Bit 0 des Flagregisters)
  6842. gesetzt ist.
  6843.  
  6844. Das Flagregister ist in {System:DOSSystem} als
  6845. VAR FLAGS: BITSET definiert.
  6846.  
  6847. Zurück zum {Typen}-Menü.
  6848.  
  6849. .topic SET
  6850.  
  6851.   SET ▄
  6852.  ▀▀▀▀▀▀
  6853.  
  6854. Diese Deklaration vereinbart eine Menge des durch Elemententyp
  6855. angegebenen Typs:
  6856.  
  6857.  Syntax:
  6858.    SET of Elemententyp
  6859.  
  6860. Der entsprechende Basistyp muß ordinal sein und darf maximal 256
  6861. verschiedene Werte beinhalten, deren Grenzen innerhalb des Bereichs
  6862. 0..255 liegen müssen.
  6863.  
  6864. Über geschweiften Klammern und eine Aufzählung von Ausdrücken
  6865. ist die Definition von Teilbereichen auch innerhalb einer
  6866. Mengen-Deklaration möglich.
  6867.  
  6868. () steht hier für eine leere Menge, die mit allen anderen
  6869. Mengentypen kompatibel ist.
  6870.  
  6871. Beispiel:
  6872.  
  6873.  (* Mengen mit ordinalen Basistypen *)
  6874.  
  6875.  TYPE
  6876.    Tag     ═ (Son, Mon, Die, Mit, Don, Fre, Sam);
  6877.    CharSet ═ SET OF CHAR;
  6878.    Tage    ═ SET OF Tag;
  6879.  
  6880.   (* Mengen mit Angaben von Unterbereichen *)
  6881.  
  6882.   ('0'..'9', 'A'..'Z', 'a'..'z', '_')
  6883.   (1, 5, I + 1 .. J - 1)
  6884.   (Mon..Fre)
  6885.  
  6886. Zurück zum {Typen}-Menü.
  6887.  
  6888. .topic POINTER, NIL
  6889.  
  6890.   POINTER ▄
  6891.  ▀▀▀▀▀▀▀▀▀▀
  6892.  
  6893. Eine Zeigervariable enthält die Speicheradresse
  6894. einer anderen Variablen des Typs, für den die
  6895. Zeigervariable deklariert wurde.
  6896.  
  6897. Mit den folgenden Operationen lassen sich einer
  6898. Zeigervariablen Werte zuordnen:
  6899.  
  6900. ■ den Prozeduren {NEW} oder {ALLOCATE}
  6901.  
  6902. ■ der Standardprozedur {PTR}
  6903.  
  6904. Das reservierte Wort NIL steht für einen
  6905. Zeiger, der "nirgendwohin" zeigt.
  6906.  
  6907. Der vordefinierte Datentyp POINTER steht für
  6908. einen untypisierten Zeiger, der mit jedem anderen
  6909. Zeigertyp kompatibel ist.
  6910.  
  6911. Beispiele:
  6912.  
  6913.  (* POINTER Typdeklarationen: *)
  6914.  
  6915.  TYPE
  6916.    BytePtr  = POINTER TO BYTE;
  6917.    WordPtr  = POINTER TO CARDINAL;
  6918.    IdentPtr = IdentRec;
  6919.    IdentRec = RECORD
  6920.                 IdentStr: ARRAY [0..15] OF CHAR;
  6921.                 RefCount: CARDINAL;
  6922.                 Next:     IdentPtr;
  6923.               END;
  6924.  
  6925. Zurück zum {Typen}-Menü.
  6926.  
  6927. .topic PROCEDURE
  6928.  
  6929.   PROCEDURE ▄
  6930.  ▀▀▀▀▀▀▀▀▀▀▀▀
  6931.  
  6932. Modula-2 implementiert den Typ PROCEDURE als Zeiger auf eine Prozedur.
  6933.  
  6934. Zurück zum {Typen}-Menü.
  6935.  
  6936. .topic ReservedWord, ABS, AND, CAP, CHR, DEC, DIV, INC, MOD, NOT, ODD, ORD, VAL, FAR, NEAR, HALT
  6937.  
  6938.   Reservierte Worte ▄
  6939.  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  6940.  
  6941. Ein Teil der Befehle in Modula gehört zum Sprachumfang und kann auch in
  6942. dem Buch "Programming in Modula-2" von N. Wirth nachgelesen werden.
  6943.  
  6944. Hier sind nur die wichtigsten Standardprozeduren und Standardoperatoren
  6945. aufgeführt:
  6946.  
  6947.  ▄ Prozeduren
  6948.  ▀▀▀▀▀▀▀▀▀▀▀▀▀
  6949.  
  6950.  
  6951.  ABS(x)  : Absoluter Wert eines numerischen Operanden x
  6952.  CAP(x)  : Umwandlung eines Zeichens (x) in seinen Großbuchstaben
  6953.  CHR(x)  : Das Zeichen {CHAR} mit dem ordinalen Wert x
  6954.  DEC(x)  : Verkleinere x um 1
  6955.  FAR     : Adreß-Zuweisung
  6956.  HALT    : Beendet das Programm
  6957.  INC(x)  : Vergrößere x um 1
  6958.  NEAR    : Adress-Zuweisung
  6959.  ODD     : {TRUE}, falls der ordinale Wert X eine ungerade Zahl ist.
  6960.  ORD(X)  : Der {CARDINAL}-Wert des Arguments X
  6961.  VAL(t,x): Der Wert x konvertiert zum TYP t
  6962.  
  6963.  ▄ Operatoren
  6964.  ▀▀▀▀▀▀▀▀▀▀▀▀▀
  6965.  
  6966.  ╒═════╤══════════════╤══════════════╤══════════════╕
  6967.  │ Op. │ INTEGER/CARD.│     REAL     │    SET       │
  6968.  ╞═════╪══════════════╪══════════════╪══════════════╡
  6969.  │ +   │Addition      │Addition      │Vereinigung   │
  6970.  │ -   │Subtraktion   │Subtraktion   │Differenz     │
  6971.  │ *   │Multiplikation│Multiplikation│Durchschnitt  │
  6972.  │ /   │     ---      │Division      │    ---       │
  6973.  │ DIV │Division      │     ---      │    ---       │
  6974.  │ MOD │Modulo        │     ---      │    ---       │
  6975.  ╘═════╧═════════════════════════════╧══════════════╛
  6976.  
  6977. Diese relationalen Operatoren liefern als Ergebnistyp BOOLEAN:
  6978.  
  6979.  ╒═════╤══════════════════════╕
  6980.  │ Op. │     Operation        │
  6981.  ╞═════╪══════════════════════╡
  6982.  │ =   │gleich                │
  6983.  │<> # │ungleich              │
  6984.  │ <   │kleiner als           │
  6985.  │ >   │größer als            │
  6986.  │ <=  │kleiner oder gleich   │
  6987.  │ >=  │größer oder gleich    │
  6988.  ╞═════╪══════════════════════╡
  6989.  │ IN  │"Element von". TRUE,  │
  6990.  │     │wenn der linke Operand│
  6991.  │     │(ordinaler Typ) in der│
  6992.  │     │Menge auf der rechten │
  6993.  │     │Seite enthalten ist;  │
  6994.  │     │FALSE, falls nicht.   │
  6995.  ╘═════╧══════════════════════╛
  6996.  
  6997.  
  6998. Zurück zum {Index}, Ende mit ESC
  6999.  
  7000. .TOPIC IDECopyright
  7001.  
  7002.    M2IDE für Fitted Modula-2 Version 2.0
  7003.  ╚═══════════════════════════════════════╝
  7004.  
  7005.  Copyright 1991 (C) DMV - Daten- & Medien-Verlag, Eschwege
  7006.  Programm von W. Rinke, Hilfetexte von J. Braun
  7007.  geschrieben mit Turbo Pascal(R) 6.0 und TurboVision(R)
  7008.  letzte Änderungen: 29.08.91
  7009.  Ein Projekt der toolbox(R)
  7010.