nnen Sie Ihren Quelltext editieren. Weitere Aktionen werden
ber die Men
leiste durchgef
hrt. Die einzelnen Men
punkte erreichen Sie durch gleichzeitiges Dr
cken der Alt-Taste und des rot hervor- gehobenen Buchstabens.
Sie k
nnen fast beliebig viele Fenster zum Editieren
ffnen, das oberste davon ist aktiv. In ein anderes Edit-Fenster gelangen Sie durch gleichzeitiges Dr
cken der Alt-Taste und der Zahl, die Sie in der oberen rechten Ecke des Edit-Fensters sehen.
Da die FST-Benutzeroberfl
che mit der gleichen Software erstellt wurde wie Turbo Pascal 6.0 (Turbo Vision), verh
lt sich auch der Editor weitestgehend wie sein gro
es Vorbild. '
Editorbefehle
Ctrl+S Zeichen nach links
Ctrl+D Zeichen nach rechts
Ctrl+A Wort nach links
Ctrl+Links Wort nach links
Ctrl+F Wort nach rechts
Ctrl+Rechts Wort nach rechts
Ctrl+R Seite nach oben
Ctrl+C Seite nach unten
Ctrl+E Zeile nach oben
Ctrl+X Zeile nach unten
Home Zeilenanfang
End Zeilenende
Ctrl+PgUp Textbeginn
Ctrl+PgDn Textende
Ctrl+G Zeichen unter dem Cursor l
schen
Ctrl+H Zeichen links vom Cursor l
schen
Ctrl+T Wort l
schen
Ctrl+L Letzes Suchen/Ersetzen wiederholen
Ctrl+M Neue Zeile hinter dem Cursor einf
Ctrl+O Einr
cke-Modus umschalten
Ctrl+U letzte
nderung r
ngig machen
Ctrl+V
berschreiben/Einf
gen umschalten
Ctrl+Y Zeile l
schen
Shift+Ins Text aus Clipboard einf
Shift+Del markierten Text ins Clipboard l
schen
Ctrl+Ins markierten Text ins Clipboard kopieren
Ctrl+Del Clipboard l
schen
Ctrl+Q "Quick"-Befehle
----------------------
+A Text ersetzen
+C Textende
+D Zeilenende
+F Text suchen
+H bis Zeilenanfang l
schen
+R Textbeginn
+S Zeilenanfang
+Y bis Zeilenende l
schen
Ctrl+K Blockbefehle
-------------------
+B Blockbeginn markieren
+C Block einf
+H Blockmarkierung entfernen
+K Block kopieren
+Y Block l
schen
Clipboard
Das Clipboard (Zwischenablage) ist ein normalerweise unsichtbares Edit-Fenster. In der Zwischenablage k
nnen immer wieder ben
tigte Textpassagen aufbewahrt werden, um sie bei Bedarf in das aktitve Edit-Fenster einzuf
gen. Auch der Transfer von markierten Textbl
cken von einem Edit-Fenster in ein anderes geht
ber das Clipboard. Mit Show
Clipboard
nnen Sie die Zwischablage aktiv machen und auch den Text des Clipboards mit SaveAs
sichern.
Make
Unter dem Men
punkt "Make" sind alle Aufrufe des FST-Modula-2-Compilers untergebracht.
Build
Der Compiler wird mit der Option "/M" aufgerufen und compiliert alle Dateien neu. Der interne Zeitstempel wird aktualisiert. Voraussetzung f
r eine erfolgreiche Compilation unter diesem Men
punkt ist die vorherige Erzeugung einer "Make-Datei". Sie k
nnen dazu den Men
punkt GenMake
verwenden.
GenMake
GenMake erzeugt die Datei, die zur Recompilierung aller beteiligten Module notwendig ist. Das Hauptmodul mu
zuvor unter dem Men
punkt Primary
angew
hlt sein.
Compile
Compiliert die Datei im aktiven Fenster. Die Datei mu
zuvor gesichert werden.
Link
Verbindet die compilierten Dateien (.M2O) zu einem lauff
higen (.EXE) Programm. Das Hauptmodul mu
unter dem Men
punkt Primary
eingetragen sein.
Files
Unter diesem Men
punkt sind alle Dateioperationen untergebracht.
DOS Shell
Sie k
nnen unter diesem Men
punkt vor
bergehend die Entwicklungsumgebung verlassen und ein DOS-Programm starten (vorausgesetzt, der verbleibende Speicherplatz ist ausreichend).
Debug
Unter diesem Men
punkt sind alle Operationen untergebracht, die Ihr Programm zum Debuggen mit einem externen Debugger (vorzugsweise Turbo Debugger) vorbereiten.
MAP-File erzeugen
Erzeugt eine MAP-Datei, in der alle externen Referenzen (Prozeduren und Variablen aus anderen Modulen) aufgelistet sind. Der externe Debugger ben
tigt diese um zum Beispiel Variableninhalte anzeigen zu k
nnen. Im Hauptmodul mu
der Compilerschalter (* $L *) (generiere Zeilennummern) gesetzt sein. Das Programm mu
vor dem Erzeugen der Map-Datei fehlerfrei compiliert und gelinkt werden.
Debugging vorbereiten
ngt die symbolischen Informationen an die erzeugte .EXE-Datei an. Die meisten Debugger ben
tigen Variablen- und Prozedurnamen, um sowohl den Maschinencode des erzeugten Programms als auch den Quelltext darstellen zu k
nnen. Zuvor mu
das Programm fehlerfrei compiliert und gelinkt werden, die Map-Datei mu
ebenfalls bereits erzeugt sein.
Error Dateien ansehen
ffnet ein Auswahlfenster mit den von den aufgerufenen Werkzeugen erzeugten .ERR-Dateien. Diese Dateien zeigen das, was Sie gesehen h
tten, wenn Sie die Programme von der Kommandozeile aus gestartet h
tten.
Datei
ffnen
sentiert ein Auswahlfenster, in dem Sie die Datei, die Sie editieren m
chten, anw
hlen k
nnen. Die vorgegebene Erweiterung ist .DEF oder -
.MOD, je nachdem, welche Default
Extension
Sie mit dem dem Schalter im Options-Men
eingestellt haben.
Verzeichnis wechseln
Erzeugt ein Dialogfenster, in dem Sie das aktuelle Verzeichnis neu bestimmen k
nnen.
Hauptmodul w
hlen
Unter diesem Men
punkt m
ssen Sie das Hauptmodul angeben.
Optionen
Dieser Men
punkt fa
t alle festen Einstellungen der Entwicklungsumgebung zusammen.
Optionen sichern
Sichert die aktuell eingestellten Optionen der Entwicklungsumgebung in der Datei M2IDE.CFG. Ist die Datei nicht im aktuellen Verzeichnis, gibt die Entwicklungsumgebung die meisten Einstellungen gem
der Installation vor. Sie m
ssen, wenn die Konfigurationsdatei versehentlich gel
scht wurde, die Einstellungen neu vornehmen. Besonders wichtig ist dabei die Vorgabe der Verzeichnisse
r die Programme des FST-Entwicklungspakets.
Optionen laden
dt die gespeicherten Optionen aus der Datei M2IDE.CFG.
Turbo Debugger starten
Startet den Turbo Debugger. Wenn Sie Ihr Programm ordnungsgem
zum Debuggen vorbereitet haben, k
nnen Sie den Programmlauf im erzeugten Maschinencode und im Quelltext Schritt f
r Schritt nachvollziehen.
Entwicklungs-Schalter
Ist der Schalter aktiv (
), werden alle zur Erzeugung des lauff
higen Programms ben
tigten Dateien nicht gel
scht. Wenn Ihr Programm fehlerfrei l
uft, k
nnen Sie den Schalter deaktivieren. Die erzeugte .EXE-Datei wird etwa 50% kleiner.
ber das Programm
Wie allgemein
blich, haben sich die Programmierer unter diesem Men
punkt "verewigt". Bei Problemem mit dem Programm geben Sie bitte die Versionsnummer an.
System
Dieser Men
punkt fa
t zun
chst nur das Programmierer-Fenster (About) und den Wort-Kontext (f
r die kontext-sensitive Hilfe zu FST Modula 2) zusammen.
IDE Verlassen
Beendet das Programm und bringt Sie sicher zur
ck zum DOS-Prompt. Sollten noch ungesicherte Dateien ge
ffnet sein, werden Sie vor dem endg
ltigen Abschied noch einmal gefragt.
Verzeichnisse
Bitte geben Sie hier die Pfade an, in denen Sie die Entwicklungswerkzeuge des FST-System gespeichert haben.
Batches l
schen
Ist der Schalter aktiv, werden die von der IDE erzeugten Batch-Dateien gel
scht. Sie sollten den Schalter so lange deaktiv lassen, bis Ihr Programm fehlerfrei l
uft.
.BAK anlegen
Der Editor legt von der aktuellen Datei eine Sicherheitskopie mit der Extension .BAK an, wenn der Schalter aktiv (
) ist.
Verzeichnis wechseln
Es erscheint ein Dialog, in dem Sie auf dem Verzeichnisbaum des aktuellen Laufwerks ein neues Verzeichnis anw
hlen k
nnen, in dem Sie weiterarbeiten m
chten. Auch das Laufwerk k
nnen Sie unter diesem Men
punkt wechseln.
Neue Datei
ffnet ein leeres Edit-Fenster mit dem Arbeitstitel "untitled". Sie k
nnen einen Text eingeben und ihn dann mit SaveAs
mit einem neuen Namen versehen.
Clipboard ansehen
In der Zwischenablage Clipboard werden markierte Bl
cke zwischengespeichert. Ist das Clipboard aktiv, k
nnen Sie die dort abgelegten Texte editieren.
Fenster nebeneinander
Nach dem Anw
hlen dieses Men
punkts werden die ge
ffneten Fenster mit Ausnahme des Clipboard nebeneinander auf dem Bildschirm "ausgebreitet". Mit Zoom
nnen Sie das aktive Fenster (erkennbar an der Rahmenfarbe) auf volle Gr
e bringen.
Datei sichern als
Dieser Men
punkt f
chert die ge
ffneten Fenster zu einem Stapel auf. Die Nummern in der rechten oberen Ecke dienen zur Anwahl des Aktiven Fensters. Mit Zoom
nnen Sie das aktive Fenster (erkennbar an der Rahmenfarbe) auf volle Gr
e bringen.
Datei sichern
Speichert die Datei auf dem Datentr
ger. Soll die Datei einen anderen Namen erhalten oder in einem anderen als dem aktuellen Verzeichnis abgelegt werden, m
ssen Sie den Men
punkt SaveAs
hlen.
Datei sichern als
Es erscheint ein Dialogfenster, in dem Sie den Namen eingeben k
nnen, unter dem Sie den Text im aktiven Fenster sichern m
chten. Sie k
nnen allerdings auch einen Namen aus der Datei
bersicht w
hlen und eine bereits vorhandene Datei
berschreiben.
Edit
Unter diesem Men
punkt sind spezielle Editor-Befehle zu finden.
ngig machen
Macht die letzte
nderung r
ngig.
Block "ausschneiden"
Der markierte Block wird aus den aktiven Edit-Fenster ausgeschnitten und vorerst auf dem Clipboard abgelegt. Wenn Sie den Text an einer anderen Stelle im Text einf
gen m
chten Paste
ssen Sie dies vor dem n
chsten Ausschneiden tun, da immer nur ein "Textschnipsel" in der Zwischenablage Platz findet.
Block kopieren
Kopiert den markierten Block in die Zwischenablage Clipboard. Mit Paste
nnen Sie den Block an anderer Stelle wieder einf
gen.
Siehe auch : Editor
Text "einkleben"
gt einen Textblock aus der Zwischablage an der Cursorposition in das aktive Edit-Fenster ein.
Textblock l
schen
scht den markiertene Textblock.
Suchen und Ersetzen
Unter diesem Men
punkt sind Operationen zu finden, die es Ihnen erm
glichen, Textstellen schnell aufzufinden sowie Zeichenketten durch andere zu ersetzen.
Textstelle suchen
ffnet einen Dialog, in dem Sie eine Zeichenkette eigeben k
nnen, die im aktiven Edit-Fenster gesucht werden soll. Die Suche kann sich auf ganze Worte beziehen (Whole words only [X]) und unabh
ngig von der Gro
-/Kleinschreibung erfolgen (Case sensitive [ ]). Die letzten f
nf Suchbegriffen k
nnen Sie im History-Fenster ausw
hlen, das sich
ffnet, wenn Sie den gr
nen Pfeil neben der Eingabezeile anw
hlen. %
Tastatur-Kurzanwahl : Ctrl+Q F
Suchen und Ersetzen
Wie unter dem Men
punkt Find
nnen Sie eine Zeichenkette eingeben, die gesucht werden soll. Auf der Eingabezeile "New Text" tragen Sie den Text ein, der den Suchbegriff ersetzen soll. Ist "Prompt on Replace" aktiv [X], werden Sie vor jedem Ersetzen gefragt, "Replace all" [X] ersetzt alle gefundenen Begriffe. %
Tastatur-Kurzanwahl : Ctrl+Q A
Suchen/Ersetzen wiederholen
Tastatur-Kurzanwahl : Ctrl+L
Fenster
t die Operationen zur Gestaltung der Arbeitsoberfl
che (Desktop) zusammen.
Gr
e ver
ndern
Die Anwahl dieses Men
punkts
ndert die Rahmenfarbe und zeigt eine neue Statuszeile. Mit den Pfeiltasten k
nnen Sie die Gr
e des aktiven Fensters ver
ndern und es auf dem Desktop verschieben. $
Tastatur-Kurzanwahl : Ctrl-F5
Vollbild
Bringt das aktive Fenster zur vollen Gr
e. Die Anwahl dieses Men
punkts hat die gleiche Funktion wie ein Anklicken des Pfeils in der oberen rechten Ecke des Fensters.
Tastatur-Kurzanwahl : F5
chstes Fenster aktivieren
Macht das n
chste Fenster im Fensterstapel auf der Arbeitsoberfl
che aktiv.
Tastatur-Kurzanwahl : F6
Voriges Fenster aktivieren
Macht das vorige Fenster im Fensterstapel aktiv. %
Tastatur-Kurzanwahl : Shift-F6
Fenster schlie
Schlie
t das aktive Fenster. Ist die Datei nicht gesichert, werden Sie gefragt, ob Sie den Text speichern wollen. Die Anwahl des Men
punkts hat die gleiche Funktion wie ein Anklicken des "Schlie
en"-Knopfes in der oberen linken Ecke des Fensters. #
Tastatur-Kurzanwahl : Alt-F3
Cursor auf Zeile/Spalte
ffnet ein Dialogfenster, in dem Sie die Zeile und die Spalte angeben k
nnen, auf die der Cursor gesetzt werden soll. Diese Funktion ist bei der Bereinigung von syntaktischen Fehlern aus der Datei COMPILER.ERR n
tzlich.
Wort Context
Wenn es zu diesem Wort im Text einen Hilfebegriff gibt, wird das zugeh
rige Hilfefenster ge
ffnet. $
Tastatur-Kurzanwahl : Ctrl-F1
Default Extension
Der Schalter setzt die vorgegebene Dateinamen-Erweiterung f
r die Dateiauswahldialoge.
Hilfe-Index
Standard-Module Modula-Schleifentypen
Routinen Standard-Typen
ASCII-Zeichen Tastaturcodes
Compilerschalter Inline-Assembler
Laufzeitfehler Reservierte
Worte
Sprachkonventionen Compiler-Begrenzungen
Objekt-Zeitstempel Environment-Variablen
Ende mit ESC
Modul-Index
ASCII Break
Directories Display
DTA Files
FileSpec FileSystem
InOut KeyBoard
Loader LongJump
Menu LMathLib0/MathLib0
NumberConversion Paths
RealConversion RealInOut
Storage Strings
SYSTEM System
TermBase Terminal
TermIO TimeDate
Windows
ck zum Index, Ende mit ESC
Liste der Standandprozeduren
Prozeduren A - E:
ADR ALLOCATE
Append arctan
ASCIIZ Assign
AssignGoto AssignRead
AssignWrite Available
CardToString ChDir
Close CloseCurWindow
CloseInput CloseOutput
CloseWindow ClrEOL
ClrEOS ClrScreen
CompareStr Concat
Copy cos
Create CreateNew
CreateTemp DEALLOCATE
Delete DirQuery
DisableBreak DisplayLine
DisplayString DISPOSE
DropExt Dup2
Dup EnableBreak
entier ErrorMessage
ErrorLn Execute
exp ExtractDirPath
ExtractFileName
Weiter
ck zum Index, Ende mit ESC /
Liste der Standandprozeduren
Prozeduren F - P:
FLAT FLOAT
GetArg GetCurDir
GetCursorPosition GetDisplayMode
GetDTA GetEnv
GetFileAttr GetFileTime
GetFirstDir GetFunKey
GetKey GetKeyCh
GetLPos GetNextDir
GetPos GetShiftStatus
GetTime GetVector
Goto HasExt
Insert InstallBreakHandler
IntToString InstallRTErrorHandler
KeyPressed Length
LLength ln
Locate Lock
LongCardToString LongIntToString
LongJump LongNumToString
LongRealToString LookUp
MkDir Move
NEW NEWPROCESS
NewWindowTitle NumToString
OFFSET Open
OpenInput OpenOutPut
OpenWindow ParseFileSpec
PopMenu Pos
PTR PullDownMenu
Weiter
ck zum Index, Ende mit ESC
Liste der Standandprozeduren
Prozeduren P - T:
real Read
ReadAgain ReadCard
ReadChar ReadCharAttr
ReadInt ReadLine
ReadLongCard ReadLongInt
ReadNBytes ReadReal
ReadScreen ReadString
ReadWord ReadWrd
RealToString RedirectInput
RedirectOutput Rename
Reset ResetVector
Rewrite RmDir
ScrollDown ScrollUp
Seek SEGMENT
SelectWindow SetCursorPosition
SetCursorType SetDisplayMode
SetDTA SetFileAttr
SetFileTime SetJump
SetLPos SetPos
SetTime SetVector
SHORT sin
sqrt StringToInt
StringToLongCard StringToLongInt
StringToLongNum StringToLongReal
StringToNum StringToReal
Terminate TermProcedure
TRANSFER Trap
TRUNC
Weiter
ck zum Index, Ende mit ESC
Liste der Standandprozeduren
Topics ab U:
UnAssignGoto UnAssignRead
UnAssignWrite UninstallBreakHandler
Unlock UninstallRTErrorHandler
Write WriteCard
WriteChar WriteCharAttr
WriteHex WriteInt
WriteLine WriteLn
WriteLongCard WriteLongInt
WriteNBytes WriteOct
WriteReal WriteScreen
WriteString WriteWord
WriteWrd XTrap
ck zum Index, Ende mit ESC
der integrierte Assembler
Es ist ein 8086 Inline-Assembler eingebaut.
Wenn der ASSEMBLER aus SYSTEM importiert ist, k
nnen Sie im Quelltext Assembler-Code eingeben. Dieser mu
nur mit den Schl
sselworten ASM und END eingeklammert werden. ^
Die Form des Assembler-Codes ist frei. Kommentare werden wie in Modula-2
blich eingegeben. E
Die Zeilen d
rfen nicht mit einem Strichpunkt abgeschlossen werden.
Beispiele:
loop: CMP BYTE [SI], 0
(* String-Ende erreicht? *)
MOV BYTE [DI], [SI]
INC SI
INC DI (* Zeiger erh
hen *)
JMP loop
PROCEDURE SHR(in, shifter: CARDINAL): CARDINAL:
VAR
out: CARDINAL;
BEGIN
ASM
MOV AX, in
MOV CX, shifter
SHR AX, CL
MOV out, AX
END;
RETURN out;
END SHR;
Der Assembler akzeptiert alle 8086/8088-Mnemonics. Adre
-Operanden k
nnen in jeder Form codiert werden, die auch andere Assembler verstehen, mit der Einschr
nkung, da
der einzige verf
gbare Operator "+" ist. z
Typ-Bestimmungen sind: WORD, BYTE, FAR, NEAR und sie d
rfen nicht von den Schl
sselworten POINTER oder PTR gefolgt sein.
Beispiel:
label: MOV AX, ES:[BX,DI+5]
MOV AX, ES:5[DI+BX]
MOV WORD [5], 1
CALL NEAR [DI]
TEST BYTE i+2, 1
Alle Mnemonics und Registernamen m
ssen in Gro
buchstaben geschrieben sein. Wenn Sie auf einen Modula-2-Bezeichner zugreifen wollen, jedoch dabei in Konflikt mit einem im Assembler reservierten Symbol kommen, stellen Sie einfach ein "@" voran.
Beispiel:
MOV @AX, AX
generiert einen Move von Register AX nach Variable AX. =
Alle Modula-2-Variablen sind grunds
tzlich vom Assembler aus zug
nglich. Record-Komponenten-Namen sind nicht zug
nglich. Der Assembler tut f
r Sie nichts automatisch! Wenn Sie beispielsweise einen VAR-Parameter als Operanden einsetzen, m
ssen Sie
ber die Zeiger-Adresse auf den tats
chlichen Parameter zugreifen. s
Beispiel:
PROCEDURE p(VAR done: BOOLEAN);
...
ASM
LES DI, done
MOV BYTE ES:[DI], TRUE
END;
ist der korrekte Weg, "done" mit TRUE zu besetzen. J
Auf Konstanten der folgenden Typen kann in Assembler zugegriffen werden: C
INTEGER,
CARDINAL,
BOOLEAN,
CHAR und
Aufz
hlungs-Konstanten.
Alle Marken (Labels) eines ASM-Abschnitts sind lokal zu diesem Abschnitt. Andere Namen, die au
erhalb deklariert sind und die in der Prozedur sichtbar sind, d
rfen nicht als Label-Namen verwendet werden. Auf Labels darf nur in Sprung-Befehlen verwiesen werden. k
Alle Spr
nge werden vom Compiler optimiert. Deshalb braucht die Sprungweite nicht spezifiziert zu werden.
Denken Sie daran, da
dies ein Modula-2-Compiler ist, kein Assembler! Der Inline-Assembler ist nur f
r den Gebrauch in Ausnahmesituationen gedacht. -
8087 Unterst
tzung
Alle Befehle des Coprozessors 8087 werden vom Inline-Assembler verarbeitet. Die Zusatzbefehle des 80186 (= 80286-Realmode) werden nicht verstanden und m
ssen im Notfall als Datenbereich mit "DB" eingegeben werden. Labels k
nnen (ohne Deklarierung) eingesetzt werden.
Der Assembler besitzt ein paar Einschr
nkungen. Nur die folgenden Operandentypen sind bei Load- und Store-Operationen m
glich: '
INTEGER, LONGINT, REAL und LONGREAL.
Sie k
nnen kein Load/Store mit einem Wert in tempor
rem Real- oder Dezimal-Format durchf
hren. Die Bedeutung der operandenlosen Form der arithmetischen Befehle wurde beibehalten:
FADD, FSUB, FMUL und FDIV arbeiten
mit den beiden oberen Elementen
des 8087-Stack.
Sie benutzen ST(1) als Ziel und
entfernen ST.
FSUBR subtrahiert ST(1) von
ST (FDIVR dividiert ST durch
ST(1)), wobei das Ergebnis
in ST(1) abgelegt und ST entfernt
wird.
Das Zwei-Operanden-Format der arithmetischen Befehle wurde nicht implementiert. Daher d
rfen Sie kein anderes Zielregister als ST angeben, au
er bei den "und pop"-Versionen der Befehle.
Mit einem normalen Assembler k
nnen Sie bei Register-Register-Operationen dasjenige Register angeben, in welchem das Ergebnis der Operation abgelegt werden soll (das Zielregister). Per Definition ist das Zielregister auch der erste Operand des Befehls. Mit dem Inline-Assembler ist jedoch immer ST das Ziel einer Operation. Ausnahme sind die "und pop"-Versionen der Befehle, bei denen das im jeweiligen Befehl angegebene Register das Ziel der Operation ist. q
Um die Konsistenz zu wahren, sollte ST immer der erste Operand sein, auch wenn die "und pop"-Form benutzt wird. =
Die Bedeutung von FSUBP, FSUBRP, FDIVP und FDIVRP ist also:
FSUBP ST(1) bedeutet:
FSUBRP ST(1),ST -> ST(1):=ST-ST(1)
FSUBRP ST(1) bedeutet:
FSUBP ST(1),ST -> ST(1):=ST(1)-ST
FDIVP ST(1) bedeutet:
FDIVRP ST(1),ST -> ST(1):=ST/ST(1)
FDIVRP ST(1) bedeutet:
FDIVP ST(1),ST -> ST(1):=ST(1)/ST und ST wird entfernt (pop).
Beispiel:
VAR
wert: WORD;
BEGIN
ASM
...
@wert:
...
MOV wert, BX
CMP BX, CX
JNZ @wert
...
END;
Eine Liste der Assembler-Befehle der Intel-Prozessorenreihe kann (mit der jeweiligen Beschreibung) jedem Assembler-Buch entnommen werden).
ck zum Index, Ende mit ESC
Modula-2-Schleifentypen
Modula bietet mehr Schleifentypen als Pascal. Die Syntax der Schleifen weicht ebenfalls von Pascal ab. F
LOOP-Schleife (Endlosschleife):
Die Abbruchbedingung mu
explizit in der Schleife mit "EXIT" erfolgen: D
LOOP
(* mach irgendwas *)
IF bedingung THEN EXIT;
END;
FOR-Schleife (einfache Z
hlschleife):
FOR var1 TO var2 [[BY] [-]var3] DO
(* abarbeiten *)
END;
"BY" ist optional und gibt die Sprungweite beim Schleifendurchgang (identisch zum STEP-Befehl in BASIC) an. *
Einfache Bedingung mit "IF":
IF bedingung1 THEN
(* mach irgendwas *)
[ELSIF bedingung2]
(* mach irgendwas anderes *)
[ELSE]
(* mach irgendwas ganz anderes *)
END;
Einfache Bedingung mit "CASE":
CASE var1 OF
wert1: (* mach was *)
[| wert2: (* mach was anderes *)]
[| wert3: (* mach wieder was anderes *)]
ELSE (* fang den Rest ab *)
END;
Kopfgesteuerte "WHILE"-Wiederholanweisung:
WHILE [NOT] bedingung DO
(* eine Schleife abarbeiten *)
END;
Die Bedingung mu
beim Einsprung erf
llt sein. Die Schleife wird verlassen, wenn die Bedingung nicht mehr erf
llt ist. U
Falls die Bedingung anfangs nicht erf
llt wird, wird die Schleife nicht ausgef
hrt. )
gesteuerte REPEAT-Wiederholanweisung:
REPEAT
(* mach was *)
UNTIL [NOT] bedingung;
Die Bedingung darf beim Einsprung erf
llt sein (mu
aber nicht). G
Dieser Schleifentyp wird grunds
tzlich mindestens einmal durchlaufen. )
Abarbeiten von RECORD-Abweisungen:
WITH Persons[i] DO
IF (Age < 4) THEN
(* Kleinkind *)
[ELSEIF (Age < 15) THEN]
(* Jugendlicher *)
[ELSE]
(* Erwachsener *)
END;
END;
WITH-Anweisungen werden benutzt, damit die Felder eines RECORDs als Schleifenvariablen genutzt werden k
nnen.
ck zum Index
Modula kontra Pascal: Konventionen
Modula ist Case-sensitiv, d.h. Klein-
und Gro
schreibung werden wie in C und
im Gegensatz zu Pascal unterschieden.
Trennung von DEFINITION (.DEF) und
IMPLEMENTATION (.MOD) in getrennten Dateien.
Beenden von Prozeduren mit END ModulName.
Hinter Prozeduren Ende mit Semikolon (;),
am Ende von Modulen mit Punkt (.).
Nur das Hauptmodul bekommt die Bezeichnung
MODULE ModulName; sonst mu
festgelegt
werden, ob es sich um ein Definitions-
oder Implementationsmodul handelt.
In DEFINITION-Modulen d
rfen nur Variablen,
Typen, Konstanten und Prozedurk
pfe stehen.
Im Unterschied zu Turbo Pascal-Unit-
Implementationen d
rfen keine Codeteile
eingebunden sein.
Die Modula-Definitionsdateien dienen nur dem Im- und Export. Dieser kann qualifiziert oder unqualifiziert erfolgen.
Beispiel:
IMPORT ASCII; (* Qualifizierter Import *)
(* vergleichbar mit dem Import *)
(* von Turbo-Pascal-Objekten. *)
FROM Files IMPORT Write, WriteChar;
(* Unqualifizierter Import. *)
FROM FileSpec IMPORT ;
(* Import des gesamten Defi- *)
(* nitionsteiles eines Moduls *)
(*
quivalent zum Import von *)
(* Turbo-Pascal Units. *)
Der unqualifizierte Import von gleichnamigen Prozeduren aus mehreren Modulen ist nicht m
glich: 5
FROM Files IMPORT Write;
FROM InOut IMPORT Write;
Der zweite Import wird vom Compiler beanstandet. Hier ist es nur m
glich, mindestens ein Modul qualifiziert zu importieren: 2
IMPORT Files;
FROM Inout IMPORT Write;
Prozeduren mit R
ckgabewert (Funktionsparametern):
Im Gegensatz zu Pascal gibt es in Modula keine Funktionen (FUNCTION). Dies wird dadurch umgangen, da
Prozeduren ebenfalls einen Parameter zur
ckgeben k
nnen. Allerdings mu
dieser ein ordinaler Typ sein. Zusammengesetzte Typen d
rfen nicht verwendet werden.
Die Pascal-Funktion:
FUNCTION MessageBack: STRING;
ist aus diesem Grund nicht m
glich.
Der Typ "ARRAY OF CHAR" der dem Pascal-String entspricht, ist kein ordinaler Typ und kann deshalb nicht als Funktionsparameter dienen. Die Struktur mu
folglich mit einem VAR-Parameter zur
ckgegeben werden: 2
PROCEDURE MessageBack(VAR Back: ARRAY OF CHAR);
oder mit einem Zeigers auf den String: ?
TYPE
String: ARRAY OF CHAR;
PtrStr: POINTER TO String;
PROCEDURE MessageBack(): PtrStr;
Bei ordinalen Typen kann die Struktur wie in Pascal programmiert werden:
Pascal:
FUNCTION GetBack: BOOLEAN;
BEGIN
GetBack := FALSE;
IF KeyPressed THEN GetBack := TRUE;
END;
Modula:
PROCEDURE GetBack(): BOOLEAN;
vBack: BOOLEAN;
BEGIN
vBack := FALSE;
IF KeyBoard.KeyPressed() THEN
vBack := TRUE;
END;
RETURN vBack; (* R
ckgabe! *)
END GetBack;
Fremdsprachige Module:
Um dem Modula-2-Compiler die n
tigen Informationen
ber die in anderen Sprachen geschriebenen Module verf
gbar zu machen, m
ssen sogenannte FOREIGN-DEFINITION(Fremd-Definitions)-Module geschrieben werden.
Ein FOREIGN-DEFINITION-Modul ist ein normales Definitions-Modul mit einem etwas ver
nderten Modulkopf, der folgenderma
en aussieht: 0
FOREIGN [C|PASCAL] DEFINITION MODULE modName;
wobei der "C"- oder "PASCAL"-Bezeichner optional ist. \
Namen von globalen Variablen und Prozeduren in Fremdmodulen werden auf drei Arten codiert:
Bei einem normalen (weder C noch
PASCAL) FOREIGN-Modul stehen die
Bezeichner so in der Object-Datei
wie Sie sie geschrieben haben.
Bei einem FOREIGN-C-Modul ist vor
jeden Bezeichner ein "_"-Zeichen
gesetzt.
Bei einem FOREIGN-PASCAL Modul werden
alle Bezeichner in Gro
buchstaben
umgewandelt.
WARNUNG: Bei der vorliegenden Implementierung erzeugt der Compiler f
r Zugriffe auf SET- und STRING-Konstanten, die in einem FOREIGN-DEFINITION-Module definiert sind, externe Verweise. F
r diese "Konstanten" sollte daher der Speicherplatz im Fremdmodul liegen und dieser sollte korrekt initialisiert werden. Bei FOREIGN-Modulen wird keine Initialisierungs-Prozedur erwartet und der Compiler erzeugt die entsprechenden Initialisierungs-Aufrufe nur bei normalen Modula-2-Modulen.
FOREIGN-C-Module:
Beim Aufruf eines Unterprogramms in einem FOREIGN-C-Modul werden die Argumente, wie bei C
blich, in umgekehrter Reihenfolge auf den Stack gelegt. Bei der R
ckkehr vom Unterprogramm entfernt au
erdem der Aufrufer selbst die Argumente vom Stack. Da C im Gegensatz zu Modula-2 die
bergabe einer variablen Anzahl von Parametern unterst
tzt, kann in Fitted Modula das Zeichen "." am Ende einer Parameterliste benutzt werden, um anzuzeigen, da
eine unbestimmte Anzahl von Argumenten
bergeben wird. ;
Das Beispiel:
PROCEDURE sum(n: INTEGER; . ): INTEGER;
definiert eine Funktion die aus n Integers die Summe bildet und zur
ckgibt. Sie k
nnte in Modula-2 folgenderma
en definiert werden:
PROCEDURE sum(n: INTEGER; . ): INTEGER;
p: POINTER TO INTEGER;
res: INTEGER;
BEGIN
res := 0;
p := ADR(n) + 2;
WHILE n > 0 DO
res := res + p^;
INC(p, 2);
DEC(n);
END;
RETURN res;
END sum;
Parameter-
bergabe:
Die Form in der die einzelnen Parameter
bergeben werden, ist immer gleich, egal ob sich die Prozedur in einem Fremdmodul befindet oder nicht. Die Ausnahme ist der Gebrauch von ".". Bei der
bergabe von Parametern f
r die im Prozedurkopf der "." steht, folgt der Compiler den
blichen Regeln von C: Alles wird als Wert
bergeben (call by value), lediglich f
r Arrays wird deren Adresse
bergeben (call by reference), anstatt deren Wert.
In Modula-2 k
nnen Funktionen keine zusammengesetzten Typen zur
ckgeben. Manche C-Compiler erm
glichen dies, indem im Registerpaar DX:AX ein Zeiger auf diese Werte zur
ckgegeben wird. Auf die gleiche Art und Weise verf
hrt Fitted Modula-2 mit Zeigern! '
Also k
nnte man wie folgt definieren:
struct someStruct cfunct()
als 1
TYPE
someStructPtr = POINTER TO someStruct;
PROCEDURE cfunct(): someStructPtr;
ck zum Index
Zeitstempel in FST-Modula-2-M2O-Dateien
Der "Module-Header-Record" und die "Import-Records", die der Compiler in die Objekt-Datei schreibt, werden mit dem Datum der benutzten .DEF-Datei markiert - dies ist der Modul-Schl
ssel. Der Linker stellt sicher, da
die Modul-Schl
ssel im Module-Header des importierten Moduls und im Import-Record
bereinstimmen. Ist dies nicht der Fall, dann wurde beim Compilieren nicht das gleiche Definitions-Modul benutzt. Wegen des Gebrauchs dieser Modul-Schl
ssel ist es zwingend erforderlich, da
das jeweilige Datum der .DEF-Dateien nicht ver
ndert wird, au
er wenn beabsichtigen ist, die Implementierungen neu zu compilieren.
Wichtig:
Wenn OBJ-Dateien benutzt werden, besteht dieser Schutz durch die Modul-Schl
ssel nicht.
ck zum Index
Environment-Variablen
Die grundlegenden Bedingungen des Fitted-Modula-Compilers k
nnen
ber Environment-Variablen gesteuert werden:
Ausgabeformat der Objektdateien:
M2OUTPUT=[M2O|OBJ]
Pfad zu den Bibliotheken/Objektdateien:
M2LIB=pfad
Speichermodell:
M2MODEL=[LARGE|HUGE]
Es mu
darauf geachtet werden, da
der DOS-Umgebungsbereich ausreicht. Falls die DOS-Meldung "Out of Environment Space" bzw. "Nicht genug Platz im Umgebungsspeicher" erscheint, mu
die Gr
e des Environments angepa
t werden. Dies erfolgt mit dem /E:-Parameter beim Shell-Aufruf in der CONFIG.SYS: 1
SHELL=[pfad]COMMAND.COM /E:<Gr
e in Bytes> /P
M2MODEL:
Der Compiler erzeugt Code f
r die Intel 8086 Speichermodelle "Huge" und "Large": Beim "Huge"-Speichermodell hat jedes Modul sein eigenes Daten- und Codesegment, die jeweils bis zu 64k gro
sein d
rfen; beim "Large"-Speichermodell sind die statischen Daten aller Module in einem einzigen Segment zusammengefa
t. Pointer sind in beiden Modellen vier Bytes lang. Andere Speichermodelle werden zur Zeit nicht unterst
tzt.
Die Umgebungsvariable M2MODEL kann auf "HUGE" oder "LARGE" gesetzt werden, so da
dem Compiler nicht jedesmal das gew
nschte Speichermodell mitgeteilt zu werden braucht (au
er man will sich
ber diese Voreinstellung hinwegsetzen).
Falls M2MODEL nicht definiert ist, nimmt der Compiler als Standard und wegen der Kompatibilit
t mit fr
heren Versionen die Einstellung "HUGE" an. d
Die Einstellung des Speichermodells kann aus Sicherheitsgr
nden nicht aus der IDE ge
ndert werden.
M2LIB:
Sowohl der Compiler als auch der Linker benutzen die Umgebungsvariable M2LIB um auf erforderliche Bibliotheks-Module zuzugreifen (das Format f
r M2LIB entspricht dem f
r DOS PATH).
M2OUTPUT:
Normalerweise werden M2O-Dateien ("Modula-2-Object") erzeugt. Dieses Dateiformat gibt es nur bei diesem Compiler. Es ist speziell f
r die Anforderungen von Modula-2 optimiert. Der Benutzer kann jedoch mittels der Umgebungs-Variablen M2OUTPUT festlegen, da
stattdessen Standard-OBJ-Dateien erzeugt werden. <
Die IDE arbeitet nur mit M2O-Dateien korrekt zusammen, da der Aufruf der beiden Linker M2LINK und LINK nicht kompatibel ist. Falls als Ausgabeformat Intel-OBJ-Dateien verwendet werden sollen, m
ssen die Programme auf der Kommandozeile gebunden werden. Alle anderen Funktionen der IDE arbeiten auch mit OBJ-Dateien.
ck zum Index
Compiler-Begrenzungen:
Der Compiler erlegt Code und Daten die folgenden Gr
enbegrenzungen auf: z
Eine String-Konstante darf 80 Zeichen
nicht
berschreiten. Dies ist auch die
Gr
engrenze f
r jeden Bezeichner.
Beim "HUGE"-Speichermodell erh
lt jedes
Modul sein eigenes Datensegment, welches
bis zu 64k gro
sein kann. Im Datensegment
organisiert der Compiler alle globalen
Variablen des Moduls und einige seiner
Konstanten.
Beim "LARGE"-Speichermodell werden die
Daten aller Module beim Linken in ein
einziges Datensegment (maximal 64 kBytes)
gepackt.
Die maximale Gr
e einer Datenstruktur
ist 65532 Bytes.
Die lokalen Variablen einer Prozedur d
chstens 32000 Bytes Speicherplatz einnehmen.
Ein Parameter der durch "Call-by-value" einer
Prozedur
bergeben wird darf h
chstens 65000
Bytes gro
sein.
Interne Grenzen des Compilers:
Die maximale Anzahl namentlich
verschiedener Variablen, die der
Compiler bei einem Lauf bew
ltigen
kann, ist 2000. Diese Zahl kann
beim Aufruf des Compilers ge
ndert
werden.
Die Gesamtzahl der Buchstaben in
den Variablennamen darf 12000
nicht
berschreiten. Diese Zahl
kann beim Aufruf des Compilers
ge
ndert werden.
Eine einzige Prozedur kann nicht
mehr als 10k Objektcode umfassen.
Alle initialisierten Daten eines
Moduls sind in einem 8k gro
Feld organisiert. Dies bewirkt
eine Begrenzung der Gesamtzahl an
String-, Real- und Long-Konstanten
eines Moduls.
Diese Ausgabe des Compilers
bersetzt Programme, die in der Sprache Modula-2 geschrieben sind, wie sie von Niklaus Wirth in der 3. Auflage seines Buches "Programming in Modula-2" definiert ist, mit folgenden Ausnahmen: O
Der arithmetische
berlauf von INTEGER
und CARDINAL bleibt unentdeckt.
ASM ist ein reservierter Bezeichner.
r Programmierer, die in der "Hex-Welt"
aufgewachsen sind, gibt es eine M
glichkeit,
CHAR-Literale ("Literal" = direkt im
Quelltext stehender Wert) hexadezimal zu
definieren: 20X entspricht dem
Leerzeichen ("space") in ASCII.
Fitted-Modula-2 Version 2.0 besitzt zwei Bugs, die nicht tragisch sind, aber eine Abweichung zur Modula-Standardsyntax hervorrufen: V
Vor dem ersten Zweig einer CASE-
Verzweigung darf kein Pipezeichen (|) stehen:
CASE x OF
| 1: ...;
| 2: ...;
ist nicht zul
ssig! Es mu
CASE x OF
1: ...;
| 2: ...;
Auch leere Prozeduren m
mit einem BEGIN anfangen:
PROCEDURE p;
BEGIN
END p;
Das in Modula-2 normalerweise erlaubte:
PROCEDURE p;
END p;
ist nicht zul
ssig.
Die fr
heren Auflagen der Wirth'schen Sprachdefinition enthalten zus
tzlich Ausdr
cke wie EXPORT oder EXPORT QUALIFIED. Diese Bezeichener werden nicht unterst
tzt, in der Regel f
hren sie aber nicht zu Fehlermeldungen sondern werden ignoriert.
ck zum Index
Rename
Mit Rename werden Dateien umbenannt oder vom einen zum anderen Verzeichnispfad verschoben. Q
Rename ist mehrfach (mit unterschiedlichen Optionen und F
higkeiten) definiert: =
Files.Rename
FileSystem.Rename
Directories.Rename
ck zum Index oder zu Routinen
Create
Legt eine neue Datei an: "
Files.Create
FileSystem.Create
ck zum Index oder zu Routinen
WriteLine
Terminal.WriteLine
InOut.WriteLine
identisch mit:
WriteString(string); WriteLn;
ck zum Index oder zu Routinen
SetFileTime
Setzen des Datum und der Uhrzeit einer Datei. 3
Files.SetFileTime
Directories.SetFileTime
Siehe auch: GetFileTime. #
ck zum Index oder zu Routinen
GetFileTime
Lesen von Erstellungsdatum und -uhrzeit einer Datei. -
Files.GetFileTime
Directories.GetFileTime
Siehe auch: SetFileTime. #
ck zum Index oder zu Routinen
WriteString
Prozeduren:
InOut.WriteString
Terminal.WriteString
ck zum Index oder zu Routinen
Write
Konstanten:
Files.WRITE
Prozeduren:
Files.Write
Display.Write
Terminal.Write
TermIO.Write
InOut.Write
TermBase.Write
siehe auch:
WriteChar, WriteWord und WriteNBytes;
bei den verwandten Prozeduren:
WriteLn, WriteString und WriteLine
sowie der Komplement
rprozedur Read
ck zum Index oder zu Routinen
WriteChar
Schreibt ein Zeichen CHAR.
Display.WriteChar
FileSystem.WriteChar
ck zum Index oder zu Routinen, siehe auch Write.
KeyPressed
berpr
fung, ob ein Zeichen im Tastaturpuffer liegt.
KeyBoard.KeyPressed
TermBase.KeyPressed
TermIO.KeyPressed
Terminal.KeyPressed
siehe auch: GetKey
ck zum Index oder zu Routinen
Goto
Die Prozedur positioniert den Cursor auf dem Textbildschirm. =
Display.Goto
Terminal.Goto
TermBase.Goto
TermIO.Goto
Goto it KEINE Sprunganweisung innerhalb des Programmes auf ein Label! Dergleichen gibt es in Modula-2 nicht. &
Das Pseudomodul SYSTEM ist nicht wie die anderen Standardmodule extern definiert. Allerdings stehen die Definitionen aus SYSTEM auch nur dann zur Verf
gung, wenn sie IMPORTed werden, obwohl es kein Definitionsmodul gibt. w
SYSTEM ist NICHT identisch mit der Standard-Unit "System". Es handelt sich um die DOS-spezifische Laufzeitbibliothek. :
In SYSTEM definierte reservierte Worte (Reserved words):
SEG, OFS, ASM, ASSEMBLER
In SYSTEM deklarierte Typen:
ADDRESS, BYTE, WORD
In SYSTEM deklarierte Prozeduren:
NEW DISPOSE
LONG SHORT
SEGMENT OFFSET
ADR FLAT
PTR NEWPROCESS
TRANSFER IOTRANSFER
TRUNC FLOAT
ck zum Index oder zu Routinen
SYSTEM.SEG / .OFS
SEG und OFS sind Komponenten des POINTER-Typs. Wenn diese importiert werden, kann in normaler Syntax auf den Segment- oder den Offset-Teil eines Zeigers zugegriffen werden.
Beispiel: d
pointer.SEG: Segment-Teil des Zeigers "pointer".
pointer.OFS: Offset-Teil des Zeigers "pointer".
ck zum Pseudomodul SYSTEM
SYSTEM.ASM
Das in Fitted-Modula-2 reservierte Wort "ASM" leitet eine Assembler-Anweisung ein. Jeder Bereich mit Inline-Assembler mu
mit ASM / END eingeschlossen sein. T
Beispiel:
PROCEDURE AsmDemo;
BEGIN
ASM
....
END;
END AsmDemo;
Kommentare m
ssen Modula-
blich eingeklammert werden. Alle Assembler-Bezeichner m
ssen in Gro
buchstaben geschrieben sein. Der ASSEMBLER mu
zuvor aus dem Pseudomodul SYSTEM importiert werden.
ck zum Pseudomodul SYSTEM
"ASSEMBLER"-Befehl:
Um den Inline-Assembler (ASM) verwenden zu k
nnen, mu
vorher der Assembler mit:
FROM SYSTEM IMPORT ASSEMBLER;
importiert werden.
ck zum Pseudomodul SYSTEM
TYPE SYSTEM.ADDRESS
Der Typ ADDRESS ist zu allen Zeiger-Typen kompatibel. ADDRESS selbst ist als POINTER TO WORD definiert.
In dieser Implementierung ist der Typ ADDRESS mit keinem arithmetischen Typ kompatibel. Das liegt an der Tatsache, da
Prozessoren der Intel 8086-Serie Adressen in Segment-Offset-Darstellung benutzen. Es w
re nicht schwierig gewesen, eine automatische Umwandlung zwischen LONGCARD und ADDRESS zu implementieren. Wir glauben, da
es dem Geist der Sprache widersprochen h
tte, wenn der Compiler irgendwelche "magischen" Tricks durchf
hren w
rde. Stattdessen stehen zu diesem Zweck zwei Prozeduren zur Verf
gung: FLAT und PTR. ;
In der Version 1.2 haben wir diese Regel etwas gelockert: D
ADDRESS + CARDINAL und ADDRESS - CARDINAL sind erlaubte Ausdr
cke. m
Der CARDINAL-Wert wird mit dem Offset-Teil der Adresse verrechnet und das Ergebnis ist wieder eine Adresse. ?
Auch f
r INC und DEC ist ADDRESS als erstes Argument erlaubt. D
Die Operation wird nur auf dem Offset-Teil der Adresse ausgef
hrt!
ck zum Pseudomodul SYSTEM
TYPE SYSTEM.BYTE
1 Byte Speicherbedarf. 1
r diesen Typ ist nur die Zuweisung definiert.
Wenn der formale Parameter einer Prozedur vom Typ BYTE ist, darf der entsprechende aktuelle Parameter von einem beliebigen 1 Byte langen Typ sein.
Wenn der formale Parameter einer Prozedur vom Typ ARRAY OF BYTE ist, dann darf der entsprechende aktuelle Parameter von beliebigem kompatiblen Typ sein.
ck zum Pseudomodul SYSTEM
TYPE SYSTEM.WORD
1 Wort (2 Bytes) Speicherbedarf. 1
r diesen Typ ist nur die Zuweisung definiert.
Wenn der formale Parameter einer Prozedur vom Typ WORD ist, dann darf der entsprechende aktuelle Parameter von einem beliebigen 1 Wort langen Typ sein.
Wenn der formale Parameter einer Prozedur vom Typ ARRAY OF WORD ist, dann darf der aktuelle Parameter von beliebigem kompatiblen Typ sein. V
Vorsicht: Die Gr
e des
bergebenen Parameters wird auf gerade Bytezahl aufgerundet!
ck zum Pseudomodul SYSTEM
SYSTEM.NEW und SYSTEM.DISPOSE
NEW und DISPOSE sind in der Sprach-Definition der 3. Auflage von Wirths Buch nicht mehr enthalten. 9
Wir haben sie auf folgende Art und Weise implementiert:
NEW(p)
ruft die Prozedur Storage.ALLOCATE auf, die dem Typ entsprechen mu
PROCEDURE (VAR ADDRESS, CARDINAL)
mit der
bergabe des Zeigers p und der Gr
e des Objekts auf p.
DISPOSE(p)
ruft die Prozedur Storage.DEALLOCATE auf, die dem Typ entsprechen mu
PROCEDURE (VAR ADDRESS, CARDINAL)
mit der
bergabe des Zeigers p und der Gr
e des Objekts auf p.
Die Prozeduren ALLOCATE und DISPOSE m
ssen also in einem Modul welches NEW und/oder DISPOSE benutzt, definiert werden, oder von einem anderen Modul (z.B. Storage) importiert werden.
ck zum Pseudomodul SYSTEM
SYSTEM.LONG
PROCEDURE LONG(INTEGER): LONGINT;
PROCEDURE LONG(CARDINAL): LONGCARD;
PROCEDURE LONG(REAL): LONGREAL;
LONG wandelt von INTEGER, CARDINAL oder REAL nach LONGINT, LONGCARD oder LONGREAL,um.
Siehe auch: SHORT.
ck zum Pseudomodul SYSTEM
SYSTEM.SHORT
PROCEDURE SHORT(LONGINT): INTEGER;
PROCEDURE SHORT(LONGCARD): CARDINAL;
PROCEDURE SHORT(LONGREAL): REAL;
SHORT wandelt von LONGINT, LONGCARD oder LONGREAL nach INTEGER, CARDINAL oder REAL um.
Siehe auch: LONG.
ck zum Pseudomodul SYSTEM
SYSTEM.ADR
PROCEDURE ADR(VAR adr: ADDRESS);
ADR(Bezeichner) gibt die Adresse des Objekts "Bezeichner" aus (Typ ADDRESS).
ck zum Pseudomodul SYSTEM
SYSTEM.FLAT
PROCEDURE FLAT(VAR adr: LONGCARD);
FLAT(ADDRESS) gibt eine unsegmentierte Adresse aus (LONGCARD).
ck zum Pseudomodul SYSTEM
SYSTEM.PTR
PROCEDURE PTR(adr: LONGCARD);
PTR gibt die der unsegmentierten Adresse (LONGCARD) entsprechende Adresse in Segment-Offset-Darstellung (ADDRESS) aus.
ck zum Pseudomodul SYSTEM
SYSTEM.NEWPROCESS
PROCEDURE NEWPROCESS(p: PROC;
a: ADDRESS;
n: CARDINAL;
VAR p1: ADDRESS);
2NEWPROCESS erzeugt einen neuen Proze
, dessen Startpunkt p ist und dessen n Bytes gro
er Arbeitsspeicher bei a beginnt. p1 ist der neue Proze
-Zeiger. Dieser Proze
ist nicht aktiviert bis ein SYSTEM.TRANSFER zu p1 vorgenommen wird. `
Die Start-Priorit
t des neuen Prozesses ist die aktuelle Priorit
t beim Aufruf von NEWPROCESS.
ck zum Pseudomodul SYSTEM
SYSTEM.TRANSFER
PROCEDURE TRANSFER(VAR p1, p2: ADDRESS);
TRANSFER setzt den laufenden Proze
er Kraft, weist ihn p1 zu und nimmt p2 auf. Der Wert vom laufenden Proze
wird p1 erst zugewiesen, nachdem p2 identifiziert wurde; daher kann f
r p1 und p2 die gleiche Variable verwendet werden. `
Der Proze
wird mit der gleichen Priorit
t wieder aufgenommen, die er beim Suspendieren hatte.
ck zum Pseudomodul SYSTEM
SYSTEM.IOTRANSFER
PROCEDURE IOTRANSFER(VAR p1,
p2: ADDRESS;
intVector: CARDINAL);
IOTRANSFER nimmt einen TRANSFER von p1 zu p2 vor. Ebenso wie es SYSTEM.TRANSFER tut, nachdem der laufende Proze
zur Reaktivierung vorbereitet wurde, die geschieht wenn
ber den Interrupt-Vektor "intVector" ein Interrupt ausgel
st wird. Wenn der Interrupt durchgef
hrt wird, wird der Interrupt-Vektor mit seinem vorherigen Wert geladen und ein TRANSFER zum I/O-Proze
(derjenige welcher den IOTRANSFER ausf
hrte) wird durchgef
hrt. Anschlie
end besitzt p2 den Wert des Prozesses, der lief, als der Interrupt auftrat.
ck zum Pseudomodul SYSTEM
SYSTEM.TRUNC
PROCEDURE TRUNC(REAL): CARDINAL;
PROCEDURE TRUNC(LONGREAL): LONGCARD;
Die TRUNC- und FLOAT-Prozeduren dienen zur Umwandlung zwischen den zwei Integer/Cardinal-Typen und Real-Typen.
ck zum Pseudomodul SYSTEM
SYSTEM.FLOAT
PROCEDURE FLOAT(CARDINAL): REAL;
PROCEDURE FLOAT(LONGCARD): LONGREAL;
Die TRUNC- und FLOAT-Prozeduren dienen zur Umwandlung zwischen den zwei Integer/Cardinal-Typen und Real-Typen.
ck zum Pseudomodul SYSTEM
SYSTEM.SEGMENT
PROCEDURE SEGMENT(adr: ADDRESS):
CARDINAL;
SEGMENT(Bezeichner) gibt den Segmentteil der Adresse des Objekts "Bezeichner"aus.
Beispiel:
DX := SEGMENT(buffer);
weist DX den Segment-Wert von ADR(buffer) zu.
ck zum Pseudomodul SYSTEM
SYSTEM.OFFSET
PROCEDURE OFFSET(adr: ADDRESS):
CARDINAL;
OFFSET(Bezeichner) gibt den Offsetteil der Adresse des Objekts "Bezeichner" aus.
ck zum Pseudomodul SYSTEM
MODULE System
Dieses Modul enth
lt systemspezifische Definitionen. Diese Version ist f
r MS/PC-DOS ab Version 2.0. w
Definierte Typen:
TYPE
ErrorProc = PROCEDURE(CARDINAL,
ADDRESS);
MemoryModel = (tiny,
small,
compact,
medium,
large,
huge);
Unterst
tzt werden z. Zt. nur "large" und "huge". G
In "System" definierte Variablen:
MemModel: MemoryModel;
DOSVersion: CARDINAL;
PSP: CARDINAL;
MemTop: CARDINAL;
HeapBase: CARDINAL;
StackSeg: CARDINAL;
StackSize: CARDINAL;
HeapTop: CARDINAL;
Has8087: BOOLEAN;
AX, BX, CX,
DX, SI, DI: CARDINAL;
BP, DS, ES: CARDINAL;
FLAGS: BITSET;
Definierte Konstanten:
CONST
carryFlag = 0; zeroFlag = 6;
Definierte Prozeduren:
GetArg GetEnv
Trap XTrap
Move TermProcedure
Terminate GetVector
SetVector ResetVector
InstallRTErrorHandler
UninstallRTErrorHandler
ck zum Index oder zu Routinen, Ende mit ESC "
VAR System.DOSVersion: CARDINAL
Die beim Start der Laufzeitbibliothek belegte Variable liefert die verwendete DOS-Version * 100 zur
ck: D
z.B.:
r DOS 2.10: 210
r DOS 3.30: 330
r DOS 5.00: 500
ck zum Modul System
VAR System.PSP: CARDINAL
Gibt das PSP (Programm-Segment-Prefix) in Paragraphen zur
ck zum Modul System
VAR System.MemTop: CARDINAL
Gibt das Ende des Speichers (MemTop) in Paragraphen zur
ck zum Modul System
VAR System.HeapBase: CARDINAL
Gibt den Beginn des Heap in Paragraphen zur
ck zum Modul System
VAR System.StackSeg: CARDINAL
Gibt die Adresse des Stack-Segments in Paragraphen zur
ck zum Modul System
VAR System.StackSize: CARDINAL
Liefert die Gr
e des Stacksegments (vorbelegter Stack-Pointer (SP-Register)) zur
ck zum Modul System
VAR System.HeapTop: CARDINAL
Liefert das Ende des Heaps in Paragraphen. Das Modul Storage kann diesen Wert anpassen.
ck zum Modul System
CPU-Register:
Registervariablen aus dem Modul System: h
AX, BX, CX, DX, SI, DI: CARDINAL;
BP, DS, ES : CARDINAL;
FLAGS : BITSET;
ck zum Modul System
System.carryFlag / .zeroFlag
CPU-Flags.
ck zum Modul System
System.ErrorProc
TYPE
ErrorProc = PROCEDURE(CARDINAL,
ADDRESS);
Setzt einen Zeiger auf eine benutzerdefinierte Fehlerbehandlungsroutine. Im Fall eines Laufzeitfehlers werden die Fehlernummer und die Fehleradresse geliefert. (
siehe auch:
Standard-Fehlerroutinen
Die Fehleradresse kann mit der Adresse in der durch DBG2MAP erzeugten .MAP-Datei wie folgt verkn
pft werden: !
a.SEG := a.SEG - (PSP + 10H);
Nach der R
ckkehr aus der benutzerdefinierten Fehlerroutine wird zur Standard-Fehlerroutine verzweigt und hiermit das Programm abgebrochen.
ck zum Modul System
System.GetArg
PROCEDURE GetArg(VAR arg: ARRAY OF CHAR;
VAR length: CARDINAL );
Liefert das n
chste Argument in der Kommandozeile. #
1. Leerzeichen trennen Argumente. 0
2. "/" leitet ein neues Argument ein (Option). ^
3. Um die obigen Voreinstellung zu
berschreiben, kann ein Modula-2-String angegeben werden. @
Beispiel:
COMMAND arg1 "arg 2" /option "command's last arg"
ck zum Modul System
System.GetEnv
PROCEDURE GetEnv(var: ARRAY OF CHAR;
VAR val: ARRAY OF CHAR);
dt "val" mit dem Wert der Environmentvariable "var". Wenn "var" nicht gefunden wird, wird ein Null-String in "val" zur
ckgeliefert.
ck zum Modul System
System.Trap
PROCEDURE Trap(intno: CARDINAL);
dt die CPU-Register mit den Inhalten von AX..DI und f
hrt dann den angegebenen Softwareinterrupt "intno" aus. Bei der R
ckkehr vom Interrupt werden die Register in AX..DI und die Prozessorflags in FLAGS gesichert.
siehe auch XTrap
ck zum Modul System
System.XTrap
PROCEDURE XTrap(intno: CARDINAL);
dt die CPU-Register mit den Inhalten von AX..ES und f
hrt dann den angegebenen Softwareinterrupt "intno" aus. i
Bei der R
ckkehr vom Interrupt werden die Register in AX..ES und die Prozessorflags in FLAGS gesichert.
siehe auch Trap
ck zum Modul System
System.Move
PROCEDURE Move(src: ADDRESS;
dest: ADDRESS;
size: CARDINAL );
Bewegt "size" Bytes von "src" nach "dest". Der Pseudocode hierf
r sieht folgenderma
en aus:
IF FLAT(src) > FLAT(dest) THEN
(bewege von der niedrigen zur hohen Adresse)
ELSE
(bewege von der hohen zur niedrigen Adresse)
ck zum Modul System
System.TermProcedure
PROCEDURE TermProcedure(p :PROC);
Installiert eine Prozedur, die ausgef
hrt wird, wenn das Programm beendet wird. Es k
nnen bis zu 20 Ende-Prozeduren installiert werden.
ck zum Modul System
System.Terminate
PROCEDURE Terminate(exitStatus: CARDINAL);
Die Prozedur unterbricht die Programmausf
hrung und setzt das DOS-Errorlevel auf "exitStatus".
ck zum Modul System
System.GetVector
PROCEDURE GetVector(IntNum: CARDINAL;
VAR ISR: ADDRESS);
Die Prozedur l
dt den Wert des Interruptvectors "IntNum" aus dem BIOS-Interruptbereich in die Variable "ISR".
Siehe auch SetVector.
ck zum Modul System
System.SetVector
PROCEDURE SetVector(IntNum: CARDINAL;
ISR: PROC);
Installiert eine Interrupt-Subroutine (ISR), die dann aufgerufen wird, wenn der Interrupt "IntNum" ausgef
hrt werden soll. Die in der Interrupt-Vektor geladene Adresse ist die Startadresse der ISR-Prozedur, bei der der vom Compiler generierte Prozedur-Eintrittscode ausgelassen wird. Die Interrupt-Subroutine mu
mit abgeschalteter Stack
berpr
fung (*$S-*) compiliert werden, da der Compiler bei eingeschalteter Stack-
berpr
fung Assembleranweisungen erzeugt, die den Stackpointer manipulieren.
Siehe auch GetVector.
ck zum Modul System
System.ResetVector
PROCEDURE ResetVector(IntNum: CARDINAL;
ISR: ADDRESS);
dt den Wert des Interruptvektor "IntNum" in die Interrupt-Subroutine (ISR).
ck zum Modul System
System.InstallRTErrorHandler
PROCEDURE InstallRTErrorHandler(errorProc:
ErrorProc);
Installiert die Fehlerbehandlungsroutine, die dann aufgerufen wird, wenn ein Laufzeitfehler auftritt. Es k
nnen bis zu zehn Fehlerbehandlungsroutinen installiert werden. Es wird jedoch nur die zuletzt installierte im Falle eines Laufzeitfehlers ausgef
hrt.
ck zum Modul System
System.UnInstallRTErrorHandler
PROCEDURE UninstallRTErrorHandler;
Deinstalliert die zuletzt mit InstallRTErrorHandler installierte Fehlerprozedur "errorProc".
ck zum Modul System
System.ErrorMessage
PROCEDURE ErrorMessage(msg: ARRAY OF CHAR);
Schreibt die Meldung msg an die Standard-Fehlerausgabe StdErr.
ck zum Modul System
System.ErrorErrorLn
PROCEDURE ErrorLn;
Schreibt eine neue Zeile an die Standard-Fehlerausgabe StdErr.
ck zum Modul System
MODULE ASCII
Die Werte f
r ASCII-Zeichen m
ssen in Modula oktal angegeben werden. Alle Zeichen unter 32 sowie das Zeichen 127 (Backspace) sind, da sie normalerweise nicht direkt geschrieben werden k
nnen, im Modul ASCII vordefiniert:
Standard ASCII-Steuerzeichen:
NUL = 00C
SOH = 01C
STX = 02C
ETX = 03C
EOT = 04C
ENQ = 05C
ACK = 06C
BEL = 07C
BS = 10C
HT = 11C
LF = 12C
VT = 13C
FF = 14C
CR = 15C
SO = 16C
SI = 17C
DLE = 20C
DC1 = 21C
DC2 = 22C
DC3 = 23C
DC4 = 24C
NAK = 25C
SYN = 26C
ETB = 27C
CAN = 30C
EM = 31C
SUB = 32C
ESC = 33C
FS = 34C
GS = 35C
RS = 36C
US = 37C
DEL = 177C
Was die Steuerzeichenkombinationen erzeugen:
CtrlA = 01C
CtrlB = 02C
CtrlC = 03C
CtrlD = 04C
CtrlE = 05C
CtrlF = 06C
CtrlG = 07C
CtrlH = 10C
CtrlI = 11C
CtrlJ = 12C
CtrlK = 13C
CtrlL = 14C
CtrlM = 15C
CtrlN = 16C
CtrlO = 17C
CtrlP = 20C
CtrlQ = 21C
CtrlR = 22C
CtrlS = 23C
CtrlT = 24C
CtrlU = 25C
CtrlV = 26C
CtrlW = 27C
CtrlX = 30C
CtrlY = 31C
CtrlZ = 32C
Modula-2 Zeilenende-Zeichen:
EOL = 36C;
Modula-2 Textdatei-Endezeichen:
EOF = CtrlZ;
ck zum Index, Ende mit ESC
MODULE InOut
Dies ist das Standardmodul InOut, wie es in dem Buch "Programming in Modula-2" von Niklaus Wirth definiert wurde. Einige Erweiterungen wurden eingebaut, haupts
chlich zur Unterst
tzung der Datentypen LONGINT und LONGCARD.
CONST
EOL = 36C;
Done : BOOLEAN;
termCH: CHAR;
definierte Prozeduren:
OpenInput OpenOutPut
RedirectInput RedirectOutput
CloseInput CloseOutput
ReadString Read
ReadInt ReadLine
ReadWrd Write
ReadCard WriteLn
WriteInt WriteLine
WriteCard WriteString
WriteOct WriteHex
WriteWrd ReadLongInt
ReadLongCard WriteLongInt
WriteLongCard
ck zum Index, Ende mit ESC
InOut.EOL
CONST
EOL = 36C;
Zeilenende-Kennung
ck zum Modul InOut
InOut.Done
Done : BOOLEAN;
"Done" wird von den Prozeduren OpenInput, OpenOutput, RedirectInput, RedirectOutput, Read, ReadInt, ReadCard, ReadLongInt, ReadLongCard, ReadWrd und WriteWrd gesetzt, um anzeigen, ob der Aufruf der Prozedur erfolgreich war.
ck zum Modul InOut
InOut.termCH
VAR
termCH: CHAR;
In dieser (globalen) Variable wird das letzte gelesene Zeichen der Leseprozeduren (ReadXXXX) des Moduls InOut gespeichert.
ck zum Modul InOut
InOut.OpenInput
PROCEDURE OpenInput(defext: ARRAY OF CHAR);
Fragt den Benutzer nach einer Datei f
r die Eingabeumleitung. Wenn das letzte Zeichen der Eingabe ein Punkt ist, wird "defext" (default Extension) an den Dateinamen angeh
ngt.
ck zum Modul InOut
InOut.OpenOutput
PROCEDURE OpenOutput(defext :ARRAY OF CHAR);
Fragt den Benutzer nach einer Datei, in die die Ausgaben umzuleiten sind. Falls das letzte Zeichen der Eingabe ein Punkt ist, wird "defext" (default Extension) an den Dateinamen angeh
ngt.
ck zum Modul InOut
InOut.RedirectInput
PROCEDURE RedirectInput(from: ARRAY OF CHAR);
Leitet die Eingabe aus der Datei "from" um.
ck zum Modul InOut
InOut.RedirectOutput
PROCEDURE RedirectOutput(to: ARRAY OF CHAR);
Leitet alle Ausgaben in die Datei "to" um.
ck zum Modul InOut
InOut.CloseInput
PROCEDURE CloseInput;
Die mit OpenInput oder RedirectInput ge
ffnete Datei wird geschlossen und das Terminal als Eingabeger
t wieder aktiviert.
ck zum Modul InOut
InOut.CloseOutput
PROCEDURE CloseOutput;
Die mit OpenOutPut oder RedirectOutput ge
ffnete Datei wird geschlossen und das Terminal als Ausgabeger
t wieder aktiviert.
ck zum Modul InOut
InOut.Read
PROCEDURE Read(VAR ch: CHAR);
Liest ein Zeichen aus der Standard-Eingabe. 1
ck zum Modul InOut oder zur Read-
bersicht.
InOut.ReadString
PROCEDURE ReadString(VAR s: ARRAY OF CHAR);
Liest eine Zeichenkette.
Die Eingabe wird durch ein Leerzeichen oder jedes beliebige Steuerzeichen mit Ausnahme von ASCII.BS oder ASCII.DEL beendet. Das letzte (beendende) Zeichen wird in der Variablen InOut.termCH gespeichert. Wenn vom Terminal gelesen wird, sind folgende Editierm
glichkeiten gegeben: %
ASCII.BS l
scht das letzte Zeichen &
ASCII.DEL l
scht die gesamte Eingabe K
ASCII.ESC l
scht die gesamte Eingabe und beendet die Funktion mit RETURN.
ck zum Modul InOut
InOut.ReadLine
PROCEDURE ReadLine(VAR s: ARRAY OF CHAR);
Liest eine Zeile "s" aus der Standardeingabe. Die Eingabe wird durch EOL, EOF oder ESC beendet bzw. abgebrochen. Das letzte (beendende) Zeichen wird in der Variablen InOut.termCH gespeichert. M
Wenn vom Terminal gelesen wird, sind folgende Editierm
glichkeiten gegeben: %
ASCII.BS l
scht das letzte Zeichen &
ASCII.DEL l
scht die gesamte Eingabe K
ASCII.ESC l
scht die gesamte Eingabe und beendet die Funktion mit RETURN. 5
ck zum Modul InOut oder zur ReadLine-
bersicht.
InOut.ReadInt
PROCEDURE ReadInt(VAR x: INTEGER);
Ein Zeichenfeld wird aus dem Eingabeger
t gelesen und dann in eine INTEGER-Zahl umgewandelt.
ck zum Modul InOut
InOut.ReadCard
PROCEDURE ReadCard(VAR x: CARDINAL);
Eine Zeichenkette wird aus dem Eingabeger
t gelesen und dann in eine CARDINAL-Zahl konvertiert.
ck zum Modul InOut
InOut.ReadWrd
PROCEDURE ReadWrd(VAR w: WORD);
Liest ein WORD aus der Eingabe-Datei.
Achtung:
ReadWrd ist nur dann erlaubt, wenn die Eingabe aus einer Datei umgeleitet wird!
ck zum Modul InOut
InOut.Write
PROCEDURE Write(ch: CHAR);
Schreibt ein Zeichen an die Standardausgabe. 2
ck zum Modul InOut oder zur Write-
bersicht.
InOut.WriteLn
PROCEDURE WriteLn;
Identisch zu Write (ASCII.EOL). Schreibt einen Zeilenumbruch. 4
ck zum Modul InOut oder zur WriteLn-
bersicht.
InOut.WriteString
PROCEDURE WriteString(s: ARRAY OF CHAR);
Schreibt die Zeichenkette "s" in die Standardausgabe. 8
ck zum Modul InOut oder zur WriteString-
bersicht.
InOut.WriteInt
PROCEDURE WriteInt(x: INTEGER; n: CARDINAL);
Schreibt die INTEGER-Zahl "x" rechtsb
ndig in ein Feld mit "n" Zeichen.
ck zum Modul InOut
InOut.WriteCard
PROCEDURE WriteCard(x, n: CARDINAL);
Schreibt die CARDINAL-Zahl "x" rechtsb
ndig in ein Feld mit "n" Zeichen.
ck zum Modul InOut
InOut.WriteOct
PROCEDURE WriteOct(x, n: CARDINAL);
Schreibt "x" in oktaler Form in ein rechtsb
ndiges Feld von mindestens "n" Zeichen. U
Wenn (n <= 3) und (x < 100H) dann werden drei, ansonsten sechs Zeichen geschrieben.
ck zum Modul InOut
InOut.WriteHex
PROCEDURE WriteHex(x, n: CARDINAL);
Schreibt "x" in hexadezimaler Form in ein rechtsb
ndiges Feld von mindestens "n" Zeichen. T
Wenn (n <= 2) und (x < 100H) dann werden zwei, ansonsten vier Zeichen geschrieben.
ck zum Modul InOut
InOut.WriteWrd
PROCEDURE WriteWrd(w: WORD);
Schreibt "w" in die Ausgabedatei. U
Die Operation ist nur dann erlaubt, wenn die Ausgabe in eine Datei umgeleitet wird.
ck zum Modul InOut
InOut.ReadLongInt
PROCEDURE ReadLongInt(VAR x: LONGINT);
Eine Zeichenkette wird aus dem Eingabeger
t gelesen und dann in eine LONGINT-Zahl umgewandelt.
ck zum Modul InOut
InOut.ReadLongCard
PROCEDURE ReadLongCard(VAR x: LONGCARD);
Eine Zeichenkette wird aus dem Eingabeger
t gelesen und dann in eine LONGCARD-Zahl umgewandelt.
SetJump sichert die Umgebung des Vaterprozesses in dem
bergebenen Parameter und gibt 0 zur
LongJump stellt die gesicherte Umgebung eines vorherigen SetJump wieder her. Die Ausf
hrung wird als R
ckgabe (RETURN) von SetJump wieder aufgenommen. Der R
ckgabewert wird SetJump untergeschoben. _
Logischerweise darf der Zeiger auf die zur
ckgelieferten Parameter nicht NIL (RETURN 0) sein. x
Wenn LongJump aufgerufen wird, mu
die Prozedur, die den korrespondierenden SetJump durchgef
hrt hat, noch aktiv sein.
Beispiel:
PROCEDURE main;
...
IF SetJump(env) = 0 THEN
Parse
ELSE
WriteString("error in Parse")
END;
...
PROCEDURE Parse;
...
IF errorcond THEN
LongJump(env, 1)
END;
...
Die Prozedur "main" ruft SetJump auf, um die aktuelle Ausf
hrungsumf
hrung in "env" zu sichern. SetJump liefert 0 zur
ck und anschlie
end wird "Parse" aufgerufen.
Falls Parse einen Fehler entdeckt, ruft die Prozedur LongJump mit einem R
ckgabewert von 1. Die Hauptprozedur "main" wird am R
ckgabe-Punkt von SetJump fortgesetzt, die IF-Bedingung Abfrage wird FALSE und der String ausgegeben.
------------------------
deklarierter Typ:
JumpBuffer
deklarierte Prozeduren:
SetJump LongJump
ck zum Index oder zu Routinen, Ende mit ESC
LongJump.JumpBuffer
TYPE
JumpBuffer = RECORD
savPC, savCS,
savSP, savBP: CARDINAL;
END;
Globale Pufferung der Routinen des Moduls LongJump.
ck zum Modul LongJump
LongJump.SetJump
PROCEDURE SetJump(VAR mark: JumpBuffer):
CARDINAL;
Sichert die Umgebung des aktuellen Vaterprozesses in "MARK". Es wird 0 zur
ckgegeben.
ck zum Modul LongJump
LongJump.LongJump
PROCEDURE LongJump(VAR mark: JumpBuffer;
return: CARDINAL);
Restauriert die in "mark" gesicherte Proze
umgebung und kehrt von SetJump mit dem R
ckgabewert "return" zur
ck zum Modul LongJump
MODULE FileSystem
Dieses Modul enth
lt die Dateiroutinen wie sie Niklaus Wirth in seinem Buch "Programming in Modula-2" beschrieben hat. Alle Prozeduren setzen File.res auf "done" wenn der Aufruf erfolgreich war; sonst wird File.res auf "notdone" gesetzt. File.eof ist TRUE nachdem eine neue Datei erzeugt wurde oder wenn eine Leseoperation (Read????) aufgerufen wurde und keine weiteren Daten zur Verf
gung stehen. &
TYPE
FDPtr; (* Nur f
r internen Gebrauch *)
Response = (done, notdone);
IOMode = (read, write, io);
File = RECORD
id: INTEGER;
res: Response;
eof: BOOLEAN;
mode: IOMode;
fdptr: FDPtr; (* Nur f
r internen Gebrauch *)
END;
deklarierte Prozeduren:
LookUp Create
Reset Close
Rewrite Rename
ReadWord WriteWord
ReadChar WriteChar
GetPos SetPos
GetLPos SetLPos
LLength Length
ReadNBytes WriteNBytes
ck zum Index oder zu Routinen, Ende mit ESC
FileSystem.FDPtr
TYPE
FDPtr;
File-Description-Pointer, nur f
r internen Gebrauch!
ck zum Modul FileSystem
FileSystem.Response
TYPE
Response = (done, notdone);
berpr
fung, ob die Dateioperation erfolgreich durchgef
hrt wurde.
ck zum Modul FileSystem
FileSystem.IOMode
TYPE
IOMode = (read, write, io);
Der Modus in dem die Datei behandelt werden soll: H
read = nur lesen
write = nur schreiben
io = lesen und schreiben
ck zum Modul FileSystem
FileSystem.File
TYPE
File = RECORD
id: INTEGER;
res: Response;
eof: BOOLEAN;
mode: IOMode;
fdptr: FDPtr; ( Nur f
r internen Gebrauch )
END;
Der Record enth
lt alle f
r Dateioperationen wichtigen Daten.
ck zum Modul FileSystem
FileSystem.LookUp
PROCEDURE Lookup(VAR f: File;
filename: ARRAY OF CHAR;
new: BOOLEAN);
ffnet die in "filename" genannte Datei. Falls die Datei nicht vorhanden ist, wird sie, wenn "new" TRUE ist, neu erstellt, sonst ein Fehler zur
ckgegeben.
LookUp versucht immer zu erst eine Datei f
r io zu
ffnen. Falls dies fehlschl
gt, wird versucht, die Datei zum Lesen zu
ffnen. f.mode wird
quivalent zum
ffnungsmodus gesetzt.
ck zum Modul FileSystem
FileSystem.Create
PROCEDURE Create(VAR f: File; (
mediumname: ARRAY OF CHAR);
Erstelle eine neue tempor
re Datei. %
Falls "mediumname" mit einer Variable im DOS-Environment
bereinstimmt, wird diese Variable f
r den Pfad zu der Tempor
rdatei verwendet. Wenn die Operation geklappt hat, wird f.res auf "done" gesetzt, sonst auf "notdone". f.eof ist nach der Operation TRUE, da eine neue Datei erstellt wurde. 8
ck zum Modul FileSystem oder zur Create-
bersicht.
FileSystem.Close
PROCEDURE Close(VAR f: File);
Schlie
t die Datei "f". l
Falls die Datei mit Rename) umbenannt wurde, wird der Verzeichniseintrag zu diesem Zeitpunkt aktualisiert. f
Falls notwendig (die Datei wurde zu einem anderen Laufwerk umbenannt), wird die Datei jetzt kopiert. 7
ck zum Modul FileSystem oder zur Close-
bersicht.
FileSystem.Reset
PROCEDURE Reset(VAR f: File);
Setzt den Dateizeiger an den Anfang der Datei "f".
ck zum Modul FileSystem
FileSystem.ReWrite
PROCEDURE Rewrite(VAR f: File);
Setzt den Dateizeiger an den Anfang der Datei und schneidet den Rest ab (leert den Inhalt) der Datei.
ck zum Modul FileSystem
FileSystem.Rename
PROCEDURE Rename(VAR f: File;
filename: ARRAY OF CHAR );
ndert den Namen der Datei "f" in "filename". f
Die Datei kann zu einem anderen Verzeichnis oder auf ein anderes Laufwerk umbenannt (bewegt) werden.
Hinweis:
Der Verzeichniseintrag wird erst ge
ndert, wenn die Datei geschlossen (Close) wird. 8
ck zum Modul FileSystem oder zur Rename-
bersicht.
FileSystem.ReadWord
PROCEDURE ReadWord(VAR f: File;
VAR w: WORD);
Lese einen WORD-Wert aus einer Datei. P
Falls die Leseoperation zum Dateiende gelangt, wird File.eof auf TRUE gesetzt.
ck zum Modul FileSystem
FileSystem.WriteWord
PROCEDURE WriteWord(VAR f: File;
w: WORD);
Schreibt ein WORD in eine Datei.
Die Prozedur setzt File.res auf "done", wenn der Aufruf erfolgreich war, ansonsten wird file.res auf "notdone" gesetzt. File.eof ist TRUE, nachdem eine neue Datei erstellt wird.
ck zum Modul FileSystem
FileSystem.ReadChar
PROCEDURE ReadChar(VAR f : File;
VAR ch: CHAR);
Liest einen Zeichen aus der Datei. Das Zeichen ASCII.CR wird zu ASCII.EOL konvertiert. ASCII.LF wird ignoriert. y
Die Prozedur setzt File.res auf "done", wenn der Aufruf erfolgreich war, ansonsten wird file.res auf "notdone" gesetzt.
ck zum Modul FileSystem
FileSystem.WriteChar
PROCEDURE WriteChar(VAR f: File;
ch: CHAR);
Schreibt das Zeichen "ch" in die Datei. >
ASCII.EOL wird zu der Sequenz ASCII.CR ASCII.LF konvertiert. ;
ck zum Modul FileSystem oder zur WriteChar-
bersicht.
FileSystem.GetPos
PROCEDURE GetPos(VAR f: File;
VAR highpos,
lowpos : CARDINAL);
Liefert die aktuelle Position des Dateizeigers. )
Siehe auch SetPos, SetLPos und GetLPos.
ck zum Modul FileSystem.
FileSystem.SetPos
PROCEDURE SetPos(VAR f: File;
highpos,
lowpos: CARDINAL);
Bewegt den Dateizeiger zur Position highpos * 65536 + lowpos. )
Siehe auch SetLPos, GetPos und GetLPos.
ck zum Modul FileSystem.
FileSystem.GetLPos
PROCEDURE GetLPos(VAR f : File;
VAR pos: LONGCARD);
Liefert die aktuelle Position des Dateizeigers. )
Siehe auch GetPos, GetLPos und SetLPos.
ck zum Modul FileSystem
FileSystem.SetLPos
PROCEDURE SetLPos(VAR f: File;
pos: LONGCARD);
Bewegt den Dateizeiger zur Position highpos * 65536 + lowpos. (
Siehe auch SetPos, GetPos und GetLPos.
ck zum Modul FileSystem
FileSystem.Length
PROCEDURE Length(VAR f: File;
VAR highlen,
lowlen : CARDINAL);
Gibt die L
nge der Datei zur
Siehe auch LLength 8
ck zum Modul FileSystem oder zur Length-
bersicht.
FileSystem.LLength
PROCEDURE LLength(VAR f: File;
VAR length: LONGCARD);
Gibt die L
nge der Datei zur
Siehe auch Length.
ck zum Modul FileSystem
FileSystem.ReadNBytes
PROCEDURE ReadNBytes(VAR f: File;
buffPtr: ADDRESS;
n: CARDINAL;
VAR nRead: CARDINAL);
Die Prozedur versucht, "n" Bytes zu lesen.
Bei der R
ckkehr wird die Anzahl der gelesenen Bytes in "nRead" zur
ckgeliefert. Falls das Dateiende erreicht wird, wird File.eof auf TRUE gesetzt.
siehe auch WriteNBytes.
ck zum Modul FileSystem
FileSystem.WriteNBytes
PROCEDURE WriteNBytes(VAR f: File;
buffPtr: ADDRESS;
n: CARDINAL;
VAR nWritten: CARDINAL);
Die Prozedur schreibt "n" Bytes in die Datei. Z
Bei der R
ckkehr wird die aktuelle Zahl geschriebener Bytes in "nWritten" zur
ckgegeben.
siehe auch ReadNBytes.
ck zum Modul FileSystem
MODULEs MathLib0/LMathLib0
MathLib0:
Das MathLib0-Modul wie es von Niklaus Wirth in seinem Buch "Programming in Modula-2" definiert wurde.
LMathLib0:
Die LONGREALs-Version von Mathlib0. W
M2Reals, Mathlib0 und LMathLib0 benutzen den Coprozessor 8087/80x87, falls vorhanden. 2
In MathLib0 und LMathLib0 definierte Prozeduren: C
lt Prozeduren zur Umwandlung von Zahlen (INTEGER/CARDINAL/LONGINT/LONGCARD) in Strings und wieder zur
CONST
MaxBase = 16;
TYPE
BASE = [2..MaxBase];
definierte Prozeduren:
StringToCard StringToInt
StringToNum CardToString
CardToString NumToString
StringToLongCard StringToLongInt
StringToLongNum LongCardToString
LongIntToString LongNumToString
ck zum Index oder zu Routinen, Ende mit ESC
CONST NumberConversion.MaxBase
Basis f
r die "Num"-Umwandlungen
CONST
MaxBase = 16
TYPE
BASE = [2..MaxBase];
ck zum Modul NumberConversion
TYPE NumberConversion.BASE
CONST
MaxBase = 16;
TYPE
BASE = [2..MaxBase];
ck zum Modul NumberConversion
NumberConversion.StringToCard
PROCEDURE StringToCard(str: ARRAY OF CHAR; L
VAR num: CARDINAL;
VAR done: BOOLEAN);
ck zum Modul NumberConversion
NumberConversion.StringToInt
PROCEDURE StringToInt(str: ARRAY OF CHAR; I
VAR num: INTEGER;
VAR done: BOOLEAN);
ck zum Modul NumberConversion
NumberConversion.StringToNum
PROCEDURE StringToNum(str: ARRAY OF CHAR; k
base: BASE;
VAR num: CARDINAL;
VAR done: BOOLEAN);
ck zum Modul NumberConversion
NumberConversion.CardToString
PROCEDURE CardToString(num: CARDINAL; R
VAR str: ARRAY OF CHAR;
width: CARDINAL);
ck zum Modul NumberConversion
NumberConversion.IntToString
PROCEDURE IntToString(num: INTEGER; P
VAR str: ARRAY OF CHAR;
width: CARDINAL);
ck zum Modul NumberConversion
NumberConversion.NumToString
PROCEDURE NumToString(num: CARDINAL; q
base: BASE;
VAR str: ARRAY OF CHAR;
width: CARDINAL);
ck zum Modul NumberConversion
NumberConversion.StringToLongCard
PROCEDURE StringToLongCard(str: ARRAY OF CHAR; T
VAR num: LONGCARD;
VAR done: BOOLEAN);
ck zum Modul NumberConversion
NumberConversion.StringToLongInt
PROCEDURE StringToLongInt(str: ARRAY OF CHAR; Q
VAR num: LONGINT;
VAR done: BOOLEAN);
ck zum Modul NumberConversion
NumberConversion.StringToLongNum
PROCEDURE StringToLongNum(str: ARRAY OF CHAR; w
base: BASE;
VAR num: LONGCARD;
VAR done: BOOLEAN);
ck zum Modul NumberConversion
NumberConversion.LongCardToString
PROCEDURE LongCardToString(num: LONGCARD; Z
VAR str: ARRAY OF CHAR;
width: CARDINAL);
ck zum Modul NumberConversion
NumberConversion.LongIntToString
PROCEDURE LongIntToString(num: LONGINT; X
VAR str: ARRAY OF CHAR;
width: CARDINAL);
ck zum Modul NumberConversion
NumberConversion.LongNumToString
PROCEDURE LongNumToString(num: LONGCARD; }
base: BASE;
VAR str: ARRAY OF CHAR;
width: CARDINAL);
ck zum Modul NumberConversion
MODULE RealInOut
Das Modul ist eine Erweiterung von InOut und enth
lt die Routinen f
r das Lesen und Schreiben von Flie
kommazahlen. Das Modul erledigt seine Ein- und Ausgaben
ber das Modul InOut.
definierte Variable:
Done
definierte Prozeduren:
ReadReal WriteReal
ReadLongReal WriteLongReal
ck zum Index oder zu Routinen, Ende mit ESC
VAR RealInOut.Done
Done: BOOLEAN;
Globale Kontrollvariable f
r die Prozeduren den Moduls RealInOut.
RealInOut.ReadReal
PROCEDURE ReadReal(VAR x: REAL);
Liest einen String. Dieser wird anschlie
end in eine REAL-Zahl umgewandelt, die dann in "x" zur
ckgegeben wird. Eine REAL-Zahl im von Fitted-Modula verarbeitbaren Format wird erwarted. c
Die Variable "Done" wird auf TRUE gesetzt, wenn eine REAL-Zahl im korrekten Format gelesen wurde.
ck zum Modul RealInOut.
RealInOut.WriteReal
PROCEDURE WriteReal(x: REAL;
n: CARDINAL);
"x" wird in wissenschaftlicher Notation rechtsb
ndig in ein Feld von mindestens n Zeichen geschrieben.
ck zum Modul RealInOut.
RealInOut.ReadLongReal
PROCEDURE ReadLongReal(VAR x: LONGREAL);
Siehe auch ReadReal.
ck zum Modul RealInOut.
RealInOut.WriteLongReal
PROCEDURE WriteLongReal(x: LONGREAL;
n: CARDINAL);
Siehe auch WriteReal
ck zum Modul RealInOut.
MODULE Storage
Dieses Modul ist f
r die Bearbeitung des Modula-2-Heaps zwischen System.HeapTop und System.MemTop verantwortlich. o
Die Prozeduren in Storage ver
ndern System.HeapTop je nachdem, wie der Heap vergr
ert oder verkleinert wird. 0
In Storage sind folgende Prozeduren definiert: "
ALLOCATE DEALLOCATE Available
ck zum Index oder zu Routinen, Ende mit ESC
Storage.ALLOCATE
PROCEDURE ALLOCATE(VAR a: ADDRESS;
size: CARDINAL);
Allokiert "size" Bytes im Heap und gibt einen Zeiger auf diesen Bereich in "a" zur
ck zum Modul Storage
Storage.DEALLOCATE
PROCEDURE DEALLOCATE(VAR a: ADDRESS;
size: CARDINAL);
Gibt eine vorher allokierten Speicherblock der Gr
e "size" wieder frei. Wenn die Compiler-Option (*$T*) gesetzt ist, werden Zeiger vor dem Zugriff auf NIL gepr
ft. Au
erdem setzt Storage.DEALLOCATE den
bergebenen Zeiger auf NIL.
ck zum Modul Storage
Storage.Available
PROCEDURE Available(size: CARDINAL): BOOLEAN; P
TRUE falls ein Speicherblock der Gr
e "size" f
r die Zuweisung verf
gbar ist.
ck zum Modul Storage
MODULE Strings
Ein String ist ein ARRAY OF CHAR. ^
Falls der String nicht komplett in das Array pa
t, wird er von dem Zeichen 0C abgeschlossen. 6
Im Modul Strings sind folgende Prozeduren definiert: V
Append Assign
CompareStr Concat
Copy Delete
Insert Length
ck zum Index oder zu Routinen, Ende mit ESC
Strings.CompareStr
PROCEDURE CompareStr(s1, s2: ARRAY OF CHAR): INTEGER;
Vergleicht zwei Zeichenketten s1 und s2. K
ckgabe:
0 falls s1 = s2
-1 falls s1 < s2
+1 falls s1 > s2
ck zum Modul Strings.
Strings.Assign
PROCEDURE Assign(VAR source, dest: ARRAY OF CHAR);
kopiert den String "source" nach "dest".
ck zum Modul Strings.
Strings.Length
PROCEDURE Length(s :ARRAY OF CHAR ): CARDINAL;
Liefert die L
nge der Zeichenkette "s" zur
ck. 5
ck zum Modul Strings oder zur Length-
bersicht.
Strings.Concat
PROCEDURE Concat(s1, s2: ARRAY OF CHAR;
VAR result: ARRAY OF CHAR);
ngt die Zeichenkette "s2" an "s1" und liefert das Ergebnis in "result" zur
Siehe auch Append.
ck zum Modul Strings.
Strings.Pos
PROCEDURE Pos(subs, s: ARRAY OF CHAR): CARDINAL; D
Sucht den SubString "subs" in "s" und liefert die Position zur
ckgabe: k
Index des ersten Austretens von "subs" in "s" oder > HIGH(s) falls kein passender Bereich gefunden wurde.
ck zum Modul Strings.
Strings.Delete
PROCEDURE Delete(VAR s: ARRAY OF CHAR;
pos, len: CARDINAL);
scht "len" Zeichen aus der Zeichenkette "s" ab der Position "pos". 5
ck zum Modul Strings oder zur Delete-
bersicht.
Strings.Copy
PROCEDURE Copy(src: ARRAY OF CHAR;
pos, len: CARDINAL;
VAR dest: ARRAY OF CHAR);
Kopiert "len" Zeichen ab der Position "pos" von "src" nach "dest".
ck zum Modul Strings.
Strings.Append
PROCEDURE Append(VAR s1: ARRAY OF CHAR; )
s2: ARRAY OF CHAR);
ngt s2 an das Ende von s1. U
Die Prozedur arbeitet
quivalent zu Concat(s1, s2, s1) aber klarer und effizienter.
ck zum Modul Strings.
Strings.Insert
PROCEDURE Insert(subs: ARRAY OF CHAR; H
VAR s: ARRAY OF CHAR;
at: CARDINAL);
gt den Substring "subs" an der Position "at" in den String "s" ein.
ck zum Modul Strings.
MODULE TermBase
Das Modul Terminal erledigt die Arbeit der Prozeduren KeyPressed, Read, Write und Goto
ber dieses Modul.
Durch das
berschreiben der Methoden AssignRead, AssignWrite und AssignGoto mit effizienteren kann der Benutzer die Ein- und Ausgaben selbst wesentlich beschleunigen.
TYPE
StatusProcedure = PROCEDURE(): BOOLEAN;
ReadProcedure = PROCEDURE(VAR CHAR);
WriteProcedure = PROCEDURE(CHAR);
GotoProcedure = PROCEDURE(CARDINAL, CARDINAL);
definierte Prozeduren:
AssignGoto AssignRead
AssignWrite Goto
KeyPressed Read
UnAssignGoto UnAssignRead
UnAssignWrite Write
ck zum Index oder zu Routinen, Ende mit ESC
TermBase.StatusProcedure
TYPE
StatusProcedure = PROCEDURE(): BOOLEAN;
ck zum Modul TermBase.
TermBase.ReadProcedure
TYPE
ReadProcedure = PROCEDURE(VAR CHAR);
ck zum Modul TermBase.
TermBase.WriteProcedure
TYPE
WriteProcedure = PROCEDURE(CHAR);
ck zum Modul TermBase.
TermBase.GotoProcedure
TYPE
GotoProcedure = PROCEDURE(CARDINAL, CARDINAL);
ck zum Modul TermBase.
TermBase.AssignRead
PROCEDURE AssignRead(rp: ReadProcedure;
sp: StatusProcedure;
VAR done: BOOLEAN);
Sichert die aktuelle Read- und KeyPressed-Prozeduren in einem Prozedur-Stack und installiert die stattdessen zu benutzende neue Prozedur.
ck zum Modul TermBase.
TermBase.AssignWrite
PROCEDURE AssignWrite(wp: WriteProcedure;
VAR done: BOOLEAN);
Sichert die aktuelle Write-Prozedur in einem Prozedur-Stack und installiert stattdessen die zu benutzende neue Prozedur.
ck zum Modul TermBase.
TermBase.UnAssignRead
PROCEDURE UnAssignRead(VAR done :BOOLEAN);
Poppt die von AssignRead auf den Prozedur-Stack geschriebenen Read- und KeyPressed-Prozeduren zur
ck und macht sie wieder aktiv.
ck zum Modul TermBase.
TermBase.UnAssignWrite
PROCEDURE UnAssignWrite(VAR done: BOOLEAN);
Poppt die von AssignWrite auf den Prozedur-Stack geschriebene Write-Prozedur zur
ck und macht sie wieder aktiv.
ck zum Modul TermBase.
TermBase.Keypressed()
PROCEDURE KeyPressed(): BOOLEAN;
Fordert den derzeit installierten KeyPressed-Service an. G
hrend der Initialisierung von TermBase ist TermIO.KeyPressed aktiv. :
ck zum Modul TermBase oder zur KeyPressed-
bersicht.
TermBase.Read
PROCEDURE Read(VAR ch: CHAR);
Fordert die derzeit installierte Read-Prozedur an. A
hrend der Initialisierung von TermBase ist TermIO.Read aktiv. 4
ck zum Modul TermBase oder zur Read-
bersicht.
TermBase.Write
PROCEDURE Write(ch: CHAR);
Fordert die derzeit installierte Write-Prozedur an. B
hrend der Initialisierung von TermBase ist TermIO.Write aktiv. 5
ck zum Modul TermBase oder zur Write-
bersicht.
TermBase.AssignGoto
PROCEDURE AssignGoto(gp: GotoProcedure;
VAR done: BOOLEAN);
Sichert die aktuelle Goto-Prozedur in einem Prozedur-Stack und installiert die stattdessen zu benutzende neue Prozedur.
ck zum Modul TermBase.
TermBase.UnAssignGoto
PROCEDURE UnAssignGoto(VAR done: BOOLEAN);
Poppt die von AssignGoto auf den Prozedur-Stack geschriebene Goto-Prozedur zur
ck und aktiviert sie erneut.
ck zum Modul TermBase.
TermBase.Goto
PROCEDURE Goto(line, pos: CARDINAL);
Ruft die aktuell installierte Goto-Prozedur auf. G
hrend der Initialisierung von TermBase ist TermIO.Goto installiert. 4
ck zum Modul TermBase oder zur Goto-
bersicht.
MODULE Terminal
Die gesamten aktuellen Ein- und Ausgaben verwenden Prozeduren des Moduls TermBase. Das aufrufende Programm kann ebenso direkt die Prozeduren aus TermBase verwenden. $
In Terminal definierte Prozeduren: {
ClrScreen
Goto
KeyPressed Read
ReadLine
ReadAgain
Write
WriteString
WriteLn
WriteLine
ck zum Index oder zu Routinen, Ende mit ESC
Terminal.KeyPressed
PROCEDURE KeyPressed(): BOOLEAN;
Die Prozedur gibt TRUE zur
ck, wenn eine Taste gedr
ckt wurde; sonst wird FALSE gemeldet. :
ck zum Modul Terminal oder zur KeyPressed-
bersicht.
Terminal.Read
PROCEDURE Read(VAR ch: CHAR);
Liefert das n
chste eingegebene Zeichen. Hierzu wird TermBase.Read verwendet. 4
ck zum Modul Terminal oder zur Read-
bersicht.
Terminal.ReadLine
PROCEDURE ReadLine(VAR string:
ARRAY OF CHAR);
Lese eine ganze Zeile mithilfe von Read mit Echo mit Ausnahme des Abschlu
zeichens (EOL oder ESC). /
ASCII.BS} l
scht das letzte gelesene Zeichen.
ASCII.DEL l
scht alle Zeichen. ;
ASCII.ESC} l
scht alle Zeichen und bricht die Eingabe ab. l
ReadAgain, gefolgt von Read kann benutzt werden, um das abschlie
ende Zeichen zu ermitteln (EOL oder ESC). 8
ck zum Modul Terminal oder zur ReadLine-
bersicht.
Terminal.ReadAgain
PROCEDURE ReadAgain;
Erzwingt beim n
chsten Aufruf von Read das zuletzt gelesene Zeichen nochmals zur
ckzugeben.
ck zum Modul Terminal.
Terminal.Write
PROCEDURE Write(ch: CHAR);
Schreibt "ch" mithilfe von TermBase.Write in die Standardausgabe. 5
ck zum Modul Terminal oder zur Write-
bersicht.
Terminal.WriteString
PROCEDURE WriteString(string: ARRAY OF CHAR);
Schreibt unter Benutzung von Terminal.Write eine Zeichenkette "string" an die Standardausgabe. ;
ck zum Modul Terminal oder zur WriteString-
bersicht.
Terminal.WriteLn
PROCEDURE WriteLn;
Identisch mit: Write(ASCII.EOL). 7
ck zum Modul Terminal oder zur WriteLn-
bersicht.
Terminal.ClrScreen
PROCEDURE ClrScreen;
Identisch zu Write(ASCII.FF). Die Prozedur ben
tigt ANSI.SYS!
ck zum Modul Terminal.
Terminal.Goto
PROCEDURE Goto(line, pos: CARDINAL);
Die Prozedur ruft TermBase.Goto(line, pos) auf. 4
ck zum Modul Terminal oder zur Goto-
bersicht.
Terminal.WriteLine
PROCEDURE WriteLine(string: ARRAY OF CHAR);
Identisch mit:
WriteString(string);
WriteLn;
ck zum Modul Terminal oder zur WriteLine-
bersicht.
MODULE TermIO
Die Prozeduren dieses Moduls sind die Standard Ein- und Ausgabe-Routinen, die vom Modul TermBase genutzt werden. Die Prozeduren des Moduls rufen die DOS-Funktionen 2, 8 und 0BH auf. S
r die Bildschirm-L
schroutinen und Goto-Funktion mu
ANSI.SYS installiert sein! "
In TermIO definierte Prozeduren: 1
Read
Write
KeyPressed
Goto
ck zum Index oder zu Routinen, Ende mit ESC
TermIO.Read
PROCEDURE Read(VAR ch: CHAR);
Wartet, bis ein Zeichen f
r das Lesen aus der Tastatur bereit steht und liest es dann. Das Zeichen wird nicht auf dem Bildschirm angezeigt. +
ASCII.CR wird nach ASCII.EOL konvertiert. 2
ck zum Modul TermIO oder zur Read-
bersicht.
TermIO.Write
PROCEDURE Write(ch: CHAR);
Schreibt ch auf den Bildschirm. B
ASCII.FF l
scht den Bildschirm (ANSI.SYS mu
installiert sein) ?
ASCII.EOL erzeugt auf dem Bildschirm die Ausgabe von CR LF. 6
ASCII.DEL erzeugt einen zerst
rerischen Backspace. 3
ck zum Modul TermIO oder zur Write-
bersicht.
TermIO.KeyPressed
PROCEDURE KeyPressed() :BOOLEAN;
Gibt TRUE zur
ck, wenn im Tastaturpuffer ein Zeichen anliegt. 8
ck zum Modul TermIO oder zur KeyPressed-
bersicht.
TermIO.Goto
PROCEDURE Goto(line, pos: CARDINAL);
Positioniert den Cursor an line/pos. Es wird ANSI.SYS ben
tigt! 1
ck zum Modul TermIO oder zu Goto-
bersicht.
MODULE Display
TYPE M
DisplayBuffer = ARRAY [0..24]
OF ARRAY [0..79] OF CARDINAL;
VAR 8
line0: CARDINAL;
col0: CARDINAL;
lineN: CARDINAL;
colN: CARDINAL;
snowy: BOOLEAN;
displayMode: CARDINAL;
displayPage: CARDINAL;
displayAttr: CARDINAL;
displayLines: CARDINAL;
displayCols: CARDINAL;
displayPtr: POINTER TO DisplayBuffer;
definierte Prozeduren:
GetDisplayMode SetDisplayMode
SetCursorType GetCursorPosition
SetCursorPosition ScrollUp
ScrollDown ReadCharAttr
WriteCharAttr WriteChar
ClrEOL Goto
ClrEOS Write
DisplayString DisplayLine
WriteScreen ReadScreen
ck zum Index oder zu Routinen, Ende mit ESC
Display.displayMode
displayMode: CARDINAL;
Wird beim Aufruf mit dem aktuellen Bildschirmmodus initialisiert.
ck zum Modul Display
Display.displayPage
displayPage :CARDINAL;
Die Bildschirmseite. <
Wird abh
ngig vom aktuellen Bildschirmmodus initialisiert.
ck zum Modul Display
Display.displayAttr
VAR
displayAttr :CARDINAL;
Das Bildschirmattribut. Wird mit 07H initialisiert.
ck zum Modul Display
Display.displayLines
VAR
displayLines:CARDINAL;
Die Anzahl der Bildschirmzeilen. Wird auf 25 initialisiert.
ck zum Modul Display
Display.displayCols
VAR
displayCols :CARDINAL;
Die Anzahl der Bildschirmfarben. <
Wird abh
ngig vom aktuellen Bildschirmmodus initialisiert.
ck zum Modul Display
Display.snowy
VAR
snowy :BOOLEAN;
Die Variable dient der
berpr
fung von "Schneetreiben" auf dem Bildschirm. Wenn TRUE: Warte auf Bildschirm-Retrace. M
snowy wird automatisch auf TRUE gesetzt, wenn der Bildschirmmodus # 7 ist.
ck zum Modul Display
aktuelle Fensterkoordinaten
line0: CARDINAL;
oberste Zeile, Startwert 0
col0: CARDINAL;
Spalte links, Startwert 0
lineN: CARDINAL;
letzte Zeile im Fenster
colN: CARDINAL;
letzte Spalte im Fenster
ck zum Modul Display
Display.displayPtr
Zeiger auf den Bildschirmpuffer. Wird zur Initialisierungszeit geladen. Y
TYPE
DisplayBuffer = ARRAY [0..24] OF
ARRAY [0..79] OF CARDINAL;
displayPtr: POINTER TO DisplayBuffer;
ck zum Modul Display
Display.GetDisplayMode
PROCEDURE GetDisplayMode(VAR mode, nCols,
activePage: CARDINAL);
Gibt den aktuellen Bildschirmmodus zur
BIOS Interface-Routine.
ck zum Modul Display
Display.SetDisplayMode
PROCEDURE SetDisplayMode(mode: CARDINAL);
Setzt den Bildschirm-Modus.
BIOS Interface-Routine.
ck zum Modul Display
Display.SetCursorType
PROCEDURE SetCursorType(start, end: CARDINAL );
Setzt die Cursor Start- und Endzeile.
BIOS Interface-Routine.
ck zum Modul Display
Display.GetCursorPosition
PROCEDURE GetCursorPosition(VAR line: CARDINAL;
VAR pos: CARDINAL);
Meldet die aktuelle Cursorposition zur
BIOS Interface-Routine.
ck zum Modul Display
Display.SetCursorPosition
PROCEDURE SetCursorPosition(line: CARDINAL;
pos: CARDINAL);
Bewegt den Cursor nach line/pos.
BIOS Interface-Routine. >
Siehe auch bei der Goto-
bersicht. Zur
ck zum Modul Display.
Display.ScrollUp
PROCEDURE ScrollUp(n,
line1, pos1,
line2, pos2: CARDINAL;
attr: CARDINAL);
Scrollt das Fenster um n Zeilen nach oben. 6
line1, pos1 = linke obere Ecke des Scrollfensters. 8
line2, pos2 = rechte untere Ecke des Scrollfensters. 3
attr = Farbattribut f
r neue Leerzeilen. /
Falls n = 0 ist, wird das Fenster gel
scht.
BIOS Interface-Routine.
Siehe auch ScrollDown
ck zum Modul Display
Display.ScrollDown
PROCEDURE ScrollDown(n,
line1, pos1,
line2, pos2: CARDINAL;
attr: CARDINAL);
Scrollt ein Window Scrolls um "n" Zeilen nach unten. K
BIOS Interface-Routine. F
r die Beschreibung der Variablen siehe ScrollUp
ck zum Modul Display
Display.ReadCharAttr
PROCEDURE ReadCharAttr(VAR ch: CHAR;
VAR attr: CARDINAL);
Liest das Zeichen und Bildschirmattribut unter dem Cursor.
BIOS Interface-Routine.
ck zum Modul Display
Display.WriteCharAttr
PROCEDURE WriteCharAttr(ch: CHAR;
attr: CARDINAL);
Schreibt das Zeichen "ch" und das Bildschirm-Attribut "attr" an die aktuelle Cursorposition. Der Cursor wird nicht bewegt.
BIOS Interface-Routine.
ck zum Modul Display
Display.WriteChar
PROCEDURE WriteChar(ch: CHAR);
Schreibt das Zeichen ch an die aktuelle Cursorposition.
BIOS Interface-Routine. 8
ck zum Modul Display oder zur WriteChar-
bersicht.
Display.Goto
PROCEDURE Goto(line, col: CARDINAL);
Bewegt den Cursor an line/pos innerhalb des von line0, col0 - lineN, colN definierten aktuellen Fensters. 3
ck zum Modul Display oder zur Goto-
bersicht.
Display.Write
PROCEDURE Write(ch: CHAR);
Schreibt ein Zeichen an die aktuelle Bildschirmposition, f
r die Farbe wird displayAttr verwendet. Der Cursor wird weiterbewegt. Die Prozedur arbeitet innerhalb der von line0, col0 - lineN, colN definierten Fenster-Koordinaten. 0
Die folgenden Steuerzeichen werden ausgef
hrt: %
BEL, EOL, CR, LF, FF, DEL, BS, HT.
ck zum Modul Display oder zur Write-
bersicht.
Display.ClrEOL
PROCEDURE ClrEOL;
scht bis zum Zeilenende. Hierzu wird displayAttr benutzt. =
Die Prozedur arbeitet in den Grenzen des aktuellen Windows.
ck zum Modul Display.
Display.ClrEOS
PROCEDURE ClrEOS;
scht bis zum Ende des aktuellen Windows. Hierzu wird displayAttr benutzt.
ck zum Modul Display.
Display.DisplayString
PROCEDURE DisplayString(s: ARRAY OF CHAR;
line, pos: CARDINAL;
attr: CARDINAL);
Die Prozedur schreibt eine Zeichenkette direkt in den Bildschirmpuffer.
"line" und "pos" beziehen sich auf die relativen Koordinaten des aktuellen Bildschirmfensters (Window). Der Cursor wird NICHT weiterbewegt und Steuerzeichen werden NICHT ausgef
hrt.
DisplayString arbeitet in den Fensterkoordinaten, wie sie in line0, col0 - lineN, colN festgelegt sind. Die Prozedur arbeitet nur im Textmodus. Sie ist sehr schnell, da direkt in den Bildschirmspeicher geschrieben wird.
ck zum Modul Display
Display.DisplayLine
PROCEDURE DisplayLine(line: ARRAY OF CHAR;
lineno: CARDINAL;
attr: CARDINAL);
Schreibt eine 80 Zeichen lange Zeile direkt in den Bildschirmspeicher. "attr" das zu verwendende Bildschirmattribut (Farbe). Falls die L
nge des Strings kleiner als 80 ist, wird der Rest mit Leerzeichen aufgef
llt.
Die Prozedur arbeitet in den Fensterkoordinaten, wie sie in line0, col0 - lineN, colN festgelegt sind. Sie arbeitet nur im Textmodus. Sie ist sehr schnell, da direkt in den Bildschirmspeicher geschrieben wird.
ck zum Modul Display
Display.WriteScreen
PROCEDURE WriteScreen(src, dest: ADDRESS;
nWords: CARDINAL);
Bewegt "nWords" "src" nach "dest".
dest mu
innerhalb des Bildschirmspeichers liegen. Falls snowy auf TRUE gesetzt ist, wird das vertikale Retrace-Signal des Monitors ber
cksichtigt.
ck zum Modul Display
Display.ReadScreen
PROCEDURE ReadScreen(src, dest: ADDRESS;
nWords: CARDINAL);
Bewegt "nWords" "src" nach "dest". "src" mu
sich innerhalb des Bildschirmspeichers befinden. Falls snowy = TRUE gesetzt ist, wird das vertikale Retrace-Signal des Monitors ber
cksichtigt. C
Die Prozedur arbeitet im Rahmen des aktuellen Bildschirmfensters.
ck zum Modul Display
Display.Buffer
TYPE
DisplayBuffer = ARRAY [0..24] OF
ARRAY [0..79] OF CARDINAL;
displayPtr: POINTER TO DisplayBuffer;
Die Variable wird zu Initialisierungszeit geladen.
ck zum Modul Display
MODULE Windows
Das Modul stellt eine einfache Implementation von Routinen f
berlappende Text-Windows zur Verf
gung. Alle Prozeduren dieses Moduls erwarten, da
sich die Bildschirmanzeige im Textmodus befindet. Z
Das Modul installiert die Prozeduren Write und Goto aus dem Modul Display nach TermBase.
definierter Typ:
Window
definierte Prozeduren:
OpenWindow SelectWindow
CloseWindow CloseCurWindow
NewWindowTitle
ck zum Index oder zu Routinen, Ende mit ESC
Windows.Window
TYPE Window;
opaker Datentyp f
r die Steuerung der Fensterroutinen.
ck zum Modul Windows.
Windows.OpenWindow
PROCEDURE OpenWindow(VAR w: Window;
l1, c1, l2, c2: CARDINAL;
frame: BOOLEAN;
header: ARRAY OF CHAR);
ffne ein neues Fenster mit der oberen linken Ecke bei "l1", "c1" und der rechten unteren Ecke bei "l2", "c2". Wenn die Variable "frame" TRUE ist, wird ein Rahmen um das Window gezeichnet. Die Fenster-
berschrift wird automatisch in der obersten Fensterzeile zentriert.
ck zum Modul Windows.
Windows.SelectWindow
PROCEDURE SelectWindow(w: Window;
mustSave: BOOLEAN);
Mache das Fenster "w" zum aktuellen Fenster, indem "w" an den Top des Windowstack gelegt wird.
Die Variable "mustSave" dient dazu, schnellere Fensterumschaltungen zu erlauben, wenn sich die Fenster nicht
berlappen. Wenn "mustSave" FALSE ist, wird der Inhalt des aktuellen Fensters nicht gesichert und der Inhalt des neuen Fensters nicht restauriert
ck zum Modul Windows.
Windows.CloseWindows
PROCEDURE CloseWindow(w: Window);
Schlie
e (zerst
re) Window "w".
ck zum Modul Windows.
Windows.CloseCurWindows
PROCEDURE CloseCurWindow;
Schlie
e das oberste Fenster. Das vorher aktive Window wird zum aktuellen Fenster.
ck zum Modul Windows.
Windows.NewWindowTitle
PROCEDURE NewWindowTitle(header: ARRAY OF CHAR);
Zeigt einen neuen Fenstertitel an.
ck zum Modul Windows.
MODULE Break
Dieses Modul erlaubt dem Benutzer, den Ctrl-Break (Vektor 1BH) und den von DOS generierten Ctrl-C Interrupt (Vektor 23H) auszul
sen oder zu sperren. Bei der Initialisierung wird BREAK automatisch abgeschaltet. Das Anwendungsprogramm mu
EnableBreak aufrufen, um die Verarbeitung von Abbruchtasten zuzulassen. Der Breakinterrupt-Handler pr
ft das DOS Busy-Flag um die Ausf
hrung von Ctrl-Break w
hrend Aktivit
ten von DOS zu verh
ten. Der voreingestellte Break-Handler bricht einfach das Programm mit einem ErrorLevel von 6 ab. DisableBreak wird immer aufgerufen, bevor die Kontrolle an eine benutzerdefinierte Breakhandler-Routine
bergeben wird. Sollte die benutzerdefinierte Breakhandlerroutine ins Programm zur
ckkehren, wird das Programm mit einem Errorlevel von 6 beendet.
Benutzung: C
Um zu verhindern, da
ein Benutzer das Programm mit Ctrl-Break oder Ctrl-C beendet, mu
nur das Modul importiert werden. W
hrend der Testphase eines Programms kann es sinnvoll sein, das Modul zu importieren und EnableBreak aufzurufen. Dies erlaubt ein Programm auch dann zu beenden, wenn es in einer Endlosschleife h
ngt.
definierte Prozeduren:
EnableBreak InstallBreakHandler
DisableBreak UninstallBreakHandler
ck zum Index oder zu Routinen, Ende mit ESC
Break.DisableBreak
PROCEDURE DisableBreak;
Schaltet die
berwachung von Crt-Break aus. Das Dr
cken von Ctrl-Break bleibt so ohne Wirkung.
ck zum Modul Break
Break.EnableBreak
PROCEDURE EnableBreak;
Erlaubt die Ausf
hrung von Ctrl-Break. Der voreingestellte Break-Handler beendet das Programm.
Liefert die Dateibezeichnung ohne den Dateinamen in "dir". `
Das Beispiel:
ExtractDirName("d:m2\comp\mc.mod", dir);
liefert zur
dir = "d:m2\comp"
ck zum Modul FileSpec
FileSpec.ExtractFileName
PROCEDURE ExtractFileName(
filespec: ARRAY OF CHAR;
VAR name: ARRAY OF CHAR);
Gibt in "name" den Dateinamen von "filespec" zur
ck. 9
Beispiel:
ExtractFileName("d:m2\comp\mc.mod", name);
gibt zur
name = "mc.mod"
ck zum Modul FileSpec
FileSpec.DropExt
PROCEDURE DropExt(
filespec: ARRAY OF CHAR;
VAR newspec: ARRAY OF CHAR);
Die Prozedur liefert in "newspec" den Dateinamen mit der vollen Pfadangabe zur
ck. <
Beispiel:
ExtractFileName("d:m2\comp\mc.mod", newspec);
gibt zur
newspec = "d:m2\comp\mc"
ck zum Modul FileSpec
FileSpec.HasExt
PROCEDURE HasExt(filespec: ARRAY OF CHAR): BOOLEAN;
TRUE, falls die Dateiangabe eine Dateiendung besitzt.
ck zum Modul FileSpec
MODULE KeyBoard
Dieses Modul liefert die Schnittstelle zu den BIOS-Tastatur-Routinen. /
definierte Typen:
ShiftKeys ShiftStatus
definierte Prozeduren:
GetKey GetKeyCh
GetFunKey GetShiftStatus
KeyPressed
erdem sind in KeyBoard alle Tastaturcodes als Konstanten definiert. 1
ck zum Index oder zu Routinen, Ende mit ESC
Tabelle der Tastaturcodes
CONST
Break = 80X; ShiftTab = 81X;
AltQ = 82X; AltW = 83X;
AltE = 84X; AltR = 85X;
AltT = 86X; AltY = 87X;
AltU = 88X; AltI = 89X;
AltO = 8AX; AltP = 8BX;
AltA = 90X; AltS = 91X;
AltD = 92X; AltF = 93X;
AltG = 94X; AltH = 95X;
AltJ = 96X; AltK = 97X;
AltL = 98X; AltZ = 09EX;
AltX = 09FX; AltC = 0A0X;
AltV = 0A1X; AltB = 0A2X;
AltN = 0A3X; AltM = 0A4X;
F1 = 0ADX; F2 = 0AEX;
F3 = 0AFX; F4 = 0B0X;
F5 = 0B1X; F6 = 0B2X;
F7 = 0B3X; F8 = 0B4X;
F9 = 0B5X; F10 = 0B6X;
Home = 0B9X; Up = 0BAX;
PgUp = 0BBX; Left = 0BDX;
Right = 0BFX; End = 0C1X;
Down = 0C2X; PgDn = 0C3X;
Ins = 0C4X; Del = 0C5X;
SF1 = 0C6X; SF2 = 0C7X;
SF3 = 0C8X; SF4 = 0C9X;
SF5 = 0CAX; SF6 = 0CBX;
SF7 = 0CCX; SF8 = 0CDX;
SF9 = 0CEX; SF10 = 0CFX;
CF1 = 0D0X; CF2 = 0D1X;
CF3 = 0D2X; CF4 = 0D3X;
CF5 = 0D4X; CF6 = 0D5X;
CF7 = 0D6X; CF8 = 0D7X;
CF9 = 0D8X; CF10 = 0D9X;
AF1 = 0DAX; AF2 = 0DBX;
AF3 = 0DCX; AF4 = 0DDX;
AF5 = 0DEX; AF6 = 0DFX;
AF7 = 0E0X; AF8 = 0E1X;
AF9 = 0E2X; AF10 = 0E3X;
CtrlPrtSc = 0E4X; CtrlLeft = 0E5X;
CtrlRight = 0E6X; CtrlEnd = 0E7X;
CtrlPgDn = 0E8X; CtrlHome = 0E9X;
Alt1 = 0EAX; Alt2 = 0EBX;
Alt3 = 0ECX; Alt4 = 0EDX;
Alt5 = 0EEX; Alt6 = 0EFX;
Alt7 = 0F0X; Alt8 = 0F1X;
Alt9 = 0F2X; Alt0 = 0F3X;
AltMinus = 0F4X; AltEquals = 0F5X;
CtrlPgUp = 0F6X;
ck zum Index Ende mit ESC
KeyBoard.ShiftKeys / .ShiftStatus
TYPE
ShiftKeys = (rightShift,
leftShift,
Ctrl,
Alt,
ScrollLock,
NumLock);
ShiftStatus = SET OF ShiftKeys;
ck zum Modul KeyBoard
KeyBoard_KeyPressed
PROCEDURE KeyPressed(): BOOLEAN;
Wartet da ein Zeichen im Tastaturpuffer? :
ck zum Modul KeyBoard oder zur KeyPressed-
bersicht.
KeyBoard.GetKey
PROCEDURE GetKey(VAR k: CHAR);
Entspricht der "INKEY"-Funktion in BASIC. p
Es wird entweder ein Zeichen oder 0C oder mit dem n
chsten Aufruf der erweiterte Tastaturcode zur
ckgeliefert.
ck zum Modul KeyBoard
KeyBoard.GetKeyCh
PROCEDURE GetKeyCh(VAR ch: CHAR);
Erweiterte Tastaturcodes werden in die oberen 128 ASCII-Zeichen
bertragen, wie sie in der Tabelle der Tastaturcodes zusammengefa
t sind.
ck zum Modul KeyBoard
KeyBoard.GetFunKey
PROCEDURE GetFunKey(VAR ch: CARDINAL);
Diese Prozedur unterst
tzt den internationalen Zeichensatz, der das obere Bit von CHAR ben
tzt. Der Ordinalwert der regul
ren Zeichen wird zur
ckgegeben. Erweiterte Zeichen werden in die oberen 128 ASCII-Zeichen umgelagert. Anschlie
end wird 100H dazuaddiert. So wird von <F1> der Wert 01ADH zur
ckgegeben.
ck zum Modul KeyBoard
KeyBoard.GetShiftStatus
PROCEDURE GetShiftStatus(VAR st: ShiftStatus);
Liefert den Status der Shift/Control-Tasten
ck zum Modul KeyBoard
MODULE Menu
In diesem Modul sind nur die beiden Men
typen PopMenu und PullDownMenu definiert. H
Das Modul verwendet das Modul Windows, um die Men
fenster zu erzeugen. 1
ck zum Index oder zu Routinen, Ende mit ESC
Menu.PopMenu
PROCEDURE PopMenu(line,
col: CARDINAL;
menu: ARRAY OF CHAR;
width: CARDINAL;
clear: BOOLEAN;
VAR cmd: CARDINAL );
Klappt ein Men
bei line, col auf.
"menu" ist eine Zeichenkette von Men
s, die durch das Zeichen "|" getrennt werden. Der erste Eintrag enth
lt den Titel des Men
s. "width" ist die minimale Breite f
r das Men
-Window. Falls "clear" TRUE ist, wird das Men
nach der Men
auswahl zerst
rt, sonst bleibt es auf dem Bildschirm. Dann mu
es mit Windows.CloseCurWindow entfernt werden. "cmd" ist 0, falls kein Men
punkt ausgew
hlt wurde (ESC), ansonsten wird die Nummer des Men
punktes zur
ckgegeben. ~
Falls bei der R
ckgabe cmd = 0 ist, wird das Fenster auf alle F
lle geschlossen, egal welcher Wert in clear abgegeben wurde. H
Beispiel:
PopMenu(5, 10, "Hauptmen
|Hallo|Bye|Ende", 0, TRUE, cmd);
Siehe auch PullDownMenu
ck zum Modul Menu
Menu.PullDownMenu
PROCEDURE PullDownMenu(line : CARDINAL;
frame : BOOLEAN;
MainMenu: ARRAY OF CHAR;
SubMenus: ARRAY OF CHAR;
clear : BOOLEAN;
VAR cmd1,
cmd2 : CARDINAL);
Erstellt ein Pulldown-Men
in der Zeile "line".
In "frame" wird angegeben, ob der Pulldownbalken einen Rahmen bekommt. "MainMenu" ist eine Zeichenkette, in der die Men
punkt, getrennt von einem "|" angegeben werden. "SubMenus" ist eine Zeichenkette mit Untermen
s, getrennt von "&"; jedes der Untermen
s enth
lt eine Liste von Auswahlpunkte, getrennt von "|". Bei der R
ckgabe enth
lt "cmd1" die Nummer des gew
hlten Hauptmen
punkts und "cmd2" die Nummer des entspechenden Untermen
punkts. Falls der Benutzer ESC dr
ckt, liefert cmd1 0 zur
ck. 7
Alle Men
fenster werden vor der R
ckkehr geschlossen.
siehe auch PopMenu
ck zum Modul Menu
MODULE Loader
In diesem Modul ist nur die Prozedur Execute definiert, die dazu dient, andere Programme nachzuladen. Sie entspricht der Turbo-Pascal Prozedur "Exec". $
ck zum Index oder zu Routinen,
Ende mit ESC
Loader.Execute
PROCEDURE Execute(pgm: ARRAY OF CHAR;
args: ARRAY OF CHAR;
VAR exitcode: CARDINAL);
Die Prozedur startet das externe Programm "pgm" mit der Argument "args". Es mu
der volle Pfadname des externen Programms angegeben werden. $
Bei der R
ckkehr aus der Prozedur: j
exitcode < 32768:
Die Ausf
hrung konnte nicht stattfinden.
Der DOS-Exitcode wird zur
ckgegeben.
exitcode >= 32768:
exitcode MOD 256 ist der Exitcode
des Programms "pgm"
(exitcode-32768) DIV 256
ist der Grund f
r die Beendigung
des Programms:
0 = normal
1 = durch Ctrl-C
2 = Kritischer Ger
tefehler
3 = DOS-Funktion 31H (TSR)
Execute versucht, dem aufgerufenen Programm m
glichst viel Speicher zuzuweisen, indem der Speicher
ber System.HeapTop freigegeben wird. Das aufgerufene Programm darf nicht speicherresident verbleiben (TSR)!!!
ck zum Modul Loader
MODULE Paths
Im Modul Paths ist nur die Prozedur Locate definiert. 1
ck zum Index oder zu Routinen, Ende mit ESC
Paths.Locate
PROCEDURE Locate(fileName: ARRAY OF CHAR;
envPath: ARRAY OF CHAR;
VAR PathAndName: ARRAY OF CHAR;
VAR found: BOOLEAN);
Es wird versucht, die im Environment-String "envPath" angebenen Pfade nach der Datei "filename" zu durchsuchen. Falls die Datei gefunden wird, wird der vollst
ndige Name inklusive des Pfades in PathAndName zur
ckgegeben. q
Beispiel:
Locate("M2IDE.CFG", "PATH", pathName, found);
IF found THEN
Lookup(f, pathName);
...
ck zum Modul Paths
MODULE RealConversion
definierte Prozeduren:
RealToString StringToReal
LongRealToString StringToLongReal
ck zum Index oder zu Routinen, Ende mit ESC
RealConversion.RealToString
PROCEDURE RealToString(x: REAL;
decDigits, n: INTEGER;
VAR s: ARRAY OF CHAR;
VAR ok: BOOLEAN);
Konvertiert "x" in ein Zeichenfeld. "n" ist die Breite des Zeichenfeldes. ABS(decDigits) ist die Zahl der gew
nschten Stellen. Das Ergebnis wird in "s" zur
ckgegeben. "ok" wird auf TRUE gesetzt, wenn die Umwandlung erfolgreich durchgef
hrt wurde.
Die Ausgabe von "s" erfolgt im Fixkomma-Format, wenn "decDigits" positiv ist, sonst erfolgt die Ausgabe in wissenschaftlicher Notation. Falls "n" gr
er als die Zahl der ben
tigten Zeichen f
r die Umwandlung ist, wird s links mit Leerzeichen aufgef
llt. b
Falls decDigits > 0 ist, mu
"n" >= decDigits + 2 sein, sonst mu
n >= ABS(decDigits) + 7 sein.
Beispiele: D
RealToString(1.148, 2, 6, s, ok) w
rde " 1.15" in s zur
ckgeben. I
RealToString(1.148, -2, 10, s, ok) w
rde " 1.15E+00" in s zur
ckgeben. "
ck zum Modul RealConversion
RealConversion.StringToReal
PROCEDURE StringToReal(s: ARRAY OF CHAR;
VAR x: REAL;
VAR ok: BOOLEAN);
Konvertiert die Zeichenkette s in eine Real-Zahl. Es wird eine Realzahl im Modula-2-Flie
kommazahlenformat erwartet. !
ck zum Modul RealConversion
RealConversion.LongRealToString
PROCEDURE LongRealToString(x: LONGREAL;
decDigits, n: INTEGER;
VAR s: ARRAY OF CHAR;
VAR ok: BOOLEAN);
Arbeitet identisch wie RealToString. !
ck zum Modul RealConversion
RealConversion.StringToLongReal
PROCEDURE StringToLongReal(s: ARRAY OF CHAR;
VAR x: LONGREAL;
VAR ok: BOOLEAN);
Arbeitet identisch wie StringToReal. !
ck zum Modul RealConversion
MODULE TimeDate
In diesem Modul sind der Typ Time und die beiden Prozeduren GetTime und SetTime definiert. 1
ck zum Index oder zu Routinen, Ende mit ESC
TYPE TimeDate.Time
TYPE
Time = RECORD
day,
minute,
millisec: CARDINAL;
END;
day = ((Jahr - 1900) * 16
+ Monat * 32
+ Tag_des_Monats)
minute = Minuten seit
Mitternacht
millisec = Millisekunden der
letzten vollen Minute
ck zum Modul TimeDate
TimeDate.GetTime
PROCEDURE GetTime(VAR time: Time);
Liefert die Systemzeit.
ck zum Modul TimeDate
TimeDate.SetTime
PROCEDURE SetTime(time: Time);
Setzt die Systemzeit.
ck zum Modul TimeDate
Compilerschalter
Durch im Programmtext enthaltene Befehle k
nnen verschiedene Compiler-Schalter gesetzt werden, die die Code-Erzeugung beeinflussen.
Diese Befehle m
ssen am Anfang eines Kommentars stehen; mehrere Compiler-Befehle k
nnen durch Kommata getrennt in einem Kommentar aufgereiht werden.
Beispiel:
(* $S-, $R+ *)
Ein "+" setzt den Schalter auf TRUE, ein "-" setzt ihn auf FALSE und ein "=" setzt den Wert auf den vorausgegangenen Wert zur
ck. @
Von Fitted Modula-2 Version 2.0 unterst
tzte Compilerschalter: B
(*$A+/$A-*)
(*$S+/$S-*)
(*$R+/$R-*)
(*$T+/$T-*)
(*$L+/$L-*)
ck zum Index, Ende mit ESC
Befehl: $A, Vorbelegung: +
Ausrichtung
-----------
Bei "+" werden alle neu deklarierten Variablen an Wortgrenzen (1 Wort = 2 Bytes) aus gerichtet. Record-Komponenten werden ungeachtet dieses Befehls gepackt (jedoch nicht ausgerichtet). )
ck zur
bersicht: Compilerschalter.
Befehl: $S, Vorbelegung: +
Stack-
berlauf-Kontrolle
------------------------
Bei "+" wird bei Eintritt in ein Unterprogramm gepr
ft, ob der verf
gbare Platz auf dem Stack ausreicht. Diese Pr
fung wird auch beim Kopieren von offenen Arrays in den lokalen Stack-Rahmen eines Unterprogramms durchgef
hrt. )
ck zur
bersicht: Compilerschalter. "
ck zum Men
Compilerschalter
Befehl: $R, Vorbelegung: +
Bereichs-Pr
----------------
Bei "+" wird vor jeder Zuweisung auf eine Variable eines Teilbereichs-Typs (Subrange) gepr
ft, ob der zuzuweisende Wert wirklich innerhalb der erlaubten Bereichsgrenzen liegt.
Wenn die Compiler-Option $R gesetzt ist, erzeugt der Compiler Code zur Bereichspr
fung ("range check code") bei Zuweisungen zwischen INTEGERs und CARDINALs. Der Wert ist unabh
ngig von der Zuweisungsrichtung au
erhalb des zugelassenen Bereiches, wenn das h
chstwertige Bit 1 ist. "
ck zum Men
Compilerschalter
Befehl $T, Vorbelegung: +
Feld-Index-Pr
------------------
Bei "+" wird bei jedem Zugriff auf ein Feld (Array)
ber Index zuvor gepr
ft, ob der Index nicht au
erhalb der definierten Feldgrenzen liegt.
Wenn die Compiler-Option $T gesetzt ist, werden Zeiger vor dem Zugriff auf NIL gepr
ft. Au
erdem setzt Storage.DEALLOCATE den
bergebenen Zeiger auf NIL. "
ck zum Men
Compilerschalter
Befehl $L, Vorbelegung -
Erzeuge Zeilennummer-Information
--------------------------------
Bei "+" erzeugt der Compiler eine Liste der Quelltext-Zeilennummern und der entsprechenden Objectcode-Adressen in der Ausgabedatei. Diese Liste wird beim Linken mit der /L-Option in die .DBG-Datei geschrieben. Mit DBG2MAP kann anschlie
end eine Standard-MAP-Datei geschrieben werden, die mit TDMAP an das EXE-Programm angeh
ngt werden kann, um die Bearbeitung mit dem Turbo-Debugger zu erm
glichen. #
ck zum Men
Compilerschalter
Laufzeitfehler
Wenn w
hrend der Ausf
hrung eines Programms ein Laufzeitfehler auftritt, wird das Programm von der Laufzeitfehler-Behandlungsroutine abgebrochen und eine Nachricht
ber Art und Stelle (Adresse) des Fehlers ausgegeben.
Stack
Overflow
Range
Overflow
Integer
Overflow
Floating
Point
Overflow
RETURN
HALT
ck zum Index, Ende mit ESC
Runtime-Error 0
Stack-
berlauf ($S Option)
ck zum Men
Laufzeitfehler
Runtime-Error 1
Bereichs-Fehler ($R oder $T Option)
ck zum Men
Laufzeitfehler
Runtime-Error 2
Integer/Cardinal-
berlauf (Division durch Null)
ck zum Men
Laufzeitfehler
Runtime-Error 3
Fehler bei einer Flie
komma-Operation
ck zum Men
Laufzeitfehler
Runtime-Error 4
Funktion hat kein RETURN ausgef
hrt.
ck zum Men
Laufzeitfehler
Runtime-Error 5
HALT wurde aufgerufen.
ck zum Men
Laufzeitfehler
MODULA Standard-Typen
Datentyp-Darstellung:
CHAR 1 Byte
INTEGER 2 Bytes 2er-Komplement
CARDINAL 2 Bytes
LONGCARD 4 Bytes
LONGINT 4 Bytes 2er-Komplement
BOOLEAN 1 Byte (1 = TRUE, 0 = FALSE)
REAL 4 Bytes im Intel-8087-Format.
LONGREAL 8 Bytes im Intel-8087-Format.
BITSET 1 Wort. 0 = low Order Bit, 15 = high Order Bit.
SET 1 bis 8 Worte (Mengen bis zu 256 Elemente)
POINTER 4 Bytes im Intel-8086/88-Format
PROCEDURE 4 Bytes POINTER zur Prozedur-Startadresse
Adressen sind im Intel-8086-Format dargestellt: +
1 Wort BYTE OFFSET
1 Wort SEGMENT
Numerische Werte sind gleichfalls so dargestellt, wie bei der Intel 8086-Prozessor-Familie
blich: niederwertiges Byte zuerst, h
herwertiges Byte zuletzt.
ck zum Index, Ende mit ESC
CHAR
Einfacher vorzeichenloser 8-Bit Datentyp. Q
CHAR implementiert den ASCII-Zeichensatz, kann aber auch als normaler Datentype verwendet werden. CHARs m
ssen in oktaler Schreibweise angegeben werden. CHAR-Konstanten werden durch ein nachstehendes C gekennzeichnet. Das Modul ASCII vereinfacht die Zuweisung von ASCII-Zeichen, da dort alle Steuerzeichen als Konstante definiert sind.
Zuweisungen von CHARs w
CONST
ch = 36C; (* oktal ! *)
Space = ' '; (* direkt zugewiesen *)
Qote = "'"; (* Hochkomma in Anf
hrungszeichen *)
Enter = ASCII.EOL; (* importiert! *)
c: CHAR;
BEGIN
c := '"'; (* Anf
hrungszeichen in Hochkommas *)
...
CHAR ist zuweisungskompatibel mit SYSTEM.BYTE, mu
aber im Gegensatz zu BYTE nicht importiert werden. CHAR-Konstanten werden mit einfachem (') oder doppeltem (") Hochkomma eingerahmt. Die in Pascal m
gliche Notierung eines Hochkommas in einer Zeichenkette oder als CHAR ist nicht m
glich. Stattdessen k
nnen genauso wie Assembler die beiden Kennungen gemischt werden: >
'"' wird f
r Anf
hrungsstriche, "'" f
r Hochkomma verwendet. 4
Der Typ String ist in Modula-2 nicht vordefiniert. 5
Ein "String" ist ein ARRAY OF CHAR, beispielsweise: )
TYPE
String: ARRAY [0..79] OF CHAR;
Da Modula-Strings als normale Arrays im Gegensatz zu Turbo-Pascal Strings kein L
ngenbyte besitzen, kann das ARRAY bei 0 beginnen.
ck zum Typen-Men
INTEGER
Vorzeichenabh
ngiger 16-Bit Datentyp. !
Wertebereich: -32768 bis 32767
ck zum Typen-Men
CARDINAL
Vorzeichenloser 16-Bit Datentyp.
CARDINAL entspricht dem Turbo-Pascal Datentyp Word und ist zuweisungskompatibel zu dem systemabh
ngigen 16-Bit-Datentype SYSTEM.WORD.
Wertebereich: 0 bis 65535.
ck zum Typen-Men
LONGINT/LONGCARD
Der Fitted-Modula-2-Compiler implementiert die 32-Bit Standard-Typen LONGINT und LONGCARD.
Operanden des Typs LONGINT oder LONGCARD d
rfen wie INTEGER oder CARDINAL in jedem Ausdruck auftauchen. Aber das ist auch schon alles! ;
Teilbereiche (Subranges) dieser Typen sind nicht m
glich. h
Keine Standard-Prozeduren akzeptieren Operanden dieser Typen (au
er INC, DEC und verwandten). Eine Variable vom Typ LONGINT oder LONGCARD darf weder als Steuerungs-Variable einer FOR-Schleife, noch als CASE-Marke vorkommen. LONGINT- oder LONGCARD-Konstanten k
nnen nur dezimal geschrieben werden und enden mit einem "L", falls der Wert kleiner als 65536 ist.
Beispiel:
123L und 123567 sind korrekte LONGCARD- oder LONGINT-Konstanten, 5
-1L und -348762 sind korrekte LONGINT-Konstanten 7
Wertebereich f
r LONGINT: -2147483648 bis 2147483647. /
Wertebereich f
r LONGCARD: 0 bis 4294967297.
ck zum Typen-Men
Boolescher Datentyp
Variablen vom Typ BOOLEAN k
nnen ausschlie
lich einen der vordefinierten Werte FALSE ( # 0) oder TRUE ( = 0) annehmen. Tats
chlich handelt es sich bei Boolean um einen Aufz
hlungstyp, der folgenderma
en deklariert ist: Zuweisungen wie PRED und SUCC sind m
glich. FALSE ist ein SUCC oder PRED von TRUE. #
TYPE
BOOLEAN = (FALSE, TRUE);
Die Anwendung der Operatoren = <> > < >= <= IN innerhalb eines Ausdrucks erzeugt Ergebnisse vom Typ BOOLEAN.
ck zum Typen-Men
REAL
kommazahlen. Der Datentyp entspricht dem Turbo-Pascal (ab 5.0) Datentyp Single und ist vier Bytes gro
REAL arbeitet mit sieben bis acht Stellen Genauigkeit. F
r genauere Operation kann LONGREAL verwendet werden. F
r Ein- und Ausgaben steht das Modul RealInOut, f
r mathematische Opertionen das Modul MathLib0 zur Verf
gung. String-Konvertierungen werden in RealConversion durchgef
hrt. ,
Wertebereich f
r REAL: 1.5E-45 bis 3.4E38.
ck zum Typen-Men
LONGREAL
Ab der Version 2.0 von Fitted Modula-2 besteht eine Wahlm
glichkeit bei der Gr
e des REAL-Typs. Version 1.x unterst
tzte nur das 4-Byte-Format, mit dem eine Genauigkeit von etwa sieben Stellen erreicht wird, w
hrend mit dem acht Bytes langen LONGREAL-Format etwa 15 bis 16 Stellen m
glich sind.
Die Typen REAL and LONGREAL sind nicht kompatibel und es gibt keinerlei automatische Umwandlung zwischen diesen Typen. Stattdessen stehen f
r diese Umwandlungen die Standard-Prozeduren SHORT und LONG zur Verf
gung. Konstanten vom Typ LONGREAL unterscheiden sich nicht von REAL-Konstanten. Der Typ wird durch den Kontext bestimmt. Sie k
nnen eine Konstante jedoch durch den Gebrauch der SHORT- oder der LONG-Procedure "typisieren". 1
Beispiel:
CONST
longreal1 = LONG(1.0);
r Ein- und Ausgaben steht das Modul RealInOut, f
r mathematische Opertionen das Modul LMathLib0 zur Verf
gung. String-Konvertierungen werden in RealConversion durchgef
hrt. 2
Wertebereich f
r LONGREAL: 5.0E-324 bis 1.7E308.
ck zum Typen-Men
BITSET
Zusammengesetzter Datentyp der ein BYTE aufschl
sselt. ;
Bitset-Werte werden in geschweiften Klammern geschrieben. Z
Ein Bitset sind beispielsweise die FLAGS oder die Dateiattribute des Moduls Directories. @
Aufgesch
sselt werden Bitsets
ber eine sehr einfache Abfrage: "
IF FLAGS = {carryFlag} THEN ...
Ist nur dann TRUE, wenn das CarryFlag (Bit 0 des Flagregisters) gesetzt ist. A
Das Flagregister ist in System als VAR FLAGS: BITSET definiert.
ck zum Typen-Men
SET
Diese Deklaration vereinbart eine Menge des durch Elemententyp angegebenen Typs: !
Syntax:
SET of Elemententyp
Der entsprechende Basistyp mu
ordinal sein und darf maximal 256 verschiedene Werte beinhalten, deren Grenzen innerhalb des Bereichs 0..255 liegen m
ssen.
ber geschweiften Klammern und eine Aufz
hlung von Ausdr
cken ist die Definition von Teilbereichen auch innerhalb einer Mengen-Deklaration m
glich. W
() steht hier f
r eine leere Menge, die mit allen anderen Mengentypen kompatibel ist.
Beispiel: (
(* Mengen mit ordinalen Basistypen *)
TYPE
Tag = (Son, Mon, Die, Mit, Don, Fre, Sam);
CharSet = SET OF CHAR;
Tage = SET OF Tag;
(* Mengen mit Angaben von Unterbereichen *)
('0'..'9', 'A'..'Z', 'a'..'z', '_')
(1, 5, I + 1 .. J - 1)
(Mon..Fre)
ck zum Typen-Men
POINTER
Eine Zeigervariable enth
lt die Speicheradresse einer anderen Variablen des Typs, f
r den die Zeigervariable deklariert wurde. Q
Mit den folgenden Operationen lassen sich einer Zeigervariablen Werte zuordnen: $
den Prozeduren NEW oder ALLOCATE
der Standardprozedur PTR L
Das reservierte Wort NIL steht f
r einen Zeiger, der "nirgendwohin" zeigt. z
Der vordefinierte Datentyp POINTER steht f
r einen untypisierten Zeiger, der mit jedem anderen Zeigertyp kompatibel ist.
Beispiele: "
(* POINTER Typdeklarationen: *)
TYPE
BytePtr = POINTER TO BYTE;
WordPtr = POINTER TO CARDINAL;
IdentPtr = IdentRec;
IdentRec = RECORD
IdentStr: ARRAY [0..15] OF CHAR;
RefCount: CARDINAL;
Next: IdentPtr;
END;
ck zum Typen-Men
PROCEDURE
Modula-2 implementiert den Typ PROCEDURE als Zeiger auf eine Prozedur.
ck zum Typen-Men
Reservierte Worte
Ein Teil der Befehle in Modula geh
rt zum Sprachumfang und kann auch in dem Buch "Programming in Modula-2" von N. Wirth nachgelesen werden. U
Hier sind nur die wichtigsten Standardprozeduren und Standardoperatoren aufgef
hrt:
Prozeduren
ABS(x) : Absoluter Wert eines numerischen Operanden x
CAP(x) : Umwandlung eines Zeichens (x) in seinen Gro
buchstaben
CHR(x) : Das Zeichen CHAR mit dem ordinalen Wert x
DEC(x) : Verkleinere x um 1
FAR : Adre
-Zuweisung
HALT : Beendet das Programm
INC(x) : Vergr
ere x um 1
NEAR : Adress-Zuweisung
ODD : TRUE, falls der ordinale Wert X eine ungerade Zahl ist.
ORD(X) : Der CARDINAL-Wert des Arguments X
VAL(t,x): Der Wert x konvertiert zum TYP t
Operatoren
Op.
INTEGER/CARD.
REAL
SET
+
Addition
Addition
Vereinigung
-
Subtraktion
Subtraktion
Differenz
*
Multiplikation
Multiplikation
Durchschnitt
/
---
Division
---
DIV
Division
---
---
MOD
Modulo
---
---
Diese relationalen Operatoren liefern als Ergebnistyp BOOLEAN: !
(.txt)