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
Standard-Typen
ASCII-Zeichen
Tastaturcodes
Inline-Assembler
Compilerschalter
Laufzeitfehler
Reservierte
Worte
Compiler-Begrenzungen
Sprachkonventionen
Objekt-Zeitstempel
Environment-Variablen
Routinen
Ende mit ESC
Modul-Index
SYSTEM
System
ASCII
InOut
LongJump
FileSystem
MathLib0
LMathLib0
Menu
Loader
Paths
RealConversion
TimeDate
Display
Windows
Break
Directories
Files
NumberConversion
RealInOut
Storage
Strings
TermBase
Terminal
TermIO
KeyBoard
FileSpec
ck zum Index, Ende mit ESC
Liste der Standandprozeduren
ALLOCATE
Append
arctan
ASCIIZ
Assign
AssignGoto
AssignRead
AssignWrite
Available
CardToString
ChDir
Close
CloseCurWindow
CloseInput
CloseOutput
CloseWindow
ClrEOL
ClrEOS
ClrScreen
CompareStr
Concat
Copy
Create
CreateNew
CreateTemp
DEALLOCATE
Delete
DirQuery
DisableBreak
DisplayLine
DisplayString
DISPOSE
DropExt
Dup2
EnableBreak
entier
ErrorMessage
ErrorLn
Execute
ExtractDirPath
ExtractFileName
Weiter .
FLAT
FLOAT
GetArg
GetCurDir
GetCursorPosition
GetDisplayMode
GetDTA
GetEnv
GetFileAttr
GetFileTime
GetFirstDir
GetFunKey
GetKey
GetKeyCh
GetLPos
GetNextDir
GetPos
GetShiftStatus
GetTime
GetVector
Goto
HasExt
Insert
InstallBreakHandler
InstallRTErrorHandler
IntToString
KeyPressed
Length
LLength
Locate
Lock
LongCardToString
LongIntToString
LongJump
LongNumToString
LongRealToString
LookUp
MkDir
Move
NEWPROCESS
NewWindowTitle
NumToString
OFFSET
Open
OpenInput
OpenOutPut
OpenWindow
ParseFileSpec
PopMenu
PullDownMenu
Weiter2
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
sqrt
StringToInt
StringToLongCard
StringToLongInt
StringToLongNum
StringToLongReal
StringToNum
StringToReal
Terminate
TermProcedure
TRANSFER
Trap
TRUNC
Weiter3
UnAssignGoto
UnAssignRead
UnAssignWrite
UninstallBreakHandler
UninstallRTErrorHandler
Unlock
Write
WriteCard
WriteChar
WriteCharAttr
WriteHex
WriteInt
WriteLine
WriteLn
WriteLongCard
WriteLongInt
WriteNBytes
WriteOct
WriteReal
WriteScreen
WriteString
WriteWord
WriteWrd
XTrap
Index
der integrierte Assembler
Es ist ein 8086 Inline-Assembler eingebaut. Wenn "ASSEMBLER" aus SYSTEM importiert ist, k
nnen Sie im Text 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.
Beispiel:
loop: CMP BYTE [SI], 0
(* String-Ende erreicht? *)
MOV BYTE [DI], [SI]
INC SI
INC DI (* Zeiger erh
hen *)
JMP loop
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. 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. 8
Alle Spr
nge werden vom Compiler optimiert. Deshalb braucht die Sprungweite nicht spezifiziert zu werden. Der Compiler wird insbesondere einen bedingten Sprung, der nach au
erhalb des m
glichen Bereichs f
hren w
rde, umwandeln in den umgekehrten bedingten Sprung und einen FAR-Sprung an das urspr
ngliche Ziel.
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 mit "DB" eingegeben werden. Labels k
nnen (ohne Deklarierung) eingesetzt werden. Es gibt jedoch 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: V
FADD, FSUB, FMUL und FDIV arbeiten mit den beiden oberen Elementen des 8087-Stack. 0
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: B
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 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 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. Falls die Bedingung anfangs nicht erf
llt wird, wird die Schleife nicht ausgef
hrt. )
gesteuerte Wiederholanweisung:
REPEAT
(* mach was *)
UNTIL <NOT> bedingung;
Die Bedingung darf beim Einsprung erf
llt sein (mu
aber nicht). Dieser Schleifentyp wird grunds
tzlich mindestens einmal durchlaufen.
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. S
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: 4
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: R
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: /
FOREIGN [C|PASCAL] DEFINITION MODULE modName; 7
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. O
Bei einem FOREIGN-C-Modul ist vor jeden Bezeichner ein "_"-Zeichen gesetzt. X
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. 7
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 :
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
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 zusammengefasst. 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.
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.
ck zum Index
Compiler-Begrenzungen:
Der Compiler erlegt Code und Daten die folgenden Gr
enbegrenzungen auf:
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
rfen h
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: r
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.
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: 6
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. -
Files.SetFileTime
Directories.SetFileTime
ck zum Index oder zu Routinen
GetFileTime
Lesen von Erstellungsdatum und -uhrzeit einer Datei. -
Files.GetFileTime
Directories.GetFileTime
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
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. #
ck zum Index oder zu Routinen
Close
Die Prozedur schlie
t eine derzeit offene Datei.
Files.Close
FileSystem.Close
ck zum Index oder zu Routinen
Read
Liest ein Zeichen (CHAR).
Konstante:
Files.READ
Prozeduren:
Files.Read
InOut.Read
TermBase.Read
Terminal.Read
Siehe auch bei den verwandten Prozeduren: ReadString, ReadLine, ReadInt, ReadCard, ReadWrd, ReadLongCard, ReadLongInt, ReadWord, ReadChar %
und der Komplement
rprozedur: Write #
ck zum Index oder zu Routinen
Length
Die Prozedur gibt die L
nge einer Datei bzw. die L
nge einer Zeichenkette zur
ck. $
Strings.Length
FileSystem.Length
ck zum Index oder zu Routinen
WriteLn
Die Prozedur f
hrt einen Zeilenvorschub durch. "
Terminal.WriteLn
InOut.WriteLn
Siehe auch WriteLine Zur
ck zum Index oder zu Routinen
ReadLine
Terminal.ReadLine
InOut.ReadLine
Siehe auch: Read Zur
ck zum Index oder zu Routinen
Delete
Files.Delete
Strings.Delete
ck zum Index oder zu Routinen
MODULE SYSTEM (Laufzeitbibliothek)
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. 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 Sie diese importieren, k
nnen Sie in normaler Syntax auf den Segment- oder den Offset-Teil eines Zeigers zugreifen.
Beispiel: b
pointer.SEG: Segment-Teil des Zeigers "pointer". pointer.OFS: Offset-Teil des Zeigers "pointer".
ck zum Modul 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 Modul 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 Modul 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: ADDRESS + CARDINAL und ADDRESS - CARDINAL sind erlaubte Ausdr
cke. 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. Die Operation wird nur auf dem Offset-Teil der Adresse ausgef
hrt!
ck zum Modul SYSTEM
TYPE SYSTEM.BYTE
1 Byte Speicherbedarf. F
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 Typ sein.
ck zum Modul SYSTEM
TYPE SYSTEM.WORD
1 Wort (2 Bytes) Speicherbedarf. F
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 Typ sein. V
Vorsicht: Die Gr
e des
bergebenen Parameters wird auf gerade Bytezahl aufgerundet!
ck zum Modul SYSTEM
SYSTEM.NEW und SYSTEM.DISPOSE
NEW und DISPOSE sind in der Sprach-Definition der 3. Auflage von Wirths Buch nicht mehr enthalten. 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 zeigt.
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 zeigt.
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 Modul 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 Modul 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 Modul SYSTEM
SYSTEM.ADR
PROCEDURE ADR(VAR adr: ADDRESS);
ADR(Bezeichner) gibt die Adresse des Objekts "Bezeichner" aus (Typ ADDRESS).
ck zum Modul SYSTEM
SYSTEM.FLAT
PROCEDURE FLAT(VAR adr: LONGCARD);
FLAT(ADDRESS) gibt eine unsegmentierte Adresse aus (LONGCARD).
ck zum Modul SYSTEM
SYSTEM.PTR
PROCEDURE PTR(adr: LONGCARD);
PTR gibt die der unsegmentierten Adresse (LONGCARD) entsprechende Adresse in Segment-Offset-Darstellung (ADDRESS) aus.
ck zum Modul SYSTEM
SYSTEM.NEWPROCESS
PROCEDURE NEWPROCESS(p: PROC;
a: ADDRESS;
n: CARDINAL;
VAR p1: ADDRESS);
NEWPROCESS 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 Modul 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 Modul 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 Modul 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 Modul 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 Modul 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 Modul SYSTEM
SYSTEM.OFFSET
PROCEDURE OFFSET(adr: ADDRESS):
CARDINAL;
OFFSET(Bezeichner) gibt den Offsetteil der Adresse des Objekts "Bezeichner" aus.
ck zum Modul 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
zeroFlag
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-Vertion * 100 zur
ck: C
z.B.:
r DOS 3.30: 330
r DOS 5.00: 500
r DR-DOS : 331
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
(Noch kein Hilfetext implementiert!)
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. 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 "intono" aus. Bei der R
ckkehr vom Interrupt werden die Register in AX..DI und die Prozessorflags in FLAGS gesichert. *
siehe auch XTrap Zur
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 "intono" aus. i
Bei der R
ckkehr vom Interrupt werden die Register in AX..ES und die Prozessorflags in FLAGS gesichert. )
siehe auch Trap Zur
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".
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 mit abgeschalteter Stack
berpr
fung (*$S-*) compiliert werden, da der Compiler bei eingeschalteter Stack-
berpr
fung Assembleranweisungen erzeugt, die den Stackpointer manipulieren.
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 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;
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: m
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 Konstante:
EOL
definierte Variablen:
Done
termCH
definierte Prozeduren:
OpenInput
OpenOutPut
RedirectInput
RedirectOutput
CloseInput
CloseOutput
Read
ReadString
ReadLine
ReadInt
ReadCard
ReadWrd
Write
WriteLn
WriteLine
WriteString
WriteInt
WriteCard
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.
ck zum Modul InOut
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 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 ASCII.ESC l
scht die gesamte Eingabe und beendet die Funktion mit RETURN.
ck zum Modul InOut
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.
ck zum Modul InOut
InOut.WriteLn
PROCEDURE WriteLn;
Identisch zu Write(ASCII.EOL). Schreibt einen Zeilenumbruch.
ck zum Modul InOut
InOut.WriteString
PROCEDURE WriteString(s: ARRAY OF CHAR);
Schreibt die Zeichenkette "s" in die Standardausgabe.
ck zum Modul InOut
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. Wenn (n <
3) und (x < 100H) dann werden drei Zeichen , ansonsten 6 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. Wenn (n <
2) und (x < 100H) dann werden zwei, ansonsten 4 Zeichen geschrieben.
ck zum Modul InOut
InOut.WriteWrd
PROCEDURE WriteWrd(w: WORD);
Schreibt w in die Ausgabedatei. 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
ck. $
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 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 Prozessumgebung 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 auch "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 Typen:
FDPtr
Response
IOMode
File
deklarierte Prozeduren:
LookUp
Create
Close
Reset
Rewrite
Rename
ReadWord
WriteWord
ReadChar
WriteChar
GetPos
SetPos
GetLPos
SetLPos
Length
LLength
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 schief geht, 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.
ck zum Modul FileSystem
FileSystem.Close
PROCEDURE Close(VAR f: File);
Schlie
t die Datei "f".
Falls die Datei mit Rename) umbenannt wurde, wird der Verzeichniseintrag zu diesem Zeitpunkt aktualisiert. Falls notwendig (die Datei wurde zu einem anderen Laufwerk umbenannt), wird die Datei jetzt kopiert.
ck zum Modul FileSystem
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". Die Datei kann zu einem anderen Verzeichnis oder auf ein anderes Laufwerk umbenannt (bewegt) werden.
Hinweis: U
Der Verzeichniseintrag wird erst ge
ndert, wenn die Datei geschlossen (Close) wird.
ck zum Modul FileSystem
FileSystem.ReadWord
PROCEDURE ReadWord(VAR f: File;
VAR w: WORD);
Lese einen WORD-Wert aus einer Datei. 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
FileSystem.GetPos
PROCEDURE GetPos(VAR f: File;
VAR highpos,
lowpos : CARDINAL);
Liefert die aktuelle Position des Dateizeigers. E
Siehe auch SetPos, SetLPos und GetLPos. Zur
ck zum Modul FileSystem
FileSystem.SetPos
PROCEDURE SetPos(VAR f: File;
highpos,
lowpos: CARDINAL);
Bewegt den Dateizeiger zur Position highpos * 65536 + lowpos. D
Siehe auch SetLPos, GetPos und GetLPos Zur
ck zum Modul FileSystem
FileSystem.GetLPos
PROCEDURE GetLPos(VAR f : File;
VAR pos: LONGCARD);
Liefert die aktuelle Position des Dateizeigers. E
Siehe auch GetPos, GetLPos und SetLPos. Zur
ck zum Modul FileSystem
FileSystem.SetLPos
PROCEDURE SetLPos(VAR f: File;
pos: LONGCARD);
Bewegt den Dateizeiger zur Position highpos * 65536 + lowpos. D
Siehe auch SetPos, GetPos und GetLPos. Zur
ck zum Modul FileSystem
FileSystem.Length
PROCEDURE Length(VAR f: File;
VAR highlen,
lowlen : CARDINAL);
Gibt die L
nge der Datei zur
ck. 0
Siehe auch LLength Zur
ck zum Modul FileSystem
FileSystem.LLength
PROCEDURE LLength(VAR f: File;
VAR length: LONGCARD);
Gibt die L
nge der Datei zur
ck. 0
Siehe auch Length. Zur
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. 5
siehe auch WriteNBytes. Zur
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. Bei der R
ckkehr wird die aktuelle Zahl geschriebener Bytes in "nWritten" zur
ckgegeben. 4
siehe auch ReadNBytes. Zur
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/80287, falls vorhanden. 2
In MathLib0 und LMathLib0 definierte Prozeduren: 8
lt Prozeduren zur Umwandlung von Zahlen (INTEGER/CARDINAL/LONGINT/LONGCARD) in Strings und wieder zur
CONST
MaxBase
TYPE
BASE
[2..MaxBase];
definierte Konstante:
MaxBase
definierter Typ:
BASE
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
NumberConversion.MaxBase
TYPE
BASE
[2..MaxBase];
ck zum Modul NumberConversion
TYPE NumberConversion.BASE
CONST
MaxBase
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. 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 reachtsb
ndig in ein Feld von mindestens n Zeichen geschrieben.
ck zum Modul RealInOut.
RealInOut.ReadLongReal
PROCEDURE ReadLongReal(VAR x: LONGREAL);
Siehe auch ReadReal. Zur
ck zum Modul RealInOut.
RealInOut.ReadLongReal
PROCEDURE WriteLongReal(x: LONGREAL;
n: CARDINAL);
Siehe auch WriteReal Zur
ck zum Modul RealInOut.
MODULE Storage
Dieses Modul ist f
r die Bearbeitung des Modula-2-Heaps zwischen System.HeapTop und System.MemTop verantwortlich. 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: H
CompareStr
Assign
Length
Concat
Delete
Copy
Append
Insert
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
-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 zum Modul Strings.
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
ck. .
Siehe auch Append. Zur
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
ck. u
ckgabe: 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".
ck zum Modul Strings.
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. 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 s 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 Typen:
StatusProcedure
StatusProcedure
WriteProcedure
GotoProcedure
definierte Prozeduren:
AssignRead
AssignWrite
UnAssignRead
UnAssignWrite
KeyPressed
Read
Write
AssignGoto
UnAssignGoto
Goto
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 benutzenden neuen Prozeduren.
ck zum Modul TermBase.
TermBase.AssignWrite
PROCEDURE AssignWrite(wp: WriteProcedure;
VAR done: BOOLEAN);
Sichert die aktuelle Write-Prozedur in einem Prozedur-Stack und installiert die stattdessen zu benutzenden neuen 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. W
hrend der Initialisierung von TermBase ist TermIO.KeyPressed aktiv. >
Siehe auch: KeyPressed-
bersicht. Zur
ck zum Modul TermBase.
TermBase.Read
PROCEDURE Read(VAR ch: CHAR);
Fordert die derzeit installierte Read-Prozedur an. W
hrend der Initialisierung von TermBase ist TermIO.Read aktiv.
ck zum Modul TermBase.
TermBase.Write
PROCEDURE Write(ch: CHAR);
Fordert die derzeit installierte Write-Prozedur an. W
hrend der Initialisierung von TermBase ist TermIO.Write aktiv.
ck zum Modul TermBase.
TermBase.AssignGoto
PROCEDURE AssignGoto(gp: GotoProcedure;
VAR done: BOOLEAN);
Sichert die aktuelle Goto-Prozedur in einem Prozedur-Stack und installiert die stattdessen zu benutzenden neuen Prozedur.
ck zum Modul TermBase.
TermBase.UnAssignGoto
PROCEDURE UnAssignGoto(VAR done: BOOLEAN);
Poppt die von AssignGoto auf den Prozedur-Stack geschriebene Goto-Prozeduren zur
ck und aktiviert sie erneut.
ck zum Modul TermBase.
TermBase.Goto
PROCEDURE Goto(line, pos: CARDINAL);
Ruft die aktuell installierte Goto-Prozedur auf. W
hrend der Initialisierung von TermBase ist TermIO.Goto installiert.
ck zum Modul TermBase.
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: a
KeyPressed
Read
ReadLine
ReadAgain
Write
WriteString
WriteLn
WriteLine
ClrScreen
Goto
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.
Terminal.Read
PROCEDURE Read(VAR ch: CHAR);
Liefert das n
chste eingegebene Zeichen. Hierzu wird TermBase.Read verwendet.
ck zum Modul Terminal.
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. ReadAgain, gefolgt von Read kann benutzt werden, um das abschlie
ende Zeichen zu ermitteln (EOL oder ESC).
ck zum Modul Terminal.
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.
ck zum Modul Terminal.
Terminal.WriteString
PROCEDURE WriteString(string: ARRAY OF CHAR);
Schreibt unter Benutzung von Terminal.Write eine Zeichenkette "string" an die Standardausgabe.
ck zum Modul Terminal.
Terminal.WriteLn
PROCEDURE WriteLn;
Identisch mit: Write(ASCII.EOL).
ck zum Modul Terminal.
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.
ck zum Modul Terminal.
Terminal.WriteLine
PROCEDURE WriteLine(string: ARRAY OF CHAR);
Identisch mit: "
WriteString(string);
WriteLn;
ck zum Modul Terminal.
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. F
r die Bildschirm-L
schroutinen und Goto-Funktion mu
ANSI.SYS installiert sein. "
In TermIO definierte Prozeduren:
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.
ck zum Modul TermIO.
TermIO.Write
PROCEDURE Write(ch: CHAR);
Schreibt ch auf den Bildschirm.
ASCII.FF l
scht den Bildschirm (ANSI.SYS mu
installiert sein)
ASCII.EOL erzeugt auf dem Bildschirm die Ausgabe von CR LF.
ASCII.DEL erzeugt einen zerst
rerischen Backspace..
ck zum Modul TermIO.
TermIO.KeyPressed
PROCEDURE KeyPressed() :BOOLEAN;
Gibt TRUE zur
ck, wenn im Tastaturpuffer ein Zeichen anliegt.
ck zum Modul TermIO.
TermIO.Goto
PROCEDURE Goto(line, pos: CARDINAL);
Positioniert den Cursor an line/pos. Es wird ANSI.SYS ben
tigt!
ck zum Modul TermIO.
MODULE Display
VAR L
line0: CARDINAL;
col0: CARDINAL;
lineN: CARDINAL;
colN: CARDINAL;
TYPE M
DisplayBuffer
ARRAY [0..24]
OF ARRAY [0..79] OF CARDINAL;
VAR (
displayPtr: POINTER TO DisplayBuffer;
------------------------------------
definierter Typ:
Buffer
definierte Variablen:
displayMode
displayPage
displayAttr
displayLines
displayCols
snowy
line0
col0
lineN
colN
displayPtr
definierte Prozeduren:
GetDisplayMode
SetDisplayMode
SetCursorType
GetCursorPosition
SetCursorPosition
ScrollUp
ScrollDown
ReadCharAttr
WriteCharAttr
WriteChar
Goto
Write
ClrEOL
ClrEOS
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. 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
ck. BIOS Interface-Routine.
ck zum Modul Display
Display.SetDisplayMode
PROCEDURE SetDisplayMode(mode: CARDINAL); 5
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
ck. BIOS Interface-Routine.
ck zum Modul Display
Display.SetCursorPosition
PROCEDURE SetCursorPosition(line: CARDINAL;
pos: CARDINAL);
Bewegt den Cursor nach line/pos. BIOS Interface-Routine. 5
Siehe auch 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. line1, pos1
linke obere Ecke des Scrollfensters. line2, pos2
rechte untere Ecke des Scrollfensters. attr = Farbattribut f
r neue Leerzeilen. Falls n
0 ist, wird das Fenster gel
scht.
BIOS Interface-Routine. 0
Siehe auch ScrollDown Zur
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. 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);
Lies 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.
ck zum Modul Display
Display.Goto
PROCEDURE Goto(line, col: CARDINAL);
Bewegt den Cursor an line/pos innerhalb des aktuellen Fensters wie es von line0, col0 - lineN, colN definiert ist.
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 Window-Koordinaten. 0
Die folgenden Steuerzeichen werden ausgef
hrt: %
BEL, EOL, CR, LF, FF, DEL, BS, HT.
ck zum Modul Display
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. 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. 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 Windows 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. N
Benutzung: 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: H
DisableBreak
EnableBreak
InstallBreakHandler
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.
Installation eines eigenen Break-Handlers - die Break
berwachung mu
eingestellt sein.
ck zum Modul Break
Break.UninstallBreakHandler
PROCEDURE UninstallBreakHandler;
Deinstalliert die User-definierte Break-Handler-Prozedur.
ck zum Modul Break
MODULE Directories
In diesem Modul sind ein gro
er Teil der Verzeichnisoperationen definiert. .
definierte Typen:
DirEntry
QueryProc
definierte Variable:
DirStatus
definierte Konstanten:
NORMAL
READONLY
HIDDEN
SYSTEM
DIRECTORY
ARCHIVE
definierte Prozeduren:
GetFirstDir
GetNextDir
DirQuery
MkDir
RmDir
ChDir
GetFileAttr
SetFileAttr
GetCurDir
Delete
Rename
GetFileTime
SetFileTime
ASCIIZ
ck zum Index oder zu Routinen, Ende mit ESC
Directories.DirEntry
TYPE
DirEntry
RECORD
name :ARRAY [0..65] OF CHAR;
attribute :BITSET;
time :CARDINAL;
date :CARDINAL;
size :LONGCARD;
END;
ck zum Modul Directories
Directories.QueryProc
TYPE
QueryProc
PROCEDURE(DirEntry);
PROCEDURE DirQuery(path: ARRAY OF CHAR;
attributes: BITSET;
p: QueryProc );
ck zum Modul Directories
Dateiattribute
Attributbits:
NORMAL
(); READONLY
(0);
HIDDEN
(1); SYSTEM
(2);
DIRECTORY
(4); ARCHIVE
(5);
ck zum Modul Directories
Directories.GetFirstDir
PROCEDURE GetFirstDir(Path:ARRAY OF CHAR;
Attribute:BITSET;
VAR Dir:DirEntry;
VAR ok :BOOLEAN );
Bei der R
ckgabe:
IF ok THEN
...
END;
"Dir" ist der erste Verzeichniseintrag der "Path" und "Attribute" besitzt.
ck zum Modul Directories
Directories.GetNextDir
PROCEDURE GetNextDir(VAR Dir:DirEntry;
VAR ok :BOOLEAN);
Bei der R
ckgabe:
IF ok THEN
...
END;
"Dir" ist der n
chste Verzeichniseintrag bei dem "Path" und "Attribute" des letzten GetFirstDir oder GetNextDir
bereinstimmen.
ck zum Modul Directories
Directories.DirQuery
TYPE
QueryProc
PROCEDURE(DirEntry);
PROCEDURE DirQuery(path: ARRAY OF CHAR;
attributes: BITSET;
p: QueryProc);
hrt die Prozedur "p" f
r jeden Verzeichniseintrag aus, der mit der Suchmaske und dem angegebenen Attribut
bereinstimmt.
ck zum Modul Directories
Directories.MkDir
PROCEDURE MkDir(dirName: ARRAY OF CHAR);
Erstellt ein neues Verzeichnis. "dirName" kann jeder beliebige Pfadname inklusive einer optionalen Laufwerksbezeichnung sein.
ck zum Modul Directories
Directories.RmDir
PROCEDURE RmDir(dirName: ARRAY OF CHAR);
scht das Verzeichnis dirName "dirName" kann jeder beliebige Pfadname inklusive einer optionalen Laufwerksbezeichnungs sein.
ck zum Modul Directories
Directories.ChDir
PROCEDURE ChDir(dirName: ARRAY OF CHAR);
Wechselt das aktuelle Verzeichnis zu "dirName". "dirName" kann jeder beliebige Pfadname inklusive einer optionalen Laufwerksbezeichnung sein. Wird ein anderes als das aktuelle Laufwerk angegeben, wird nur auf dem anderen Laufwerk der Pfad gewechselt. Au
erdem wird zum anderen Laufwerk als aktuelles Laufwerk gewechselt
ck zum Modul Directories
Directories.GetFileAttr
PROCEDURE GetFileAttr(fileName: ARRAY OF CHAR;
VAR attr: BITSET);
Liest die Attribut-Bits der Datei "fileName". "fileName" und "dirName" sind jeder beliebige Pfadname inklusive einer optionalen Laufwerksbezeichnung.
ck zum Modul Directories
Directories.SetFileAttr
PROCEDURE SetFileAttr(fileName: ARRAY OF CHAR;
attr: BITSET);
Setzt die Dateiattribut-Bits der Datei "fileName". "fileName" und "dirName" sind jeder beliebige Pfadname inklusive einer optionalen Laufwerksbezeichnung.
ck zum Modul Directories
Directories.GetCurDir
PROCEDURE GetCurDir(drive: CARDINAL;
VAR curDir: ARRAY OF CHAR);
Liefert das aktuelle Verzeichnis des angegebenen Laufwerks wobei gilt: g
drive
0 - aktuelles Laufwerk
1 - Laufwerk A
2 - Laufwerk B
...
ck zum Modul Directories
Directories.Delete
PROCEDURE Delete(fileName: ARRAY OF CHAR);
scht die Datei "fileName" vom Datentr
"fileName" kann jeder beliebige Pfad- und Dateiname inklusive einer optionalen Laufwerksbezeichnung sein.
ck zum Modul Directories
Directories.Rename
PROCEDURE Rename(oldName,
newName: ARRAY OF CHAR);
Benennt die Datei "oldName" in "newName" um. Rename kann benutzt werden, um eine Datei vom einen in anderes Verzeichnis auf dem selben Laufwerk zu verschieben. "oldName" und "newName" sind jeder beliebige Pfadname inklusive einer optionalen Laufwerksbezeichnung.
ck zum Modul Directories
Directories.GetFileTime
PROCEDURE GetFileTime(fileName: ARRAY OF CHAR;
VAR time: LONGCARD);
Liefert das Datum die Uhrzeit der letzten
nderung der Datei "fileName". ]
time DIV 65536L
Datum der letzten
nderung time MOD 65536L
Uhrzeit der letzten
nderung `
"fileName" kann jeder beliebige Pfadname inklusive einer optionalen Laufwerksbezeichnung sein.
ck zum Modul Directories
Directories.SetFileTime
PROCEDURE SetFileTime(fileName: ARRAY OF CHAR;
time: LONGCARD);
Setzt Datum und Uhrzeit einer Datei. "fileName" kann jeder beliebige Pfadname inklusive einer optionalen Laufwerksbezeichnung sein.
ck zum Modul Directories
Directories.ASCIIZ
PROCEDURE ASCIIZ(VAR src,
dest: ARRAY OF CHAR);
Konvertiert die Zeichenkette "src" in einen Null-terminierten String in "dest" wie er von Dateiprozeduren verlangt wird.
ck zum Modul Directories
Directories.DirStatus
DirStatus: CARDINAL;
DOS-Status nach dem letzten Aufruf eines Datei-Prozeduraufrufs.
ck zum Modul Directories
MODULE DTA
Lesen und Setzen der DOS-Disk-Transfer-Adress (DTA). !
In "DTA" definierte Prozeduren:
SetDTA
GetDTA
ck zum Index oder zu Routinen, Ende mit ESC
DTA.SetDTA
PROCEDURE SetDTA(adrs: ADDRESS);
setzt die DTA nach "adrs".
ck zum Modul DTA.
DTA.GetDTA
PROCEDURE GetDTA(VAR adrs :ADDRESS);
Liest die aktuelle DAT und setzt den Zeiger nach "adrs".
ck zum Modul DTA.
MODULE Files
Modul f
r das DOS-Dateiverwaltungs-Interface. Weitere Informationen
ber diese Routinen sollten dem technischen Handbuch f
r DOS entnommen werden.
definierte Konstanten:
StdIn
StdOut
StdErr
StdCom
StdPrn
NORMAL
READONLY
HIDDEN
SYSTEM
READ
WRITE
IO
NOINHERIT
DENYWRITE
DENYREAD
DENYNONE
definierter Typ:
SeekMode
definierte Variable:
FileStatus
definierte Prozeduren:
Open
Create
CreateTemp
CreateNew
Close
Read
Write
Seek
Lock
Unlock
Dup
Dup2
GetFileTime
SetFileTime
Rename
Delete
ck zum Index oder zu Routinen, Ende mit ESC. $
DOS-Standard-Handles
CONST
StdIn
0; StdOut
StdErr
2 StdCom
StdPrn
ck zum Modul Files
Dateiattribut-Bits
Diese Bits werden ben
tigt, um Dateien zu erzeugen. Es d
rfen mehrere der Bits gleichzeitig verwendet werden. J
CONST
NORMAL
(); READONLY
(0);
HIDDEN
(1); SYSTEM
(2);
ck zum Modul Files
Flags f
r die Datei-Zugriffsrechte
Flags f
r die Zugriffsrechte beim
ffnen von Dateien. Es mu
eines aus der ersten Gruppe ausgew
hlt werden oder ein es oder mehrere aus der zweiten Gruppe gew
hlt und diese dann zusammenaddiert werden.
READ
();
ffnet die Datei zum Lesen.
WRITEc
(0);
ffnet die Datei zum Schreiben.
IO
(1);
ffnet die Datei zum Lesen und Schreiben. "
Datei-Zugriffsrechte ab DOS 3.1: >
DENYALL
(4); Zur
ckweisung aller anderen Prozesse.
DENYWRITE
(5); Zur
ckweisen der Schreibfunktion f
r alle anderen Prozesse.
DENYREAD
(4,5); Zur
ckweisern des Lesens f
r alle anderen Prozesse.
DENYNONE
(6); Freier Zugriff f
r andere Prozesse.
NOINHERIT
(7); Kein Zugriff f
r Tochterprozesse.
ck zum Modul Files
Files.SeekMode
Suchmodus - f
r die Benutzung mit "Seek". 2
TYPE
SeekMode
(SEEKABS, SEEKCUR, SEEKEND);
SEEKABS: Angabe der absoluten Suchposition.
SEEKCUR: Relative Angabe der Suchposition zum aktuellen Dateizeiger.
SEEKEND: Angabe der absoluten Suchposition vom Dateiende aus.
ck zum Modul Files
Files.FileStatus
FileStatus: CARDINAL;
DOS-Fehlercode f
r die letzten Dateifunktionen. Liefert 0 zur
ck, wenn der letzte Dateiaufruf erfolgreich war.
ck zum Modul Files
Files.Open
PROCEDURE Open(VAR fd: INTEGER;
name: ARRAY OF CHAR;
mode: BITSET);
ffnet eine Datei abh
ngig vom angegebenen Dateimodus. Bei der R
ckkehr enth
t der Datei-Deskriptor den von DOS zur
ckgegebenen Wert oder -1 wenn ein Fehler aufgetreten ist.
ck zum Modul Files
Files.Create
PROCEDURE Create(VAR fd: INTEGER;
name: ARRAY OF CHAR;
attr: BITSET);
Erstellt eine neue Datei oder schneidet eine bestehende Datei ab. Falls Create erfolgreich war, wird die Datei f
r Lesen und Schreiben ge
ffnet. "fd" erh
lt den Datei-Deskriptorwert, der von DOS zur
ckgeliefert wurde. Falls Create fehlgeschlagen ist, enth
lt "fd" den Wert -1.
ck zum Modul Files
Files.CreateTemp
PROCEDURE CreateTemp(VAR fd: INTEGER;
VAR path: ARRAY OF CHAR;
attr: BITSET);
Erstellt ab DOS 3.x eine neue Datei mit einmalig vergebenem Namen. Beim Eintritt in die Prozedur sollte die Varable "path" den Namen des Verzeichnisses enthalten, in dem die Tempor
rdatei angelegt wird und gen
gend Platz (14 Bytes), damit DOS den Namen anh
ngen kann. Bei der R
ckkehr aus der Prozedur enth
lt die Variable "path" den kompletten Namen der Tempor
rdatei.
Hinweis: DOS l
scht die Tempor
rdatei nicht automatisch. Falls die Datei nicht mehr ben
tigt wird, mu
sie vom Benutzer gel
scht werden.
ck zum Modul Files
Files.CreateNew
PROCEDURE CreateNew( VAR fd :INTEGER; name :ARRAY OF CHAR; attr :BITSET );
Entspricht Create. CreateNew schl
gt jedoch fehl, wenn die Datei bereits existiert (DOS 3.x).
ck zum Modul Files
Files.Close
PROCEDURE Close(fd: INTEGER);
Schlie
t die Datei. Jede weitere Ein- oder Ausgabe auf diesen Datei-Deskriptor schl
gt fehl.
ck zum Modul Files
Files.Read
PROCEDURE Read(fd: INTEGER; W
buffer: ADDRESS;
bytes: CARDINAL;
VAR nread: CARDINAL);
Lese die angegebene Anzahl von Bytes aus der Datei. Bei der R
ckkehr enth
lt "nwritten" die aktuelle Anzahl gelesener Bytes.
ck zum Modul Files
Files.Write
PROCEDURE Write(fd: INTEGER;
buffer: ADDRESS;
bytes: CARDINAL;
VAR nwritten: CARDINAL);
Schreibe die angegebene Anzahl von Bytes in die Datei. Bei der R
ckkehr enth
lt "nwritten" die aktuelle Anzahl geschriebener Bytes.
ck zum Modul Files
Files.Seek
PROCEDURE Seek(fd: INTEGER;
mode: SeekMode;
VAR offset: LONGCARD);
Die Prozedur bewegt den Dateizeiger zu der mit "offset" angegebenen Adresse in der Datei, je nach der in Mode angegebenen Startegie Bei der R
ckkehr enth
lt "offset" die neue Dateizeigerposition.
ck zum Modul Files
Files.Lock
PROCEDURE Lock(fd: INTEGER;
offset: LONGCARD;
length: LONGCARD);
Sperrt den Dateibereich ab dem Offset "offset" f
r "length" Bytes. Erst ab DOS 3.1!
ck zum Modul Files
Files.Unlock
PROCEDURE Unlock(fd: INTEGER;
offset: LONGCARD;
length: LONGCARD);
Hebt die Sperrung des Dateibereichs ab "offset" f
r "length" Bytes wieder auf. Die Prozedur ben
tigt DOS ab 3.1
ck zum Modul Files
Files.Dup
PROCEDURE Dup(fd: INTEGER;
VAR newfd: INTEGER);
Erzeugt einen neuen Datei-Handle f
r "fd" in "newfd".
ck zum Modul Files
Files.Dup2
PROCEDURE Dup2(fd, fd2 :INTEGER);
Dupliziert den Dateihandle fd auf fd2.
ck zum Modul Files
Files.GetFileTime
PROCEDURE GetFileTime(fd: INTEGER;
VAR time: LONGCARD);
Liefert die Zeit und das Datum der letzten
nderung der Datei. Z
time DIV 65536L
Datum der letzten
nderung time MOD 65536L
Zeit der letzten
nderung
ck zum Modul Files
Files.SetFileTime
PROCEDURE SetFileTime(fd: INTEGER;
time: LONGCARD);
Setzt das Datum und die Uhrzeit der Datei.
ck zum Modul Files
Files.Rename
PROCEDURE Rename(oldname, *
newname: ARRAY OF CHAR);
ndert den Dateinamen von "oldname" in "newname". Files.Rename kann dazu verwendet werden, eine Datei vom einen in anderes Verzeichnis zu verschieben, allerdings nur auf dem selben Laufwerk.
ck zum Modul Files
Files.Delete
PROCEDURE Delete(name: ARRAY OF CHAR);
scht die in "name" angegebene Datei.
ck zum Modul Files
MODULE FileSpec
Die Prozeduren dieses Moduls erlauben dem Benutzer, komplette Dateinamen zu manipulieren. Keine der Prozeduren f
r eine
berpr
fung auf die Richtigkeit der Pfadnamen durch. Sie trennen nur die einzelnen Komponenten auf der Grundlage der DOS-Sytax f
r Pfadnamen.
Beispiel: ParseFileSpec gibt f
r "\m2\comp" ein Verzeichnis "m2" und einen Dateinamen "comp" zur
ck - auch dann, wenn "\m2\comp" der Name eines vorhandenen Unterverzeichnisses ist.
Definierte Prozeduren: B
ParseFileSpec
ExtractDirPath
ExtractFileName
DropExt
HasExt
ck zum Index oder zu Routinen, Ende mit ESC
FileSpec.ParseFileSpec
PROCEDURE ParseFileSpec(
filespec: ARRAY OF CHAR;
VAR drive: CHAR;
VAR dir: ARRAY OF CHAR;
VAR name: ARRAY OF CHAR;
VAR ext: ARRAY OF CHAR);
Beschreibung der Ausgaben: Nur diese Teile in "filespec" werden wieder zur
ckgeliefert. Die anderen Felder werden mit einer Null in ersten Feld geladen.
drive: das angegebene Laufwerk dir: der anagebene Verzeichnispfad name: der Dateiname ohne die Extension ext: die Dateiendung
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
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
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. 0
definierte Typen:
ShiftKeys
ShiftStatus
definierte Prozeduren:
KeyPressed
GetKey
GetKeyCh
GetFunKey
GetShiftStatus
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
KeyBoard.GetKey
PROCEDURE GetKey(VAR k: CHAR);
Entspricht der "INKEY"-Funktion in BASIC. 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 Scancode-Tabelle 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. 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. J
"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.
Beispiel: ;
PopMenu(5, 10, "Hauptmen
|Hallo|Bye|Ende", 0, TRUE, cmd);
Siehe auch PullDownMenu Zur
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. Alle Men
fenster werden vor der R
ckkehr geschlossen. *
siehe auch PopMenu Zur
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". 1
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:
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 Grun f
r die Beendigung des Programms: [
normal
durch Ctrl-C
Kritischer Ger
tefehler
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.
Beispiel:
Locate("M2IDE.CFG", "PATH", pathName, found);
IF found THEN
Lookup(f, pathName);
...
ck zum Modul Paths
MODULE RealConversion
definierte Prozeduren: A
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. Falls decDigits > 0 ist, mu
"n" >
decDigits + 2 sein, sonst mu
n >
ABS(decDigits)+7 sein.
Beispiele:
RealToString(1.148, 2, 6, s, ok) w
rde " 1.15" in s zur
ckgeben. 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 (wahr, ja), ein "-" setzt ihn auf FALSE (falsch, nein) 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, sowie beim Kopieren von offenen Arrays in den lokalen Stack-Rahmen eines Unterprogramms. )
ck zur
bersicht: Compilerschalter.
Befehl: $R, Vorbelegung: +
Bereichs-Pr
fung ---------------- 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 zur
bersicht: Compilerschalter.
Befehl $T, Vorbelegung: +
Feld-Index-Pr
fung ------------------ Bei "+" wird bei jedem Zugriff auf ein Feld (Array)
ber Index zuvor gepr
ft, ob der Index nicht au
erhalb der definierten Feldgrenzen liegt. Au
erdem wird vor jedem Zugriff
ber einen Zeiger dieser auf NIL gepr
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 zur
bersicht: 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. )
ck zur
bersicht: 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 wird 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)
Runtime-Error 1
Bereichs-Fehler ($R oder $T Option)
Runtime-Error 2
Integer/Cardinal-
berlauf (Division durch Null)
Runtime-Error 3
Fehler bei einer Flie
komma-Operation
Runtime-Error 4
Funktion hat kein RETURN ausgef
Runtime-Error 5
HALT wurde aufgerufen.
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. CHAR implementiert den ASCII-Zeichensatz, kann aber auch als normaler Datentype verwendet werden. 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 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. k
Der Typ String ist in Modula-2 nicht vordefiniert. 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. 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,
-1L und -348762 sind korrekte LONGINT-Konstanten e
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..3.4E38.
ck zum Typen-Men
LONGREAL
Sie haben ab der Version 2.0 von Fitted Modula-2 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. Ein Bitset sind beispielsweise die FLAGS oder die Dateiattribute.
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
Diese Liste ist in dieser Version der FST-IDE-Hilfestellung noch nicht implementiert. Bitte lesen Sie zur Syntax und den reservierten Worten bzw. Standardprozeduren der Sprache Modula das Buch von N. Wirth: Programming in Modula-2.
(.txt)