Best of German Only 2/romside_best_of_german_only_2.iso/dos/lernbild/itg/entpack.exe/ITG.HLP

Text File | 1993-09-18 | 198KB | 7,540 lines

≡≡ITG-PASCAL

Igel-GrafikStandard-GrafikITG-Pascal-Grafik
Operatorenmathematische·FunktionenStandard-Bezeichner
Standard-ProzedurenITG-Pascal-ProzedurenStandard-Funktionen
ITG-Pascal-Funktionenparallele·Prozesse    Konstante
TypenFehler-HilfeDebugger
EditorSynonymeFischertechnik·LEGO
Allgemeines

≡≡ALLGEMEINES

ITG-Pascal
ist
zum
größten
Teil
Turbo-Pascal-kompatibel
(Version
4.0
-
6.0),
enthält
aber
Einschränkungen
und
viele
Erweiterungen,
die
Schülern
das
Programmieren
und
Fehlersuchen
erleichtern.

Bezeichner
aus
Standard-Pascal
oder
aus
Turbo-Pascal
tragen
die
üblichen
Namen,
Erweiterungen
sind
mit
deutschen
Namen
versehen.
Dabei
sind
auch
die
deutschen
Sonderzeichen
(ä,ö,ü,Ä,Ö,Ü,ß)
zugelassen.

≡

ITG-Pascal
besteht
aus
einem
Interpreter,
mit
dem
ein
Teil
der
Pascal-Anweisungen
im
Grafik-
und
im
Textmodus
direkt
ausgeführt
werden
kann
und
einem
Compiler
/
Interpreter,
der
Pascal-Programme
übersetzt
und
ausführt.

Alle
Anweisungen,
die
im
Direktmodus
ausgeführt
werden,
können
auf
Wunsch
im
Editor
mitprotokolliert
werden.
Dabei
werden
sie
automatisch
zu
einem
lauffähigen
Programm
ergänzt,
das
verändert
oder
ergänzt,
gestartet
und
abgespeichert
werden
kann.

≡

ITG-Pascal
enthält
in
der
vorliegenden
Version
drei
verschiedene
Koordinaten-Systeme:

1)
den
Textschirm
mit
1
≤
x
≤
80
und
1
≤
y
≤
25,
wobei
der
linke
obere
Eckpunkt
die
Koordinaten
x
=
1
und
y
=
1
hat.

2)
die
Standardgrafik
mit
-320
≤
x
≤
320
und
yMin
≤
y
≤
yMax,
wobei
yMin
und
yMax
von
der
Grafikkarte
abhängen,
wie
unter
GetMaxY
beschrieben.
Dabei
gilt
:
yMin
=
-
GetMaxY
/
2
yMax
=GetMaxY
/
2.
Der
Ursprung
des
Koordinatensystems
liegt
in
der
Mitte
des
Bildschirms.
Die
positive
y-Achse
zeigt
nach
oben!

≡

3)
die
Igelgrafik
mit
-320
≤
x
≤
320
und
-240
≤
y
≤
240
für
alle
Grafikkarten.
Gegebenenfalls
erfolgt
eine
Korrektur
in
y-Richtung.
Auch
hier
liegt
der
Ursprung
des
Koordinatensystems
in
der
Mitte
des
Bildschirms.
Die
positive
y-Achse
zeigt
nach
oben!
Winkel
werden
zur
positiven
x-Achse
im
mathematisch
positiven
Umlaufsinn
(entgegen
dem
Urzeigersinn)
gemessen.

≡

Debug-Anweisungen
werden
im
Quelltext
eingefügt
(s.
auch
Debugger),
wobei
die
Informationen
nach
jeder
Quelltextzeile
auf
dem
Bildschirm
ausgegeben
werden
und
zusätzlich
in
einem
zweiten
Editor-Fenster
mitprotokolliert
werden,
damit
sie
später
in
Ruhe
angesehen
werden
können.

≡≡Synonyme

Aufbau
der
Synonym-Datei
'ITG.SYN':
Kommentare
werden
wie
in
Pascal
eingefügt.
Das
erste
Wort
gibt
den
alten
Bezeichner,
das
zweite
den
neuen
zusätzlichen
an.
Pro
Zeile
ist
nur
ein
Wortpaar
zugelassen.
Kommentare
dürfen
nie
in
einer
Zeile
VOR
Bezeichnern
stehen.
Kommentar-Klammern
dürfen
NICHT
in
Kommentaren
stehen.

Beispiele
:

≡

A
C
H
T
U
N
G
:Es
handelt
sich
hier
nur
um
Beispiele!
===============Die
gültigen
Synonyme
entnehmen
Sie
bitte
Ihrer
Datei
'ITG.SYN'!

INTEGER
GANZZAHL(*
Hier
ist
ein
Kommentar
zulässig
*)
REAL
KOMMAZAHL
INC
ERHÖHE
REPEAT
WIEDERHOLE
UNTIL
BIS

≡≡Operatoren

+Addition2
+
5=
7
-Subtraktion    5
-
2=
3
*Multiplikation2
*
5=
10
/Division2
/
5=
0.4
DIVGanzzahl-Division7
DIV
5
=
1(=
1
Rest
2)
MODDivisionsrest7
MOD
5
=
2(=
1
Rest
2)
^Potenz2
^
3=
8(=
2
*
2
*
2)

≡≡Standard-Bezeichner

ANDARRAYBEGINCASECONSTDISPOSE
DIVDODOWNTOELSEENDEXIT
FORWARDFILEFORFUNCTIONGOTOHALT
IF ININCLUDELABELMODNEW
NILNOTOFORPACKEDPROCEDURE
PROGRAMRECORDREPEATSETTHENTO
TYPEUNTILUSESVARWHILEWITH
XOR

≡≡AND

Mit
AND
kann
einerseits
geprüft
werden,
ob
zwei
oder
mehr
Wahrheitswerte
gleichzeitig
erfüllt
sind,
andererseits
kann
eine
bitweise
Verknüpfung
zweier
oder
mehrerer
INTEGER
-
Werte
erfolgen.

Verknüpfung
von
Wahrheitswerten
(
BOOLEAN
):

a│b│a
AND
b
───────┼───────────┼───────────
FALSE│FALSE│FALSE
FALSE│TRUE│FALSE
TRUE│FALSE│FALSE
TRUE│TRUE│TRUE

≡

Verknüpfung
von
INTEGER
-
Werten

│dezimal│binärFür
je
zwei
untereinanderstehende
─────────┼───────────┼────────Ziffern
im
Binärsystem
wird
eine
a│13│1101Verknüpfung
nach
der
obigen
Tabelle
b│11│1011für
Wahrheitswerte
durchgeführt,
wobei
─────────┼───────────┼────────0
durch
FALSE
und
1
durch
TRUE
zu
a
AND
b│9│1001ersetzen
sind.

≡≡ARRAY

Durch
ARRAY
wird
ein
Feld
mit
einer
bestimmten
Anzahl
gleichartiger
Elemente
deklariert.

Primzahl
:
ARRAY[1..50]
OF
INTEGER;

stellt
50
Speicherplätze
für
INTEGER
-
Variablen
zu
Verfügung,
die
über
den
Bezeichner
Primzahl
und
ihren
Index
angesprochen
werden
können.

Primzahl[1]
:=
2;
Primzahl[2]
:=
3;

stellen
gültige
Anweisungen
dar,

≡

Primzahl
:=
2;

ist
nicht
möglich,
weil
nicht
ersichtlich
ist,
welchem
Feldelement
die
2
zugewiesen
werden
soll.

Primzahl[51]
:=
101;

ist
ebenfalls
nicht
möglich,
da
laut
Deklaration
kein
Feldelement
mit
dem
Index
51
einzurichten
war.

≡≡BEGIN

BEGIN
und
END
klammern
immer
Folgen
von
Anweisungen
ein,
die
unter
den
jeweiligen
Voraussetzungen
nacheinander
abzuarbeiten
sind.
BEGIN
und
END
treten
jeweils
PAARWEISE
auf.

Durch
BEGIN
werden
folgende
Programmabschnitte
eingeleitet
:
1)
das
Hauptprogramm
2)
jede
Programmrumpf
einer
Prozedur
(
PROCEDURE
)
/
Funktion
(
FUNCTION
)
3)
die
Anweisungsfolge,
die
nach
einer
IF
-
Abfrage
abzuarbeiten
ist
4)
die
Anweisungsfolge,
die
nach
einer
ELSE
-
Anweisung
abzuarbeiten
ist

≡

5)
die
Anweisungsfolge,
die
nach
einer
WHILE
-
Abfrage
abzuarbeiten
ist
6)
die
Anweisungsfolge,
die
nach
einer
Fallunterscheidung
in
einer
CASE
-
Anweisung
abzuarbeiten
ist

In
den
Fällen
3-6
kann
das
BEGIN
entfallen,
wenn
jeweils
nur
EINE
Anweisung
ausgeführt
werden
soll.

≡≡CASE

Die
CASE
-
Struktur
dient
zum
bedingten
Abarbeiten
einzelner
Programm-
abschnitte
nach
bestimmten
Fallunterscheidungen
und
ersetzt
unübersicht-
lichere
verschachtelte
IF
-
Anweisungen.

Sei
c
eine
CHAR
-
Variable,
die
vor
der
CASE
-
Struktur
mit
mehreren
verschiedenen
Werten
belegt
werden
kann.

CASE
c
OF
"A"
:
BEGIN
...
END;
"B"
:
BEGIN
...
END;
.
.
ELSEBEGIN
...
END;
END;

≡

Die
einzelnen
Fälle
werden
nach
KONSTANTEN
vorher
bekannten
Werten
unter-
schieden.
Der
Inhalt
der
Variablen
cdarf
für
die
Fallunterscheidung
nicht
mit
dem
Inhalt
einer
anderen
CHAR
-
Variablen
verglichen
werden.

In
der
vorliegenden
Version
von
ITG-PASCAL
MUß
die
ELSE
-
Anweisung
mit
aufgeführt
werden.

≡≡CONST

Mit
CONST
werden
Konstante
deklariert,
die
für
die
gesamte
Laufzeit
des
Programms
den
selben
Wert
behalten
und
nicht
durch
eine
Wertzuweisung
verändert
werden
können.

CONST
AnzahlDerWochentage
=
7;

Anweisungen
der
Form

FOR
n
:=
1
TO
AnzahlDerWochentage
DO
...
oder
n
:=
AnzahlDerWochentage;

sind
möglich,
Wertzuweisungen
wie

AnzahlDerWochentage
:=
5;

sind
nicht
möglich.

≡≡DISPOSE

DISPOSE
gibt
den
Speicherplatz,
den
eine
Zeigervariable
(dynamische
Variable)
belegte,
wieder
frei.
Der
Wert
des
Zeigers
ist
anschließend
NIL.

Beispiel
:

NEW(Zeigertyp);Platz
für
eine
Zeigervariable
auf
dem
Heap
.anfordern.
Erst
dann
dürfen
Zuweisungen
.vorgenommen
werden.
DISPOSE(Zeigertyp);Wenn
der
Inhalt
der
Zeigervariablen
nicht
mehr
benötigt
wird,
wird
der
Platz
auf
dem
Heap
wieder
freigegeben.

≡≡DIV

DIVGanzzahl-Division7
DIV
5
=
1(=
1
Rest
2)

≡≡DO

DO
ist
ein
Teil
des
Schleifenkopfes
der
WHILE
-
DO
-
Schleife
und
ein
Teil
der
WITH
-
DO
-
Anweisung.

≡≡DOWNTO

DOWNTO
ist
ein
Teil
des
Schleifenkopfes
der
abwärts
zählenden
FOR
-
TO
-
Schleife.

≡≡ELSE

ELSE
ist
ein
Teile
der
IF
-
THEN
-
ELSE
-
und
der
CASE
-
OF
-
Anweisungen.

≡≡END

siehe
BEGIN

≡≡EXIT

Mit
der
Anweisung
EXIT
wird
erreicht,
daß
die
Anweisungen
zwischen
EXIT
und
dem
Ende
der
Prozedur,
der
Funktion
oder
dem
Programm,
wenn
EXIT
im
Hauptprogramm
ausgeführt
wird,
übersprungen
werden.

PROCEDURE
Suche(Text
:
STRING);
VAR
n
:
INTEGER;
BEGIN
FOR
n
:=
1
TO
AnzahlDerStrings
DO
BEGIN
IF
Eintrag[n]
=
Text
THEN
BEGIN
Write(Text,
"
ist
das
",
n,
".te
Element
im
Array
Eintrag.");
EXIT;
END;
END;
Write(Text,
"
im
Array
Eintrag
nicht
gefunden.");
END;

≡

Die
vorletzte
Zeile
wird
nur
ausgeführt,
wenn
die
Suche
erfolglos
war,
sonst
wird
der
Erfolg
gemeldet
und
die
Ausführung
der
FOR
-
TO
-
Schleife
und
der
Prozedur
Suche
wird
sofort
beendet.

≡≡FORWARD

Wenn
sich
mehrere
Prozeduren
(
PROCEDURE
)
oder
Funktionen
(
FUNCTION
)
gegenseitig
aufrufen,
führt
es
zu
Problemen,
weil
eine
Prozedur,
die
von
einer
anderen
aufgerufen
wird,
vorher
deklariert
sein
muß.
Der
Compiler
meldet
in
diesem
Fall
einen
Fehler,
weil
er
nicht
weiß,
ob
es
sich
um
eine
Prozedur
oder
eine
Funktion
handelt
und
welche
Parameter
ihr
übergeben
werden
müssen.

Beispiel
:

≡

FUNCTION
f1(x
:
INTEGER)
:
INTEGER;
BEGIN
IF
n
>
1
THEN
f1
:=
n
*
f2(n-2)Aufruf
von
f2
!!!
ELSE
f1
:=
1;
END;

FUNCTION
f2(x
:
INTEGER)
:
INTEGER;
BEGIN
IF
n
>
1
THEN
f2
:=
SQR(n)
*
f1(n-1)Aufruf
von
f1
!!!
ELSE
f2
:=
1;
END;

≡

Da
der
Compiler
zuerst
nur
den
Prozedur-/Funktionskopf
benötigt,
um
die
Parameterübergabe
prüfen
zu
können,
reicht
es
nur
den
Kopf
hinzu-
schreiben.
Damit
anschließend
nicht
die
Deklaration
der
Prozedur/
Funktion
erwartet
wird,
wird
dem
Compiler
durch
FORWARD
mitgeteilt,
daß
es
sich
nur
um
den
Kopf
handelt
und
der
Rest
später
folgt.
Dazu
ist
der
Prozedur-/Funktionskopf
GENAUSO
hinzuschreiben
wie
bei
der
endgültigen
Deklaration,
es
ist
nur
"FORWARD;"
anzufügen.
Ansonsten
müssen
beide
Köpfe
ZEICHEN
FÜR
ZEICHEN
übereinstimmen.

≡

FUNCTION
f2(x
:
INTEGER)
:
INTEGER;
FORWARD;jetzt
ist
alles
Nötige
bekannt
FUNCTION
f1(x
:
INTEGER)
:
INTEGER;
BEGIN
IF
n
>
1
THEN
f1
:=
n
*
f2(n-2)Aufruf
von
f2
!!!
ELSE
f1
:=
1;
END;

FUNCTION
f2(x
:
INTEGER)
:
INTEGER;
BEGIN
IF
n
>
1
THEN
f2
:=
SQR(n)
*
f1(n-1)Aufruf
von
f1
!!!
ELSE
f2
:=
1;
END;

≡≡FILE

Durch
FILE
-
OF
wird
die
Struktur
einer
Datei
vereinbart.

Beispiel
:

TYPE
DatenEinerPerson
=
RECORD
Vorname,
Nachname,
Wohnort,
Straße
:
STRING[20];
PLZ,
HausNr,
Tel
:
INTEGER;
END;
VAR
Person
:
DatenEinerPerson;
PersonenDatei
:
FILE
OF
DatenEinerPerson;

≡

Die
Struktur
und
die
Größe
der
Datei
"PersonenDatei"
werden
beim
Schreiben
von
Daten
in
eine
Datei
so
gewählt,
daß
die
Datei
ein
direktes
Abbild
der
Variablen
"Person"
auf
der
Diskette/Festplatte
zu
finden
ist.
Auf
diese
Weise
lassen
sich
die
Daten
leicht
wieder
in
eine
Variable
vom
Typ
"DatenEinerPerson"
einlesen.

Schreiben
in
eine
Datei
:

Write(PersonenDatei,
Person);vorher
öffnen,
dann
schließen

Lesen
aus
einer
Datei
:

Read(PersonenDatei,
Person);

≡≡FOR

Durch
FOR
wird
der
Kopf
einer
Wiederholschleife
eingeleitet,
bei
der
ein
Zähler
bei
jedem
Durchgang
automatisch
im
Gegensatz
zur
WHILE
-
DO
-
und
REPEAT
-
UNTIL
-
Schleife
um
Eins
herauf
oder
herabgesetzt
wird.
Der
Zähler
muß
vom
Typ
INTEGER
sein.

Beispiele
:

aufwärts
zählende
Schleife
:

FOR
n
:=
1
TO
5
DO
...nur
eine
Anweisung
in
der
Schleife

FOR
n
:=
1
TO
5
DO
BEGIN
...mehrere
Anweisungen
in
der
Schleife
END;

≡

Beim
Start
der
FOR
-
TO
-
Schleife
wird
der
Inhalt
des
Schleifenzählers
n
auf
1
gesetzt
und
es
wird
geprüft,
ob
der
Inhalt
des
Schleifenzähler
kleiner
oder
gleich
der
oberen
Grenze
(
zwischen
TO
und
DO
)
ist.
Wenn
das
der
Fall
ist,
dann
werden
alle
Anweisungen
innerhalb
der
Schleife
mit
dem
Wert
n
=
1
durchlaufen.
Am
Ende
der
Schleife
wird
der
Schleifenzähler
um
1
erhöht
und
die
vorherigen
Schritte
werden
solange
wiederholt,
bis
der
Schleifenzähler
größer
als
die
obere
Grenze
ist
(n
>
5).
Danach
wird
das
Programm
mit
der
Anweisung
fortgesetzt,
die
direkt
nach
der
Schleife
steht.
n
nimmt
also
nacheinander
die
Werte
1,
2,
3,
4
und
5
an.

≡

abwärts
zählende
Schleife
:

FOR
n
:=
5
DOWNTO
1
DO
...wie
oben,
aber
TO
wird
durch
DOWNTO
ersetzt
FOR
n
:=
5
DOWNTO
1
DO
BEGIN
...
END;

Es
werden
dieselben
Schritte
wie
bei
der
aufwärts
zählenden
Schleife
durchgeführt,
nur
n
nimmt
nacheinander
die
Werte
5,
4,
3,
2
und
1
an.

≡≡FUNCTION

Eine
Funktion
(
FUNCTION
)
ist
eine
Folge
von
Anweisungen,
die
durch
Aufruf
des
Funktions-Namens
(und
Übergabe
von
Parametern,
soweit
nötig)
rechts
von
einer
Wertzuweisung
gestartet
wird.
Die
Struktur
einer
Funktion
unterscheidet
sich
nur
im
Funktions-Kopf
und
der
Art
der
Wertrückgabe
von
einem
Programm
(
PROGRAM
)
oder
einer
Prozedur
(
PROCEDURE
),
ansonsten
gelten
die
gleichen
Regeln
wie
unter
PROCEDURE
ausgeführt.

möglicher
Aufbau
einer
Funktion
:

≡

FUNCTION
Quadrat(x
:
REAL)
:
REAL;Der
Funktion
wird
ein
Parameter
vom
BEGINTyp
REAL
über
geben.
Der
Wert
dieses
Quadrat
:=
x
*
x;Parameters
steht
in
der
Variablen
x
END;
zur
Verfügung.
Die
Angabe
":
REAL"
bedeutet,
daß
der
Funktionswert
vom
Typ
REAL
ist.
Diese
Angabe
ist
nötig,
damit
der
Funktionswert
einer
REAL-
Variablen
zugewiesen
werden
kann.
Durch
die
Angabe
"Quadrat
:=
..."
weiß
der
Compiler,
daß
an
der
Stelle
im
Programm,
an
der
"Quadrat(x)"
steht,
der
Wert
von
"x
*
x"
einzusetzen
ist.

≡

Für
die
Übergabe
von
Paramtern
gelten
die
selben
Regeln
wie
unter
PROCEDURE
angegeben.

Beispiele
zum
Aufruf
der
Funktion
Quadrat
(y
ist
vom
Typ
REAL)
:

richtig
:
y
:=
Quadrat(x);
y
:=
Quadrat(3.2);
y
:=
Quadrat(a);Auf
den
Inhalt
von
a
wird
in
der
Funktion
unter
der
Variablen
x
zugegriffen.
Write(Quadrat(z));Der
Funktionswert
läßt
sich
überall
einsetzen,
wo
auch
eine
REAL-Konstante
verwendet
werden
kann.

≡

falsch
:
n
:=
Quadrat(x);n
ist
vom
Typ
INTEGER
Read(Quadrat(x));Read
arbeitet
mit
Variablen-Parametern,
wie
unter
PROCEDURE
im
dritten
Beispiel
angegeben.

≡≡GOTO

GOTO
steht
in
ITG-PASCAL
nicht
zur
Verfügung.

Da
mit
ITG-PASCAL
die
strukturierte
Programmierung
erlernt
werden
soll,
stehen
die
Bezeichner
GOTO
und
LABEL
nicht
zur
Verfügung.
Durch
eine
entsprechende
Programmstruktur
kann
IMMER
auf
diese
Anweisungen
verzichtet
werden.

≡≡HALT

Mit
der
Anweisung
HALT
wird
die
Ausführung
des
Programms
SOFORT
BEENDET.

PROCEDURE
Suche(Text
:
STRING);
VAR
n
:
INTEGER;
BEGIN
FOR
n
:=
1
TO
AnzahlDerStrings
DO
BEGIN
IF
Eintrag[n]
=
Text
THEN
BEGIN
WriteLn(Text,
"
ist
das
",
n,
".te
Element
im
Array
Eintrag.");
WriteLn("Beende
die
Programmausführung.");
HALT;
END;
END;
Write(Text,
"
im
Array
Eintrag
nicht
gefunden.");
END;

≡

Die
vorletzte
Zeile
wird
nur
ausgeführt,
wenn
die
Suche
erfolglos
war,
sonst
wird
der
Erfolg
gemeldet
und
die
Ausführung
des
Programms
wird
sofort
beendet.

≡≡IF

Durch
die
IF
-
THEN
-
ELSE
-
Anweisung
wird
eine
bedingte
Programm-
ausführung
erreicht,
d.h.,
daß
eine
Folge
von
Anweisungen
nur
unter
bestimmten
Voraussetzungen
ausgeführt
wird.

Beispiel
:

IF
x
<
2.5
THEN
BEGINx
ist
vom
Typ
INTEGER
oder
REAL
.Die
Anweisungen
zwischen
BEGIN
und
END
werden
.ausgeführt,
wenn
x
<
2.5
ist,
sonst
wird
das
END;Programm
hinter
END
fortgesetzt.

≡

IF
x
<
2.5
THEN
BEGIN
.Diese
Anweisungen
werden
nur
für
x
<
2.5
.ausgeführt,
END
ELSE
BEGIN
.andernfalls
(d.h.
für
x
>=
2.5)
werden
diese
.Anweisungen
ausgeführt.
END;In
beiden
Fällen
geht
es
dann
nach
dem
END
weiter.

≡≡ IN

In
ITG-PASCAL
ist
die
einzige
zur
Verfügung
stehende
SET
-
Anweisung
...
c
IN
["A..C",
"D",
"X"]
...,
mit
der
geprüft
werden
kann,
ob
der
Wert
einer
CHAR
-
Variablen
in
einer
Menge
von
Zeichen
enthalten
ist.
Das
Ergebnis
ist
ein
Wahrheitswert.

Für
c
=
"B"
oder
c
=
"D"
istc
IN
["A..C",
"D",
"X"]TRUE,
für
c
=
"b"
oder
c
=
"F"
istc
IN
["A..C",
"D",
"X"]FALSE.

≡≡INCLUDE

Mit
der
Anweisung
INCLUDE
[Pfad\]Dateiname
kann
im
Deklarationsteil
eines
Programms
oder
einer
Prozedur
/
Funktion
der
Quelltext
einer
Datei
in
das
Programm
an
der
vorgesehenen
Stelle
eingebunden
werden,
ohne
daß
der
Quelltext
der
Datei
im
Editor
vorhanden
ist.
Die
Pfad-
angabe
kann
entfallen,
wenn
die
Datei
im
aktuellen
Verzeichnis
zu
finden
ist.
Es
kann
auch
die
Syntax
von
TURBO-PASCAL
mit
{$I
[Pfad\]Dateiname}
verwendet
werden.

Beispiel
:
INCLUDE
C:\ITG\BSP\PRG1.INC,
C:\ITG\BSP\PRG2.INC;

oder

{$I
C:\ITG\BSP\PRG1.INC}
{$I
C:\ITG\BSP\PRG2.INC}

≡≡LABEL

LABEL
steht
in
ITG-PASCAL
nicht
zur
Verfügung.

Da
mit
ITG-PASCAL
die
strukturierte
Programmierung
erlernt
werden
soll,
stehen
die
Bezeichner
GOTO
und
LABEL
nicht
zur
Verfügung.
Durch
eine
entsprechende
Programmstruktur
kann
IMMER
auf
diese
Anweisungen
verzichtet
werden.

≡≡MOD

MODDivisionsrest7
MOD
5
=
2(=
1
Rest
2)

≡≡NEW

NEW
fordert
Speicherplatz
auf
dem
Heap
für
eine
Zeigervariable
an.

Beispiel
:

NEW(Zeigertyp);Platz
für
eine
Zeigervariable
auf
dem
Heap
.anfordern.
Erst
dann
dürfen
Zuweisungen
.vorgenommen
werden.
DISPOSE(Zeigertyp);Wenn
der
Inhalt
der
Zeigervariablen
nicht
mehr
benötigt
wird,
wird
der
Platz
auf
dem
Heap
wieder
freigegeben.

≡≡NIL

NIL
ist
der
Wert
eines
nicht
mit
NEW
initialisierten
Zeigers.
Wenn
der
Wert
eines
Zeigers
NIL
ist,
darf
auf
KEINEN
FALL
in
die
Variable
geschrieben
werden,
auf
die
der
Zeiger
zeigt,
weil
sonst
ein
Rechner-
absturz
erfolgen
kann.

c
:
^CHAR;c
zeigt
auf
eine
CHAR-Variable

IF
c
<>
NIL
THEN
c^
:=
"A";sicherstellen,
daß
c
initialisiert
wurde,
dann
erst
in
c^
hineinschreiben

≡≡NOT

Mit
NOT
kann
einerseits
ein
Wahrheitswert
negiert
werden,
andererseits
kann
eine
bitweise
Umkehr
der
Ziffern
einer
Zahl
im
Binärsystem
erfolgen.

Verknüpfung
von
Wahrheitswerten
(
BOOLEAN
):

a│NOT
a
───────┼───────────
FALSE│TRUE
TRUE│FALSE

≡

Verknüpfung
von
INTEGER
-
Werten

│dezimal│binärFür
jede
Ziffer
im
Binärsystem
wird
─────────┼───────────┼─────────eine
Umkehrung
nach
der
obigen
Tabelle
a│13│
00001101für
Wahrheitswerte
durchgeführt,
wobei
─────────┼───────────┼─────────0
durch
FALSE
und
1
durch
TRUE
zu
NOT
a│-14│
11110010ersetzen
sind.

Dieses
merkwürdig
erscheinende
Ergebnis
kommt
dadurch
zustande,
daß
das
führende
(linke)
Bit
als
Vorzeichen
(0
:
+
/
1
:
-)
interpretiert
wird
und
daß
in
folgender
Weise
gezählt
wird
:

0,
1,
2...32768,-32767,-32766,...,-2,-1

≡≡OF

OF
wird
in
der
CASE
-
OF
-
Struktur
und
bei
der
Festlegung
eines
Dateityps
mit
FILE
-
OF
verwendet.

≡≡OR

Mit
OR
kann
einerseits
geprüft
werden,
ob
von
zwei
oder
mehr
Wahrheits-
werten
mindestens
einer
erfüllt
ist,
andererseits
kann
eine
bitweise
Verknüpfung
zweier
oder
mehrerer
INTEGER
-
Werte
erfolgen.

Verknüpfung
von
Wahrheitswerten
(
BOOLEAN
):

a│b│a
OR
b
───────┼───────────┼───────────
FALSE│FALSE│FALSE
FALSE│TRUE│TRUE
TRUE│FALSE│TRUE
TRUE│TRUE│TRUE

≡

Verknüpfung
von
INTEGER
-
Werten

│dezimal│binärFür
je
zwei
untereinanderstehende
─────────┼───────────┼────────Ziffern
im
Binärsystem
wird
eine
a│5│0101Verknüpfung
nach
der
obigen
Tabelle
b│9│1001für
Wahrheitswerte
durchgeführt,
wobei
─────────┼───────────┼────────0
durch
FALSE
und
1
durch
TRUE
zu
a
OR
b│13│1101ersetzen
sind.

≡≡PACKED

PACKED
steht
in
ITG-PASCAL
nicht
zur
Verfügung.

≡≡PROCEDURE

Eine
Prozedur
(
PROCEDURE
)
ist
eine
Folge
von
Anweisungen,
die
durch
Angabe
des
Prozedur-Namens
(und
Übergabe
von
Parametern,
soweit
nötig)
gestartet
wird.
Die
Struktur
einer
Prozedur
unterscheidet
sich
nur
im
Prozedur-Kopf
von
einem
Programm
(
PROGRAM
),
ansonsten
gelten
die
gleichen
Regeln
wie
unter
PROGRAM
ausgeführt.

mögliche
Prozedurköpfe
:

PROCEDURE
Name;
.weiter
wie
bei
einem
Programm
.

Die
Prozedur
benötigt
keine
Parameter.
Der
Aufruf
erfolgt
einfach
durch
Hinschreiben
von
"Name"
im
Anweisungsteil
des
Programms,
einer
Prozedur
(einer
anderen
oder
dieser)
oder
einer
Funktion,
wenn
die
Programm-
ausführung
diese
Stelle
erreicht.

≡

PROCEDURE
Name(x,
y
:
INTEGER;
r
:
REAL);
.
.

Der
Prozedur
sind
drei
Parameter
zu
übergeben,
die
in
der
Reiehenfolge
den
Variablen
x,
y
und
r
zugewiesen
werden.

Beispiele
:

richtig
:
Name(3,
5,
4.9);x
=
3,
y
=
5,
r
=
4.9
Name(3,
5,
9);x
=
3,
y
=
5,
r
=
9(.0)

falsch
:
Name(3);
zwei
Parameter
zu
wenig
Name(4.9,
3,
5);x
kann
nicht
den
Wert
4.9
annehmen!

≡

PROCEDURE
Name(x,
y
:
INTEGER;
VAR
a
:
INTEGER);
.
.

Der
Prozedur
sind
drei
Parameter
zu
übergeben,
die
in
der
Reiehenfolge
den
Variablen
x,
y
und
a
zugewiesen
werden.
Wenn
innerhalb
der
Prozedur
Name
die
Inhalte
von
x
und
y
verändert
werden,
merkt
das
die
aufrufende
Prozedur
nicht.
Wenn
der
Wert
von
a
verändert
wird,
wird
auch
der
Wert
der
Variablen
verändert,
die
als
dritter
Parameter
übergeben
wurde.
Daraus
ergibt
sich,
daß
als
dritter
Parameter
eine
Variable
verwendet
werden
muß!

Beispiele
:

richtig
:
Name(3,
5,
n);x
=
3,
y
=
5,
a
=
n(n
ist
INTEGER-Variable)

≡

falsch
:
Name(3);
zwei
Parameter
zu
wenig
Name(4.9,
3,
n);x
kann
nicht
den
Wert
4.9
annehmen!
Name(3,
5,
9);der
dritte
Parameter
MUß
eine
Variable
sein

≡≡PROGRAM

Jedes
PASCAL-Programm
beginnt
mit
dem
Bezeichner
PROGRAM
und
einem
Programmnamen.
Daran
schließen
sich
je
nach
Bedarf
Typ-,
Konstanten-,
Variablen-,
Prozedure-
und
Funktions-Deklarationen
an.
Anschließend
folgen
die
Anweisungen
des
Hauptprogramms,
die
von
BEGIN
und
END
eingeschlossen
sind.
Das
Ende
des
Programms
ist
durch
einen
Punkt
"."
zu
kennzeichnen.

Das
kleinstmögliche
Programm
:

PROGRAM
EinName;
BEGIN
END.

≡

Standardaufbau
eines
Programms
:

PROGRAM
EinName;
CONSTDie
Konstanten-,
Typ-,
Variablen-,
Prozedur-
.....und
Funktions-Deklarationen
dürfen
in
diesem
TYPEAbschnitt,
dem
Deklarationteil,
bis
zum
BEGIN
.....des
Hauptprogramms
in
beliebiger
Anzahl
und
VARReihenfolge
erfolgen.
Es
ist
aber
darauf
zu
.....achten,
daß
alles,
worauf
zugegriffen
wird,
PROCEDURE
.....VOR
der
ersten
Verwendung
zu
deklarieren
ist!
.....Dadurch
ergeben
sich
oft
Zwänge
für
eine
bestimmte
FUNCTION
.....    Reihenfolge
der
Deklarationen.
.....
BEGINMit
diesem
BEGIN
fängt
das
Hauptprogramm
an.
.....Die
erste
Anweisung
wird
beim
Programmstart
ausge-
END.führt.
Ende
des
Programms
mit
"END.".

≡≡RECORD

Die
Programmiersprache
PASCAL
erlaubt
es,
aufbauend
auf
den
vordefierten
Datentypen
eigene
neue
Datenstrukturen
und
Typen
zu
definieren.
Diese
Deklararation
wird
durch
TYPE
eingeleitet
(
siehe
auch
VAR
).
Die
Struktur
des
Datentyps
ist
in
die
Bezeichner
RECORD
und
END
einzuklammern.

TYPE
DatenEinerPerson
=
RECORD
Vorname,
Nachname,
Wohnort,
Straße
:
STRING[20];
PLZ,
HausNr,
Tel
:
INTEGER;
END;
VAR
Person
:
DatenEinerPerson;

Die
Variable
"Person"
enthält
dann
automatisch
die
7
aufgeführten
Felder,
auf
die
über
Person.Feldbezeichnung
zugegriffen
werden
kann.
Innerhalb
einer
WITH
-
DO
-
Anweisung
kann
Schreibarbeit
eingespart
werden.

≡

Der
Vorteil
einer
Datenstruktur
ist,
daß
alle
Felder
dieser
Variablen
fest
miteinander
verbunden
sind
(man
spricht
deshalb
auch
von
einem
VERBUND)
und
daß
Programmfehler
leichter
vermieden
werden
können,
durch
die
Teile
mehrere
gleichartiger
Variablen
durcheinander
geraten
können.

≡

Beispiele
:

Person.Vorname
:=
"Egon";
Person.Nachname
:=
"Müller";

WITH
Person
DO
BEGIN
Vorname
:=
"Egon";
Nachname
:=
"Müller";
END;

Damit
sind
der
Variablen
"Person"
Vorname
und
Nachname
zugewiesen
worden.

≡≡REPEAT

Die
REPEAT
-
UNTIL
-
Schleife
ist
eine
Schleife,
bei
der
NACH
Ausführung
der
Anweisungen
zwischen
REPEAT
und
UNTIL
geprüft
wird,
ob
die
Anweis-
ungsfolge
noch
einmal
ausgeführt
wird.
Das
ist
dann
der
Fall,
wenn
die
Bedingung
hinter
UNTIL
(Abbruchbedingung)
NICHT
ERFÜLLT
ist.
Innerhalb
der
Schleife
ist
darauf
zu
achten,
daß
die
Abbruchbedingung
irgendwann
erfüllt
wird,
da
das
Programm
die
Schleife
sonst
unendlich
oft
durch-
läuft.

Die
Schleife
wird
AUF
JEDEN
FALL
einmal
durchlaufen,
weil
die
Prüfung
erst
am
Ende
durchgeführt
wird.
(s.
auch
WHILE
-
DO
-
Schleife)

Beispiel
:

≡

x
:=
-1.5;    x
einen
definierten
Wert
zuweisen
REPEAT
.Anweisungsfolge,
die
für
x-Werte
zwischen
-1.5
und
.1.5
ausgeführt
werden
soll
x
:=
x
+
0.1;x
erhöhen,
damit
die
Abbruchbedingung
erfüllt
wird
UNTIL
x
>
1.5;nicht
x
=
1.6
wegen
möglicher
Rundungsfehler
x
nimmt
den
Wert
1.6
nicht
unbedingt
GENAU
an,
dann
gibt
es
eine
Endlos-Schleife!

≡≡SET

SET
steht
in
ITG-PASCAL
nicht
zur
Verfügung.

In
ITG-PASCAL
ist
die
einzige
zur
Verfügung
stehende
SET
-
Anweisung
...
c
 IN
["A..C",
"D",
"X"]
...,
mit
der
geprüft
werden
kann,
ob
der
Wert
einer
CHAR-Variablen
in
einer
Menge
von
Zeichen
enthalten
ist.

≡≡THEN

THEN
ist
ein
Teil
der
IF
-
THEN
-
ELSE
-
Anweisung.

≡≡TO

TO
ist
ein
Teil
des
Schleifenkopfes
der
aufwärts
zählenden
FOR
-
TO
-
Schleife.

≡≡TYPE

Die
Programmiersprache
PASCAL
erlaubt
es,
aufbauend
auf
den
vordefierten
Datentypen
eigene
neue
Datenstrukturen
und
Typen
zu
definieren.
Diese
Deklararation
wird
durch
TYPE
eingeleitet
(
siehe
auch
VAR
).

TYPE
Wochentage
=
(Mo,
Di,
Mi,
Do,
Fr,
Sa,
So);
    Einer
Variablen
vom
Typ
Wochentage
kann
nur
einer
dieser
7
Werte
    zugewiesen
werden.
DatenEinerPerson
=
RECORD
Vorname,
Nachname,
Wohnort,
Straße
:
STRING[20];
PLZ,
HausNr,
Tel
:
INTEGER;
END;
    Eine
Variable
vom
Typ
DatenEinerPerson
enthält
dann
automatisch
    die
7
aufgeführten
Felder,
auf
die
über
Variablenname.Feldbezeich-
    nung
zugegriffen
werden
kann.

≡≡UNTIL

UNTIL
ist
ein
Teil
der
REPEAT
-
UNTIL
-
Schleife.

≡≡USES

USES
wird
in
der
vorliegenden
Version
von
ITG-PASCAL
nicht
benötigt.

Mit
USES
werden
in
TURBO-PASCAL
UNITs
eingebunden,
deren
Quelltext
nicht
unbedingt
zur
Verfügung
stehen
muß.
Auf
diese
Weise
wird
das
Arbeiten
mit
fertigen
Programm-Bibliotheken
sehr
erleichtert.

In
ITG-PASCAL
sind
bereits
umfangreiche
Bibliotheken
enthalten,
sodaß
UNITs
für
nicht
so
dringend
wie
in
TURBO-PASCAL
benötigt
werden.

≡≡VAR

In
PASCAL-Programmen
muß
VOR
der
ersten
Verwendung
einer
Variablen
bekannt
sein,
um
welchen
Typ
es
sich
handeln
soll.
Diese
Information
entnimmt
der
Compiler
der
Variablen-Deklaration,
die
durch
VAR
einge-
leitet
wird.

VAR
m,
n
:
INTEGER;
x:
REAL;

oder

VAR
m
:
INTEGER;
n
:
INTEGER;
x
:
REAL;

≡

oder

VAR
m
:
INTEGER;
VAR
n
:
INTEGER;
VAR
x
:
REAL;

≡≡WHILE

Die
WHILE
-
DO
-
Schleife
ist
eine
Schleife,
bei
der
VOR
Ausführung
der
Anweisungen
zwischen
WHILE
und
dem
dazugehörigen
END
geprüft
wird,
ob
die
Anweisungsfolge
noch
ausgeführt
wird.
Das
ist
dann
der
Fall,
wenn
die
Bedingung
hinter
WHILE
(Abbruchbedingung)
ERFÜLLT
ist.
Innerhalb
der
Schleife
ist
darauf
zu
achten,
daß
die
Abbruchbedingung
irgendwann
erfüllt
wird,
da
das
Programm
die
Schleife
sonst
unendlich
oft
durch-
läuft.

Die
Schleife
wird
NICHT
UNBEDINGT
durchlaufen,
weil
die
Prüfung
schon
vor
der
ersten
Ausführung
durchgeführt
wird.

Beispiel
:

≡

x
:=
-1.5;x
einen
definierten
Wert
zuweisen
WHILE
x
<=
1.5
DO
BEGIN
.Anweisungsfolge,
die
für
x-Werte
zwischen
.-1.5
und
1.5
ausgeführt
werden
soll
x
:=
x
+
0.1;
x
erhöhen,
damit
die
Abbruchbedingung
erfüllt
END;wird

≡≡WITH

WITH
dient
dem
vereinfachten
Zugriff
auf
Variablen
eines
RECORD
's.
Damit
ist
beim
Zugriff
auf
umfangreichere
RECORD
-
Variablen
weniger
Schreib-
arbeit
nötig.

Beispiel
:

TYPE
PunktTyp
=
RECORD
x,
y
:
REAL;
END;
VAR
P
:
PunktTyp;

≡

statt

P.x
:=
1.3;
P.y
:=
7.4;

kann
geschrieben
werden

WITH
P
DO
BEGIN
x
:=
1.3;
y
:=
7.4;
END;

≡≡XOR

Mit
XOR
kann
einerseits
geprüft
werden,
ob
von
zwei
Wahrheitswerten
genau
einer
erfüllt
ist,
andererseits
kann
eine
bitweise
Verknüpfung
zweier
INTEGER
-
Werte
erfolgen.

Verknüpfung
von
Wahrheitswerten
(
BOOLEAN
):

a│b│a
XOR
b
───────┼───────────┼───────────
FALSE│FALSE│FALSE
FALSE│TRUE│TRUE
TRUE│FALSE│TRUE
TRUE│TRUE│FALSE

≡

Verknüpfung
von
INTEGER
-
Werten

│dezimal│binärFür
je
zwei
untereinanderstehende
─────────┼───────────┼────────Ziffern
im
Binärsystem
wird
eine
a│13│1101Verknüpfung
nach
der
obigen
Tabelle
b│11│1011für
Wahrheitswerte
durchgeführt,
wobei
─────────┼───────────┼────────0
durch
FALSE
und
1
durch
TRUE
zu
a
XOR
b│6│0110ersetzen
sind.

≡≡Konstante

BlauCRDunkelblau
DunkelgelbDunkelgrauDunkelgrün
DunkelkobaltDunkelrotDunkelviolett
ESCEulerFALSE
GelbGrauGrün
Kobalt
LSTPi
RotSchwarz    StrgBildAb2
StrgBildAuf2TRUEViolett
Weiß

≡≡Blau

Blau
ist
eine
INTEGER-Konstante,
die
auf
VGA-Karten
blaue
Schrift
oder
blaue
Grafik
erzeugt.
Ihr
Zahlenwert
ist
9.

≡≡CR

CR
ist
eine
CHAR-Konstante,
deren
Wert
beim
Drücken
der
RETURN-Taste
an
das
Programm
übergeben
wird.

≡≡Dunkelblau

Dunkelblau
ist
eine
INTEGER-Konstante,
die
auf
VGA-Karten
blaue
Schrift
oder
dunkelblaue
Grafik
erzeugt.
Ihr
Zahlenwert
ist
1.

≡≡Dunkelgelb

Dunkelgelb
ist
eine
INTEGER-Konstante,
die
auf
VGA-Karten
gelbe
Schrift
oder
dunkelgelbe
Grafik
erzeugt.
Ihr
Zahlenwert
ist
6.

≡≡Dunkelgrau

Dunkelgrau
ist
eine
INTEGER-Konstante,
die
auf
VGA-Karten
graue
Schrift
oder
dunkelgraue
Grafik
erzeugt.
Ihr
Zahlenwert
ist
8.

≡≡Dunkelgrün

Dunkelgrün
ist
eine
INTEGER-Konstante,
die
auf
VGA-Karten
grüne
Schrift
oder
dunkelgrüne
Grafik
erzeugt.
Ihr
Zahlenwert
ist
2.

≡≡Dunkelkobalt

Dunkelkobalt
ist
eine
INTEGER-Konstante,
die
auf
VGA-Karten
blaue
Schrift
oder
dunkelblaue
Grafik
erzeugt.
Ihr
Zahlenwert
ist
3.

≡≡Dunkelrot

Dunkelrot
ist
eine
INTEGER-Konstante,
die
auf
VGA-Karten
rote
Schrift
oder
dunkelrote
Grafik
erzeugt.
Ihr
Zahlenwert
ist
4.

≡≡Dunkelviolett

Dunkelviolett
ist
eine
INTEGER-Konstante,
die
auf
VGA-Karten
violette
Schrift
oder
dunkelviolette
Grafik
erzeugt.
Ihr
Zahlenwert
ist
5.

≡≡ESC

ESC
ist
eine
CHAR-Konstante,
deren
Wert
beim
Drücken
der
ESC-Taste
an
das
Programm
übergeben
wird.

≡≡Euler

Die
Konstante
Euler
ist
die
Eulersche
Zahl
e=2.718281828..
.
Die
Abkürzung
e
kann
für
die
Eulersche
Zahl
nicht
verwendet
werden,
weil
e
in
PASCAL
für
die
Exponentialschreibweise
einer
reellen
Zahl
verwendet
wird
(z.B.
5.4e-3).

≡≡FALSE

FALSE
(Falsch)
ist
der
Wahrheitswert
einer
Aussage.
FALSE
kann
nur
einer
Variablen
des
Typs
BOOLEAN
zugeordnet
werden.

Beispiel
:
VAR
IstWahr
:
BOOLEAN;
BEGIN
IstWahr
:=
FALSE;
IF
IstWahr
=
FALSE
THEN
BEGINFür
IstWahr
=
FALSE
kann
auch

TueDasEine;NOT
IstWahr
geschrieben
werden.
END
ELSE
BEGIN

TueDasAndere;
END;
END;

≡≡Gelb

Gelb
ist
eine
INTEGER-Konstante,
die
auf
VGA-Karten
gelbe
Schrift
oder
gelbe
Grafik
erzeugt.
Ihr
Zahlenwert
ist
14.

≡≡Grau

Grau
ist
eine
INTEGER-Konstante,
die
auf
VGA-Karten
graue
Schrift
oder
graue
Grafik
erzeugt.
Ihr
Zahlenwert
ist
7.
Auf
CGA-
und
Herkules-Karten
wird
das
erreicht,
indem
niemals
zwei
waagerecht
oder
senkrecht
nebeneinanderliegende
Punkte
in
derselben
Farbe
gezeichnet
werden.
Ein
Punkt
hat
jeweils
die
Farbe
Weiß
und
seine
vier
Nachbarn
haben
die
Farbe
Schwarz.

≡≡Grün

Grün
ist
eine
INTEGER-Konstante,
die
auf
VGA-Karten
grüne
Schrift
oder
grüne
Grafik
erzeugt.
Ihr
Zahlenwert
ist
10.

≡≡Kobalt

Kobalt
ist
eine
INTEGER-Konstante,
die
auf
VGA-Karten
blaue
Schrift
oder
blaue
Grafik
erzeugt.
Ihr
Zahlenwert
ist
11.

≡≡LST

LST
ist
eine
Konstante
des
Dateityps
TEXT.
Sie
dient
dazu,
WRITE-
Anweisungen
auf
den
Drucker
umzulenken.
In
ITG-PASCAL
können
stattdessen
auch
die
Anweisungen
AusgabeAufDrucker
und
AusgabeAufBildschirm
zur
Umlenkung
der
Ausgabe
verwendet
werden.
Dadurch
können
im
Unterschied
zu
TURBO-PASCAL
mit
derselben
Anweisungs-
folge
Informationen
sowohl
auf
den
Bildschirm
als
auch
auf
den
Drucker
ausgegeben
werden.

≡

Beispiele
:
TURBO-PASCAL
und
ITG-PASCAL
:
    WriteLn(LST,
'Dieser
Text
erscheint
auf
dem
Drucker.');
WriteLn('Dieser
Text
erscheint
auf
dem
Bildschirm.');

alternativ
in
ITG-PASCAL
:
AusgabeAufDrucker;
WriteLn("Dieser
Text
erscheint
auf
dem
Drucker.");
AusgabeAufBildschirm;
WriteLn("Dieser
Text
erscheint
auf
dem
Bildschirm.");

≡≡Pi

Die
Konstante
PI
ist
die
Kreiszahl
π=3.141592654..
.


≡≡Rot

Rot
ist
eine
INTEGER-Konstante,
die
auf
VGA-Karten
rote
Schrift
oder
rote
Grafik
erzeugt.
Ihr
Zahlenwert
ist
12.

≡≡Schwarz

Schwarz
ist
eine
INTEGER-Konstante,
die
auf
CGA-,
Herkules-
und
VGA-
Karten
schwarze
Schrift
oder
schwarze
Grafik
erzeugt.
Ihr
Zahlenwert
ist
0.

≡≡StrgBildAb2

StrgBildAb2
ist
eine
CHAR-Konstante,
deren
Wert
beim
Drücken
der
Tastenkombination
Strg-Bild-Ab
(Ctrl-PgDn)
als
zweites
Zeichen
an
das
Programm
übergeben
wird.
Mit
dieser
Tastenkombination
kann
die
Prozedur
LiesEingaben
beendet
werden,
um
auf
den
folgenden
Datensatz
zu
wechseln.

Beispiel:
TYPE
EinEintrag
=
RECORD

Nachname,
Vorname,
Ort,
Straße
:
STRING[20];

Plz,
HausNr,
Vorwahl,
TelNr
:
LONGINT;
END;
CONST
Anzahl
=
3;
VAR
TelefonListe
:
ARRAY[1..Anzahl]
OF
EinEintrag;
n
:
INTEGER;

≡

BEGIN
n
:=
1;
REPEAT

WITH
TelefonListe[n]
DO
BEGIN
EingabeFeld(
1,
3,
"Name:
",
Nachname);
EingabeFeld(
1,
4,
"Vorname
:
",
Vorname);
EingabeFeld(
1,
5,
"Plz
:
",
Plz);
EingabeFeld(25,
5,
"Ort
:
",
Ort);
EingabeFeld(
1,
6,
"Straße:
",
Straße);
EingabeFeld(35,
6,
"Nr.
:
",
HausNr);
EingabeFeld(
1,
7,
"Vorwahl
:
",
Vorwahl);
EingabeFeld(30,
7,
"Telefon-Nr
:
",
TelNr);
LiesEingaben;

END;

≡


CASE
LetzteTaste
OF
CR,
StrgBildAb2
:nächsten
Datensatz
bearbeiten
n
:=
n
+
1;
ESC
:
n
:=
Anzahl
+
1;
StrgBildAuf2
:
vorigen
Datensatz
noch
einmal
IF
n
>
1
THEN
BEGINbearbeiten
n
:=
n
-
1;
END;

END;
UNTIL
n
>
Anzahl;
END;

≡≡StrgBildAuf2

StrgBildAuf2
ist
eine
CHAR-Konstante,
deren
Wert
beim
Drücken
der
Tastenkombination
Strg-Bild-Auf
(Ctrl-PgUp)
als
zweites
Zeichen
an
das
Programm
übergeben
wird.
Mit
dieser
Tastenkombination
kann
die
Prozedur
LiesEingaben
beendet
werden,
um
auf
den
vorangegangenen
Datensatz
zu
wechseln.

Beispiel:
TYPE
EinEintrag
=
RECORD

Nachname,
Vorname,
Ort,
Straße
:
STRING[20];

Plz,
HausNr,
Vorwahl,
TelNr
:
LONGINT;
END;
CONST
Anzahl
=
3;
VAR
TelefonListe
:
ARRAY[1..Anzahl]
OF
EinEintrag;
n
:
INTEGER;

≡

BEGIN
n
:=
1;
REPEAT

WITH
TelefonListe[n]
DO
BEGIN
EingabeFeld(
1,
3,
"Name:
",
Nachname);
EingabeFeld(
1,
4,
"Vorname
:
",
Vorname);
EingabeFeld(
1,
5,
"Plz
:
",
Plz);
EingabeFeld(25,
5,
"Ort
:
",
Ort);
EingabeFeld(
1,
6,
"Straße:
",
Straße);
EingabeFeld(35,
6,
"Nr.
:
",
HausNr);
EingabeFeld(
1,
7,
"Vorwahl
:
",
Vorwahl);
EingabeFeld(30,
7,
"Telefon-Nr
:
",
TelNr);
LiesEingaben;

END;

≡


CASE
LetzteTaste
OF
CR,
StrgBildAb2
:nächsten
Datensatz
bearbeiten
n
:=
n
+
1;
ESC
:
n
:=
Anzahl
+
1;
StrgBildAuf2
:
vorigen
Datensatz
noch
einmal
IF
n
>
1
THEN
BEGINbearbeiten
n
:=
n
-
1;
END;

END;
UNTIL
n
>
Anzahl;
END;

≡≡TRUE

TRUE
(Wahr)
ist
der
Wahrheitswert
einer
Aussage.
TRUE
kann
nur
einer
Variablen
des
Typs
BOOLEAN
zugeordnet
werden.

Beispiel
:
VAR
IstWahr
:
BOOLEAN;
BEGIN
IstWahr
:=
TRUE;
IF
IstWahr
=
TRUE
THEN
BEGIN    Für
IstWahr
=
TRUE
kann
auch
    TueDasEine;            IstWahr
geschrieben
werden.
END
ELSE
BEGIN

TueDasAndere;
END;
END;

≡≡Violett

Violett
ist
eine
INTEGER-Konstante,
die
auf
VGA-Karten
violette
Schrift
oder
violette
Grafik
erzeugt.
Ihr
Zahlenwert
ist
13.

≡≡Weiß

Weiß
ist
eine
INTEGER-Konstante,
die
auf
CGA-,
Herkules-
und
VGA-Karten
weiße
Schrift
oder
weiße
Grafik
erzeugt.
Ihr
Zahlenwert
ist
15.

≡≡Typen

CHARSTRINGBOOLEANBYTEINTEGER
WORDLONGINTREALDOUBLEEXTENDED
FILE TEXTSIGNAL

ITG-PASCAL
unterscheidet
nur
8
verschiedene
Datentypen
voneinander.
1)CHAR:
einzelner
Buchstabe
2)STRING:
Zeichenkette,
eine
Aneinanderfügung
von
Buchstaben
3)BOOLEAN:
Aussagetyp,
WAHR
oder
FALSCH
4)LONGINT:
ganze
Zahlen
im
Bereich
von
-2147483648
bis
2147483647
5)EXTENDED:
Dezimalzahlen
mit
einem
Betrag
von
3.4*10^-4932
bis
1,1*10^4932
6)FILE:
Datei-Variable
beliebigen
Typs
7)
 TEXT:
Datei-Variable
für
Strings
(Zeichenketten)
8)SIGNAL:
Synchronisation
von
Prozessen

≡≡CHAR

CHAR:
einzelner
Buchstabe

Beispiel
:
VAR
c
:
CHAR;Deklaration
BEGIN
c
:=
"b";erlaubte
Zuweisung,
c
hat
jetzt
den
Wert
"b"
c
:=
"ABC";falsch!
c
kann
nur
EINEN
Buchstaben
aufnehmen
c
:=
65;falsch!
c
kann
keine
Zahlenwerte
annehmen
c
:=
CHR(65);c
wird
der
Wert
"A"
zugewiesen
.(
65.
Buchstabe
der
ASCII-Tabelle
)
.
END;

≡≡STRING

STRING:
Zeichenkette,
eine
Aneinanderfügung
von
Buchstaben
Bei
der
Deklaration
sollte
die
benötigte
Zeichenzahl
angegeben
werden,
weil
alle
READ-Anweisungen
ein
Eingabefenster
entsprechend
der
Deklarationslänge
öffnen.

Deklarations-Beispiele:
s255
:
STRING;255
Zeichen
s10:
STRING[10];10
Zeichen
s:
STRING[Max];
mit
1
<=
Max
<=
255
≡≡BOOLEAN

BOOLEAN:
Aussagetyp,
WAHR
oder
FALSCH

≡≡BYTE

siehe
LONGINT

≡≡INTEGER

siehe
LONGINT

≡≡WORD

siehe
LONGINT

≡≡LONGINT

LONGINT:
ganze
Zahlen
im
Bereich
von
-2147483648
bis
2147483647
Die
Datentypen
BYTE,
INTEGER
und
WORD
werden
intern
im
Datenformat
LONGINT
verwaltet
und
können
deshalb
Werte
in
dem
selben
Bereich
wie
LONGINT-Variablen
annehmen.

≡≡REAL

siehe
EXTENDED

≡≡DOUBLE

siehe
EXTENDED

≡≡EXTENDED

EXTENDED:
Dezimalzahlen
mit
einem
Betrag
von
3.4*10^-4932
bis
1.1*10^4932
mit
einer
Genauigkeit
von
19
bis
20
Stellen
Die
Datentypen
REAL
und
DOUBLE
werden
intern
im
Datenformat
EXTENDED
verwaltet
und
können
deshalb
Werte
in
dem
selben
Bereich
wie
EXTENDED-Variablen
annehmen.

≡≡FILE

FILE:
Datei-Variable
beliebigen
Typs
Im
Unterschied
zu
TURBO-PASCAL
können
einer
Datei-
Variablen
beliebige
Datentypen
außer
FILE-
und
 TEXT-
Typen
zugeordnet
werden,
ohne
daß
eine
spezielle
Deklaration
erfolgen
muß.
Auf
diese
Weise
können
in
einer
Datei
beliebig
viele
Variablen
nacheinander
abgespeichert
werden.
Die
Operationen
READ
und
WRITE
in
ITG-PASCAL
entsprechen
dann
BLOCKREAD
UND
BLOCKWRITE
in
TURBO-PASCAL.
Das
Lesen
und
Schreiben
typisierter
Dateien
entspricht
dem
von
TURBO-PASCAL.

≡≡ TEXT

TEXT:
Datei-Variable
für
Strings
(Zeichenketten)
In
ITG-PASCAL
können
nur
die
Anweisungen
READLN(TextDatei,
Zeichenkette)
und
WRITELN(TextDatei,
Zeichenkette)
verwendet
werden.
READ,
WRITE
und
Char-Variablen
dürfen
nicht
verwendet
werden.

≡≡SIGNAL

SIGNAL:
Synchronisation
von
Prozessen
Wenn
zwei
Prozesse,
die
gleichzeitig
ausgeführt
werden,
auf
Zwischenergebnisse
des
jeweils
anderen
Prozesses
angewiesen
sind,
kann
einer
der
Prozesse
durch
WarteAufSignal(SignalVar)
zum
Warten
veranlaßt
werden,
bis
der
andere
Prozeß
durch
SendeSignal(SignalVar)
mitteilt,
daß
die
Zwischenergebnisse
bereitgestellt
sind.

≡≡Igel-Grafik

DreheAufGeheNachHinten
IgelWinkel
IgelZeigen
LinkerBogen

 LinksMaßstabMitIgel
MitStiftOhneIgelOhneStift
RechterBogen RechtsStiftFarbe
UrsprungVorneWoIgelX
WoIgelY

≡≡DreheAuf

DreheAuf
richtet
den
Igel
auf
einen
absoluten
Winkel
aus,
der
von
der
positiven
x-Achse
aus
gegen
den
Uhrzeigersinn
im
mathematisch
positiven
Umlaufsinn
in
Winkelgrad
gemessen
wird.

Deklaration:
PROCEDURE
DreheAuf(AbsoluterWinkel
:
REAL);

Beispiel:
DreheAuf(90);Der
Igel
zeigt
nach
oben.
DreheAuf(180);Der
Igel
zeigt
nach
links.
(Drehung
um
180°
entgegen
dem
Uhrzeiger-
sinn
von
der
positiven
x-Achse
aus)
DreheAuf(-180);Auch
hier
zeigt
der
Igel
nach
links.
(Drehung
um
180°
im
Uhrzeigersinn
von
der
positiven
x-Achse
aus)

≡≡GeheNach

Der
Igel
wird
in
seinem
Koordinatensystem,
dessen
Ursprung
der
Mittelpunkt
des
Grafikfensters
ist,
dessen
positive
x-Achse
nach
rechts
und
dessen
positive
y-Achse
nach
oben
zeigt,
zu
den
angegebenen
Koordinaten
bewegt,
ohne
daß
er
dabei
zeichnet.
Die
Maximalwerte
sind
in
x-Richtung
-320
und
320
und
in
y-Richtung
-240
und
240
für
alle
Grafikkarten.
Es
gibt
zwei
weitere
Koordinatensysteme
für
Grafik
ohne
Igel
(s.
auch
MoveTo,
WeltGeheNach)
und
für
den
Textcursor
(s.
auch
GotoXY).

≡

Deklaration:
PROCEDURE
GeheNach(xPos,
yPos
:
INTEGER);

Beispiel:
GeheNach(0,
0);bewegt
den
Igel
auf
den
Ursprung
seines
Koordinatensystems.
GeheNach(200,
100);bewegt
den
Igel
vom
Ursprung
seines
Koordinatensystems
aus
gesehen
um
200
Schritte
nach
rechts
und
um
100
nach
oben.

≡≡Hinten

Durch
die
Anweisung
Hinten(x)
wird
der
Igel
x
Schritte
rückwärts
bewegt.
Wenn
die
Bewegung
mit
Stift
erfolgt,
ist
seine
Spur
anschließend
sichtbar.

Deklaration:
PROCEDURE
Hinten(Schritte
:
REAL);

Beispiel:
Hinten(50);
bewegt
den
Igel
50
Schritte
rückwärts.

≡≡IgelWinkel

Die
Funktion
IgelWinkel
liefert
den
Winkel
zwischen
der
Bewegungsrichtung
vorwärts
und
der
positiven
x-Achse
im
mathematisch
positiven
Umaufsinn
gemessen.

Deklaration:
FUNCTION
IgelWinkel
:
REAL;

Beispiel:
DreheAuf(100);
Write(IgelWinkel);
druckt
den
Wert
100
für
den
Winkel
aus.

≡≡IgelZeigen

Die
Funktion
IgelZeigen
ergibt
den
Wert
wahr
(TRUE),
wenn
der
Igel
nach
jeder
Igelbewegung
gezeichnet
werden
soll.
Andernfalls
ergibt
sie
den
Wert
falsch
(FALSE).

Deklaration:
FUNCTION
IgelZeigen
:
BOOLEAN;

Beispiel:
MitIgel;
Write(IgelZeigen);druckt
TRUE,
OhneIgel;
Write(IgelZeigen);druckt
FALSE
aus.

≡≡LinkerBogen

Mit
LinkerBogen
beschreibt
der
Igel
einen
 Bogen
von
seiner
augenblicklichen
Position
und
Richtung
aus
nach
links
und
hinterläßt
dabei
eine
Spur,
wenn
die
Bewegung
mit
Stift
erfolgt.

Deklaration:
PROCEDURE
LinkerBogen(Radius,
Winkel
:
REAL);

Beispiel:
LinkerBogen(100,
45);Der
Igel
beschreibt
einen
 Bogen
nach
links
mit
einem
Radius
von
100
Schritten
und
einem
Winkel
von
45°.

≡≡ Links

Links(x)
veranlaßt
den
Igel,
sich
aus
seiner
augenblicklichen
Richtung
um
x
Grad
nach
links
zu
drehen.

Deklaration:
PROCEDURE
Links(Winkel
:
REAL);

Beispiel:
DreheAuf(0);Der
Igel
zeigt
nach
rechts.
Links(90);Der
Igel
zeigt
nach
oben.

≡≡Maßstab

Mit
der
Anweisung
Maßstab
wird
festgelegt,
mit
welchem
Faktor
die
in
GeheNach,
Vorne
und
Hinten
übergebenen
Werte
multipli-
ziert
werden.
Damit
ist
es
z.B.
möglich,
im
Heft
ein
Dreieck
zu
konstruieren
und
den
Igel
dieses
Dreieck
auf
dem
Bildschirm
zeichnen
zu
lassen,
ohne
jede
einzelne
Strecke
an
die
Schrittzahl
auf
dem
Bildschirm
anzupassen.

Deklaration:
PROCEDURE
Maßstab(MaßstabsFaktor
:
REAL);

Beispiel:
Maßstab(1);
Vorne(100);
Igel
1*100
Schritte
vorwärts
bewegen
Maßstab(50);
Vorne(1.5);
Igel
um
1.5*50=75
Schritte
vorwärts
bewegen

≡≡MitIgel

Nach
der
Anweisung
MitIgel
ist
der
Igel
sichtbar
und
wird
jeweils
nach
einer
Bewegung
neu
gezeichnet
bis
die
Anweisung
OhneIgel
ausgeführt
wird.
Durch
die
Funktion
IgelZeigen
läßt
sich
feststellen,
ob
der
Igel
gezeigt
wird.

Deklaration:
PROCEDURE
MitIgel;

Beispiel:
MitIgel;Igel
zeigen.
Vorne(100);
Igel
wegwischen,
100
Schritte
vorwärts
bewegen
und
neu
zeichnen.
OhneIgel;Igel
wegwischen
und
nicht
wieder
neu
zeichnen.
Vorne(100);
Igel
um
100
Schritte
vorwärts
bewegen,
ohne
ihn
zu
zeichnen.
Es
ist
nur
seine
Spur
sichtbar.

≡≡MitStift

Durch
MitStift
wird
festgelegt,
daß
die
Spur
des
Igels
gezeichnet
werden
soll.

Deklaration:
PROCEDURE
MitStift;

Beispiel:
OhneIgel;Igel
nicht
zeigen.
MitStift;Stift
absenken.
Vorne(100);
Igel
100
Schritte
vorwärts
bewegen
und
seine
Spur
zeichnen.
OhneStift;Stift
anheben.
Vorne(100);
Der
Igel
hinterläßt
keine
Spur.

≡≡OhneIgel

Nach
der
Anweisung
OhneIgel
ist
der
Igel
nicht
sichtbar.
Es
wird
aber
seine
Spur
gezeichnet,
wenn
die
Bewegung
mit
Stift
erfolgt.
Durch
die
Funktion
IgelZeigen
läßt
sich
feststellen,
ob
der
Igel
gezeigt
wird.

Deklaration:
PROCEDURE
OhneIgel;

Beispiel:
MitIgel;Igel
zeigen.
Vorne(100);
Igel
wegwischen,
100
Schritte
vorwärts
bewegen
und
neu
zeichnen.
OhneIgel;Igel
wegwischen
und
nicht
wieder
neu
zeichnen.
Vorne(100);
Igel
um
100
Schritte
vorwärts
bewegen,
ohne
ihn
zu
zeichnen.
Es
ist
nur
seine
Spur
sichtbar.

≡≡OhneStift

Durch
OhneStift
wird
festgelegt,
daß
die
Spur
des
Igels
nicht
gezeichnet
werden
soll.

Deklaration:
PROCEDURE
OhneStift;

Beispiel:
OhneIgel;Igel
nicht
zeigen.
MitStift;Stift
absenken.
Vorne(100);
Igel
100
Schritte
vorwärts
bewegen
und
seine
Spur
zeichnen.
OhneStift;Stift
anheben.
Vorne(100);
Der
Igel
hinterläßt
keine
Spur.

≡≡RechterBogen

Mit
RechterBogen
beschreibt
der
Igel
einen
 Bogen
von
seiner
augenblicklichen
Position
und
Richtung
aus
nach
rechts
und
hinterläßt
dabei
eine
Spur,
wenn
die
Bewegung
mit
Stift
erfolgt.

Deklaration:
PROCEDURE
RechterBogen(Radius,
Winkel
:
REAL);

Beispiel:
RechterBogen(100,
45);Der
Igel
beschreibt
einen
 Bogen
nach
rechts
mit
einem
Radius
von
100
Schritten
und
einem
Winkel
von
45°.

≡≡ Rechts

Rechts(x)
veranlaßt
den
Igel,
sich
aus
seiner
augenblicklichen
Richtung
um
x
Grad
nach
rechts
zu
drehen.

Deklaration:
PROCEDURE
Rechts(Winkel
:
REAL);

Beispiel:
DreheAuf(0);Der
Igel
zeigt
nach
rechts.
Rechts(90);Der
Igel
zeigt
nach
unten.

≡≡Ursprung

Die
Anweisung
Ursprung
entspricht
der
Anweisung
GeheNach(0,0)
und
bewegt
den
Igel
zum
Ursprung
seines
Koordinatensystems.
Er
zeigt
dabei
nach
oben.
Sein
Winkel
zur
positiven
x-Achse
beträgt
dann
90°.
Eine
Beschreibung
des
Koordinatensystems
ist
unter
GeheNach
zu
finden.

Deklaration:
PROCEDURE
Ursprung;

Beispiel:
Ursprung;plaziert
den
Igel
mitten
im
Grafikfenster.

≡≡Vorne

Durch
die
Anweisung
Vorne(x)
wird
der
Igel
x
Schritte
vorwärts
bewegt.
Wenn
die
Bewegung
mit
Stift
erfolgt,
ist
seine
Spur
anschließend
sichtbar.

Deklaration:
PROCEDURE
Vorne(Schritte
:
REAL);

Beispiel:
Vorne(50);
bewegt
den
Igel
50
Schritte
vorwärts.

≡≡WoIgelX

Durch
die
Funktion
WoIgelX
läßt
sich
die
x-Koordinate
des
Aufenthaltsortes
des
Igels
in
seinem
Koordinatensystem
feststellen.

Deklaration:
FUNCTION
WoIgelX
:
INTEGER;

Beispiel:
GeheNach(200,
100);
Write(WoIgelX);druckt
den
Wert
200.

≡≡WoIgelY

Durch
die
Funktion
WoIgelY
läßt
sich
die
y-Koordinate
des
Aufenthaltsortes
des
Igels
in
seinem
Koordinatensystem
feststellen.

Deklaration:
FUNCTION
WoIgelY
:
INTEGER;

Beispiel:
GeheNach(200,
100);
Write(WoIgelY);druckt
den
Wert
100.

≡≡Standard-Grafik

CircleGetMaxXGetMaxY
GetXGetYLine
LineToMoveTo

≡≡Circle

Circle
zeichnet
einen
Kreis
auf
dem
Bildschirm.
Da
bei
CGA-
und
Hercules-Karten
der
Abstand
zweier
benachbarter
Bildpunkte
in
x-
und
in
y-Richtung
verschieden
ist,
werden
die
y-Koordinaten
mit
einem
Korrekturfaktor
multipliziert.
(s.
auch
yKorrekturFaktor)

Deklaration:
PROCEDURE
Circle(xm,
ym,
Radius);

Beispiel:
Circle(50,
100,
30);
zeichnet
einen
Kreis
mit
dem
Mittelpunkt
M(50/100)
und
dem
Radius
r=30,
der
in
x-
Richtung
30
Bildpunkten
entspricht.

≡≡GetMaxX

GetMaxX
gibt
die
Anzahl
der
Bildpunkte
minus
eins
in
x-
Richtung
auf
dem
Grafikschirm
an.
ITG-PASCAL
verwendet
für
alle
Grafikkarten
einheitlich
640
Punkte
in
x-Richtung.

Deklaration:
FUNCTION
GetMaxX
:
INTEGER;

Beispiel:
Write(GetMaxX);druckt
639=640-1
für
alle
Grafik-
karten
aus.

≡≡GetMaxY

GetMaxY
gibt
die
Anzahl
der
Bildpunkte
minus
eins
in
y-
Richtung
auf
dem
Grafikschirm
an.

Deklaration:
FUNCTION
GetMaxY
:
INTEGER;

Beispiel:
Write(GetMaxY);druckt
199=200-1
für
CGA-Karten
347=348-1
für
Herculeskarten
349=350-1
für
EGA-Karten
479=480-1
für
VGA-Karten

≡≡GetX

GetX
liefert
die
x-Koordinate
des
Grafik-Cursors
zurück.

Deklaration:
FUNCTION
GetX
:
INTEGER;

Beispiel:
MoveTo(100,
50);
Write(GetX);druckt
100
aus.
LineTo(-200,
40);
Write(GetX);druckt
-200
aus.

≡≡GetY

GetY
liefert
die
y-Koordinate
des
Grafik-Cursors
zurück.

Deklaration:
FUNCTION
GetY
:
INTEGER;

Beispiel:
MoveTo(100,
50);
Write(GetY);druckt
50
aus.
LineTo(-200,
40);
Write(GetY);druckt
40
aus.

≡≡Line

Line(x1,y1,x2,y2)
zeichnet
eine
Strecke
zwischen
zwei
Punkten
P1(x1/y1)
und
P2(x2/y2)
auf
dem
Grafikschirm.
Der
Ursprung
des
Koordinatensystems
liegt
in
der
Mitte
des
Bildschirmfensters.
Die
Lage
des
Grafik-Cursors
wird
nicht
beeinflußt.

Deklaration:
PROCEDURE
Line(x1,
y1,
x2,
y2
:
INTEGER);

Beispiel:
Line(-100,
-30,
50,
80);zeichnet
die
Strecke
mit
den
Endpunkten
P1(-100/-30)
und
P2(50/80).

≡≡LineTo

LineTo(x,y)
verbindet
den
Punkt,
auf
dem
sich
der
Grafik-
Cursor
befindet,
mit
dem
 Punkt
P(x/y).
Anschließend
wird
der
Grafik-Cursor
auf
den
Punkt
P(x/y)
gesetzt.
(s.
auch
MoveTo)

Deklaration:
LineTo(x,
y
:
INTEGER);

Beispiel:
MoveTo(-100,
-30);
setzt
den
Grafik-Cursor
auf
P(-100/-30).
LineTo(50,
80);verbindet
P(-100/-30)
mit
Q(50/80)
und
setzt
den
Grafik-Cursor
auf
Q(50/80).
[Ergibt
das
gleiche
wie
Line(-100,-30,50,80)]
LineTo(0,
70);verbindet
Q(50/80)
mit
R(0/70).

≡≡MoveTo

ITG-PASCAL
hat
vier
verschiedene
Cursor
für
Text,
Standard-Grafik,
Igel-Grafik
und
Weltkoordinaten.
MoveTo
bewegt
den
Grafik-Cursor
an
eine
neue
Position.
Es
entspricht
den
Anweisungen
GeheNach
für
den
Igel
und
GotoXY
für
den
Text-Cursor.

Deklaration:
MoveTo(x,
y
:
INTEGER);

Beispiel:
MoveTo(-100,
-30);
setzt
den
Grafik-Cursor
auf
P(-100/-30).
LineTo(50,
80);verbindet
P(-100/-30)
mit
Q(50/80)
und
setzt
den
Grafik-Cursor
auf
Q(50/80).
MoveTo(-15,
-45);setzt
den
Grafik-Cursor
auf
R(-15/-45).
LineTo(0,
70);verbindet
R(-15/-45)
mit
S(0/70).

≡≡ITG-Pascal-Grafik


 BogenDefiniereWelt    DruckeBildschirm
FärbenFunktionsGraf    FunktionstermFehler
GrafGotoXYGrafikFenster    GrafikKorrekturAus
GrafikKorrekturEinGrafikSchirm
GrafWrite
KreisMitWeltRaster    OhneweltRaster
PapierFarbe PunktSetzeFontWerte
StiftFarbeStreckeTextSchirm
WähleFontWeltGeheNach
WeltPunkt
WeltStreckeWeltStreckeNachWischen
WoGrafikXWoGrafikYyKorrekturFaktor

≡≡ Bogen

Mit
Bogen
wird
ein
Kreisbogen
gezeichnet.

Deklaration:
PROCEDURE
Bogen(xm,
ym,
Radius,
AnfangsWinkel,
DrehWinkel
:
INTEGER);

Beispiel:
Bogen(0,
0,
100,
45,
90);
zeichnet
einen
Bogen,
der
auf
einem
Kreis
mit
dem
Mittelpunkt
M(0/0)
liegt
und
des-
sen
Radius
r=100
ist,
beginnend
bei
dem
Winkel
α=45°
zur
positiven
x-Achse,
wobei
das
Ende
des
Bogens
bei
ß=45°+90°=135°
liegt.

≡≡DefiniereWelt

Mit
DefiniereWelt
wird
ein
Koordinatensystem
gezeichnet,
in
dem
mit
den
Welt-Prozeduren
WeltPunkt,
WeltStrecke,
WeltGeheNach
und
WeltStreckeNach
orientiert
an
den
Koordinaten
des
Systems
gezeichnet
wird.
Die
geforder-
ten
Grenzen
des
Systems
werden
als
Minimum
angesehen.
ITG-PASCAL
zeichnet
das
kleinste
Koordinatensystem,
das
größer
ist
als
das
geforderte,
wobei
darauf
geachtet
wird,
daß
der
Rasterabstand
auf
den
Achsen
gleichmäßig
ist.
Auf
CGA-,
Herkules-
und
EGA-Karten
muß
dazu
vorher
der
Schalter
yKorrekturAus
gesetzt
werden.
Andernfalls
ergibt
sich
für
das
Raster
in
y-Richtung
keine
gleichmäßige
Einteilung.
Wenn
kein
Raster
gezeichnet
werden
soll,
ist
VORHER
die
Anweisung
OhneWeltRaster
auszuführen.

Deklaration:
PROCEDURE
DefiniereWelt(LinkeGrenze,
UntereGrenze,
RechteGrenze,
ObereGrenze
:
REAL);

Beispiel:

≡

yKorrekturAus;gleichmäßiges
Raster
MitWeltRaster;Punktraster
zeichnen,
wenn
eine
Welt
definiert
wird
DefiniereWelt(-5,
-2.5,
10,
4.5);Koordinatensystem
mit
-5,0
<=
x
<=
10,0
und
-2,5
<=
y
<=4,5
definieren
und
zeichnen
WeltStrecke(-3,
-2.2,
7.3,
3.4);Strecke
mit
den
Endpunkten
P(-3/-2,2)
und
Q(7,3/3,4)
zeichnen

≡≡DruckeBildschirm

Mit
DruckeBildschirm
wird
der
Inhalt
des
Bildschirm
sowohl
im
Textmodus
als
auch
im
Grafikmodus
mit
dem
Drucker
gedruckt.
Weil
bei
einem
Drucker
das
Längenverhältnis
von
Strecken
in
x-
und
y-Richtung
anders
ist
als
auf
dem
Bildschirm,
erscheinen
Kreise
als
Ellipsen
und
Quadrate
als
Rechtecke.

Deklaration:
PROCEDURE
DruckeBildschirm;

Beispiel:
GrafikSchirm;
ZeichneIrgendetwas;Hier
kann
eine
beliebige
Zeichnung
erstellt
werden.
DruckeBildschirm;Die
Zeichnung
wird
gedruckt.
TextSchirm;
SchreibeIrgendetwas;
Hier
kann
belieber
Text
geschrieben
werden.
DruckeBildschirm;Der
Text
wird
gedruckt.

≡≡Färben

Färben(x,y,Farbe)
färbt
einen
Bereich
beginnend
im
 Punkt
P(x/y)
in
der
Farbe
Farbe
ein,
der
von
einer
Linie
begrenzt
ist,
die
nicht
die
Papierfarbe
hat.
Als
Farben
sind
schwarz,
grau
und
weiß
zugelassen.

Deklaration:
PROCEDURE
Färben(x,
y,
Farbe
:
INTEGER);

Beispiel:

≡

PapierFarbe(Schwarz);
StiftFarbe(Weiß);
Kreis(100,
50,
30);
Färben(100,
50,
Grau);
Weil
der
Punkt
P(100/50)
innerhalb
des
Kreises
liegt,
wird
der
Kreis
grau
ausge-
füllt.
Für
einen
Punkt
auf
dem
Kreis
geschieht
nichts,
für
einen
Punkt
außerhalb
des
Kreises
wird
der
Bereich
außerhalb
grau
gefärbt.

≡≡FunktionsGraf

FunktionsGraf
zeichnet
den
Grafen
einer
Funktion
innerhalb
der
angegebenen
Grenzen.
Dabei
wird
versucht,
eine
gleichmäßige
Einteilung
der
Achsen
zu
erhalten.
Der
tatsächlich
gezeichnete
Ausschnitt
ist
etwas
größer
als
angegeben.
Zum
Zeichnen
wird
ein
Verfahren
benutzt,
das
pro
Bildpunkt
zwei
bis
drei
Funktionswerte
berechnet,
damit
auch
in
ungünstigen
Fällen
ein
vernünftiger
Funktionsgraf
entsteht.

ACHTUNG:
Die
unabhängige
Variable
ist
mit
"x"
festgelegt!

Deklaration:
PROCEDURE
FunktionsGraf(FunktionsTerm
:
STRING;
LinkeGrenze,
UntereGrenze,
RechteGrenze,
ObereGrenze
:
REAL);

Beispiel:

≡

GrafikKorrekturAus;gleichmäßiges
Raster
in
y-Richtung
FunktionsGraf("sin(x)",
-5,
-1.5,
5,
1.5);Graf
der
Sinus-Funktion
für
-5
<=
x
<=
5
und
-1.5
<=
y
<=
1.5

FunktionsGraf("sin(2x)",
-5,
-2,
5,
2);richtig
:
2*x
!
Write(FunktionstermFehler);ergibt
den
Wert
6,
weil
das
6.
Zeichen
fehler-
haft
ist.

≡≡FunktionstermFehler

Wenn
den
Prozeduren
FunktionsGraf
oder
DefiniereFunktionsterm
ein
fehlerhafter
Funktionsterm
übergeben
wurde,
ergibt
die
Funktion
FunktionstermFehler
die
Stelle,
an
der
der
Fehler
auftrat,
ansonsten
ergibt
sie
Null.

Deklaration:
FUNCTION
FunktionstermFehler
:
INTEGER;

Beispiel:
FunktionsGraf("sin(2x)",
-5,
-2,
5,
2);richtig
:
2*x
!
Write(FunktionstermFehler);ergibt
den
Wert
6,
weil
das
6.
Zeichen
fehlerhaft
ist.

≡≡GrafGotoXY

GrafGotoXY(x,y)
setzt
den
Grafikcursor
auf
den
 Punkt
P(x/y).
Für
die
Koordinaten
gelten
die
Werte
des
Koordinatensystems
im
Grafikmodus.
Der
Mittelpunkt
des
Bildschirms
hat
die
Koordinaten
(0/0).
Die
x-Werte
nehmen
nach
rechts
bis
320,
nach
links
bis
-320
zu,
die
y-Werte
nach
oben
je
nach
Grafikkarte
bis
240,
nach
unten
bis
-240.

Deklaration
:
PROCEDURE
GrafGotoXY(x,
y
:
WORD);

Beispiel
:
GrafGotoXY(0,
0);linker
oberer
Eckpunkt
GrafGotoXY(-320,
240);linker
oberer
Eckpunkt

≡≡GrafikFenster

Wenn
nur
ein
bestimmter
Bereich
des
Grafikschirms
für
eine
Zeichnung
verwendet
werden
soll,
kann
der
übrige
Bereich
gesperrt
werden.
Dazu
dient
die
Anweisung
GrafikFenster(x1,y1,x2,y2),
mit
der
ein
Rechteck
mit
bildschirmparallelen
Seiten
mit
dem
linken
oberen
Eckpunkt
P(x1/y1)
und
dem
rechten
unteren
Eckpunkt
Q(x2/y2)
als
Zeichenfläche
definiert
wird.
Der
Ursprung
des
Koordinatensystems
liegt
innerhalb
dieses
Fensters
automatisch
im
Mittelpunkt
des
Fensters.

Deklaration:
GrafikFenster(x1,
y1,
x2,
y2
:
INTEGER);

≡

Beispiel:
GrafikFenster(50,
20,
500,
220);
öffnet
ein
Fenster
mit
x-Werten
    zwischen
-225
und
225
und
y-Werten
    zwischen
-100
und
100.
Die
linke
    obere
Ecke
ist
in
x-Richtung
50
    Punkte,
in
y-Richtung
20
Punkte
von
    dem
linken
oberen
Eckpunkt
des
    Bildschirms
entfernt.

≡≡GrafikKorrekturAus

GrafikKorrekturAus
bewirkt,
daß
Punkt-
und
Strecken-Zeichnungen
nicht
mehr
den
Bildschirmverzerrungen
bei
CGA-,
Hercules-
und
EGA-Karten
angepaßt
werden.
Deshalb
stimmen
die
y-Koordinaten
für
Standardgrafik
und
für
Igelgrafik
bei
ausgeschalteter
Koorektur
nicht
mehr
überein.

Deklaration:
PROCEDURE
GrafikKorrekturAus;

Beispiel:

≡

GrafikKorrekturEin;    Korrektur
in
y-Richtung
einschalten
Circle(-105,
0,
100);Kreis
schlagen
Line(-105,
0,
-105,
100);Strecke
vom
Kreismittelpunkt
senkrecht
nach
oben
zeichnen.
Wegen
der
Korrektur
endet
sie
auf
der
Kreislinie.
GrafikKorrekturAus;    Korrektur
in
y-Richtung
ausschalten
Circle(105,
0,
100);Kreis
schlagen
Line(105,
0,
105,
100);Strecke
vom
Kreismittelpunkt
senkrecht
nach
oben
zeichnen.
Wegen
der
ausge-
schalteten
Korrektur
endet
sie
nicht
auf
der
Kreislinie.

≡≡GrafikKorrekturEin

GrafikKorrekturEin
bewirkt,
daß
Punkt-
und
Strecken-Zeichnungen
den
Bildschirmverzerrungen
angepaßt
werden.
Deshalb
stimmen
die
y-Koordinaten
für
Standardgrafik
und
für
Igelgrafik
jetzt
bei
allen
Grafikkarten
überein.

Deklaration:
PROCEDURE
GrafikKorrekturEin;

Beispiel:

≡

GrafikKorrekturEin;    Korrektur
in
y-Richtung
einschalten
Circle(-105,
0,
100);Kreis
schlagen
Line(-105,
0,
-105,
100);Strecke
vom
Kreismittelpunkt
senkrecht
nach
oben
zeichnen.
Wegen
der
Korrektur
endet
sie
auf
der
Kreislinie.
GrafikKorrekturAus;    Korrektur
in
y-Richtung
ausschalten
Circle(105,
0,
100);Kreis
schlagen
Line(105,
0,
105,
100);Strecke
vom
Kreismittelpunkt
senkrecht
nach
oben
zeichnen.
Wegen
der
ausge-
schalteten
Korrektur
endet
sie
nicht
auf
der
Kreislinie.

≡≡GrafikSchirm

Mit
der
Anweisung
GrafikSchirm
wird
aus
dem
Textmodus
in
den
Grafik-
modus
gewechselt.
ITG-PASCAL
erkennt
die
vorhandene
Grafikkarte
automatisch.
Grafikanweisungen
werden
nur
im
Grafikmodus
ausgeführt,
sonst
bricht
das
Programm
mit
der
Fehlermeldung
"Programm
wegen
Grafikanweisung
im
Textmodus
in
Zeile
xxx
beendet."
ab.

Deklaration:
PROCEDURE
GrafikSchirm;

Beispiel:

≡

GrafikSchirm;Zeichnen
im
Grafikmodus
ermöglichen.
Strecke(0,
0,
100,
100);Eine
Strecke
wird
gezeichnet.
WriteLn("im
Grafikmodus");
Auf
dem
Grafikschirm
wird
"im
Grafikmodus"
gedruckt.
TextSchirm;Zurück
in
den
Textmodus.
WriteLn("im
Textmodus");Auf
dem
Textschirm
wird
"im
Textmodus"
gedruckt.
Die
Textausgabe
erfolgt
hier
wesentlich
schneller
als
im
Grafikmodus.

≡≡GrafWrite

Mit
GrafWrite
erfolgt
die
Textausgabe
auf
dem
Grafikschirm
an
den
mit
GrafGotoXY
definierten
Koordinaten
des
Grafikschirms.
Es
gelten
die
selben
Bedingungen
wie
bei
der
Write-Anweisung
im
Textmodus.
ACHTUNG:
Vor
der
ersten
Verwendung
von
GrafWrite
muß
mit
"WähleFont"
========
ein
Zeichensatz
geladen
werden,
sonst
bricht
das
Programm
mit
einer
Fehlermeldung
ab.

Deklaration:
PROCEDURE
GrafWrite(v
:
VariableBeliebigenTyps);

Beispiel:

≡

GrafikSchirm;Schreiben
im
Grafikmodus
ermöglichen.
WähleFont("LITT");    Zeichensatz
laden
SetzeFontWerte(2,2,90);mit
doppelter
Schriftgröße
senkrecht
GrafWrite("senkrecht");nach
oben
"senkrecht"
schreiben.

≡≡Kreis

Kreis
zeichnet
einen
Kreis
auf
dem
Bildschirm.
Da
bei
CGA-,
Hercules-
und
EGA-Karten
der
Abstand
zweier
benachbarter
Bildpunkte
in
x-
und
in
y-Richtung
verschieden
ist,
werden
die
y-Koordinaten
mit
einem
Korrekturfaktor
multipliziert.
(s.
auch
yKorrekturFaktor)

Deklaration:
PROCEDURE
Kreis(xm,
ym,
Radius);

Beispiel:
Kreis(50,
100,
30);zeichnet
einen
Kreis
mit
dem
Mittelpunkt
M(50/100)
und
dem
Radius
r=30,
der
in
x-
Richtung
30
Bildpunkten
entspricht.

≡≡MitWeltRaster

MitWeltRaster
bewirkt,
daß
in
dem
mit
Definierewelt
definierten
Koordinatensystem
ein
Punktraster
gezeichnet
wird.
Das
Raster
kann
vor
der
Definition
der
Welt
mit
OhneWeltRaster
unterdrückt
werden.
Standardeinstellung
ist
MitWeltRaster.

Deklaration:
PROCEDURE
MitWeltRaster;

Beispiel:
yKorrekturAus;gleichmäßiges
Raster
MitWeltRaster;ein
Punktraster
zeichnen,
wenn
eine
Welt
definiert
wird
DefiniereWelt(-5,
-2.5,
10,
4.5);Koordinatensystem
mit
-5,0
<=
x
<=
10,0
und
-2,5
<=
y
<=4,5
definieren
und
zeichnen

≡≡OhneWeltRaster

OhneWeltRaster
bewirkt,
daß
in
dem
mit
Definierewelt
definierten
Koordinatensystem
kein
Punktraster
gezeichnet
wird.
Standardeinstellung
ist
MitWeltRaster.

Deklaration:
PROCEDURE
OhneWeltRaster;

Beispiel:
yKorrekturAus;gleichmäßiges
Raster
OhneWeltRaster;kein
Punktraster
zeichnen,
wenn
eine
Welt
definiert
wird
DefiniereWelt(-5,
-2.5,
10,
4.5);Koordinatensystem
mit
-5,0
<=
x
<=
10,0
und
-2,5
<=
y
<=4,5
definieren
und
zeichnen

≡≡PapierFarbe

Mit
PapierFarbe
wird
die
Farbe
des
Hintergrundes
für
alle
Grafikanwei-
sungen
festgesetzt.
Der
Hintergrund
wird
aber
erst
durch
die
Anweisung
Wischen
in
der
gewählten
Farbe
dargestellt.
Zur
Verfügung
stehen
die
Farben
Schwarz,
Grau
und
Weiß.
Andere
Werte
sind
nicht
zugelassen.

Deklaration:
PROCEDURE
PapierFarbe(Farbe
:
INTEGER);

Beispiel:
PapierFarbe(Schwarz);
Wischen;Der
Hintergrund
erscheint
schwarz.
PapierFarbe(Grau);
Wischen;Der
Hintergrund
erscheint
grau.
PapierFarbe(Weiß);
Wischen;Der
Hintergrund
erscheint
weiß.

≡≡ Punkt

Mit
der
Anweisung
Punkt(x,
y)
wird
der
Punkt
P(x/y)
auf
dem
Grafikschirm
gezeichnet.
Der
Ursprung
des
Achsenkreuzes
liegt
in
der
Mitte
des
Grafikfensters.

Deklaration:
PROCEDURE
Punkt(x,
y
:
INTEGER);

Beispiel:
Punkt(100,
50);
zeichnet
den
Punkt
P(100/50).

≡≡SetzeFontWerte

Nachdem
mit
WähleFont
ein
Vektor-Zeichensatz
geladen
wurde,
kann
mit
SetzeFontWerte
sowohl
die
Größe
der
Buchstaben
in
beiden
Richtungen
als
auch
die
Schreibrichtung
verändert
werden.
Die
Richtung
wird
als
Winkel
gegen
den
Uhrzeigersinn
zur
positiven
x-Achse
in
Grad
gemessen.

Deklaration:
PROCEDURE
SetzeFontWerte(xGröße,
yGröße,
Richtung
:
REAL);

Beispiel:
GrafikSchirm;Schreiben
im
Grafikmodus
ermöglichen.
WähleFont("LITT");    Zeichensatz
laden
SetzeFontWerte(2,2,90);mit
doppelter
Schriftgröße
senkrecht
GrafWrite("senkrecht");nach
oben
"senkrecht"
schreiben.

≡≡StiftFarbe

Mit
StiftFarbe
wird
die
Farbe
des
Zeichenstiftes
für
alle
Grafik-
anweisungen
festgesetzt,
die
keine
Farbe
als
Parameter
enthalten.
Zur
Verfügung
stehen
die
Farben
Schwarz,
Grau
und
Weiß.
Andere
Werte
sind
nicht
zugelassen.

Deklaration:
PROCEDURE
StiftFarbe(Farbe
:
INTEGER);

Beispiel:
StiftFarbe(Grau);Zeichenfarbe
Grau
festlegen.
Strecke(0,
0,
100,
50);Weil
nicht
jeder
 Punkt
gezeichnet

wird,
erscheint
die
Strecke
in
ihrer

Farbe
nicht
so
intensiv,
also
grau.

≡≡Strecke

Strecke(x1,y1,x2,y2)
zeichnet
eine
Strecke
zwischen
zwei
Punkten
P1(x1/y1)
und
P2(x2/y2)
auf
dem
Grafikschirm.
Der
Ursprung
des
Koordinatensystems
liegt
in
der
Mitte
des
Bildschirmfensters.

Deklaration:
PROCEDURE
Strecke(x1,
y1,
x2,
y2
:
INTEGER);

Beispiel:
Strecke(-100,
-30,
50,
80);zeichnet
die
Strecke
mit
den
Endpunkten
P1(-100/-30)
und
P2(50/80).

≡≡TextSchirm

Mit
der
Anweisung
TextSchirm
wird
aus
dem
Grafikmodus
zurück
in
den
Textmodus
gewechselt.

Deklaration:
PROCEDURE
TextSchirm;

Beispiel:
GrafikSchirm;Zeichnen
im
Grafikmodus
ermöglichen.
Strecke(0,
0,
100,
100);Eine
Strecke
wird
gezeichnet.
WriteLn("im
Grafikmodus");
Auf
dem
Grafikschirm
wird
"im
Grafikmodus"
gedruckt.
TextSchirm;Zurück
in
den
Textmodus.
WriteLn("im
Textmodus");Auf
dem
Textschirm
wird
"im
Textmodus"
gedruckt.
Die
Textausgabe
erfolgt
hier
wesentlich
schneller
als
im
Grafikmodus.


≡≡WähleFont

Bevor
auf
dem
Grafikschirm
mit
GrafWrite
geschrieben
werden
kann,
muß
mit
WähleFont
ein
Vektor-Zeichensatz
nach
BORLAND-Standard
geladen
worden
sein.
Mitgeliefert
werden
die
Zeichensätze
"LITT.CHR",
"GOTH.CHR",
"SANS.CHR"
und
"TRIP.CHR".
Weitere
Zeichensätze
sind
von
der
Firma
BORLAND
oder
im
Bereich
Shareware/Public
Domain
zu
bekommen.
Nach
dem
erfolgreichen
Laden
eines
Zeichensatzes
werden
automatisch
Standardwerte
mit
SetzeFontWerte(1,
1,
0)
gesetzt.

Deklaration:
PROCEDURE
WähleFont(FontName
:
STRING);

Beispiel:
GrafikSchirm;Schreiben
im
Grafikmodus
ermöglichen.
WähleFont("LITT");    Zeichensatz
laden
SetzeFontWerte(2,2,90);mit
doppelter
Schriftgröße
senkrecht
GrafWrite("senkrecht");nach
oben
"senkrecht"
schreiben.

≡≡WeltGeheNach

WeltGeheNach
setzt
den
Weltcursor
auf
die
angegebenen
Koordinaten
des
mit
DefiniereWelt
definierten
Koordinatensystems.
Mit
WeltStreckeNach
wird
dieser
 Punkt
mit
einem
zweiten
verbunden.

Deklaration:
PROCEDURE
WeltGeheNach(x,
y
:
REAL);

Beispiel:
yKorrekturAus;gleichmäßiges
Raster
DefiniereWelt(-5,
-2.5,
10,
4.5);Koordinatensystem
mit
-5,0
<=
x
<=
10,0
und
-2,5
<=
y
<=4,5
definieren
und
zeichnen
WeltGeheNach(-3,
-2.2,
7.3,
3.4);Weltcursor
auf
P(-3/-2,2)
setzen


≡≡WeltPunkt

WeltPunkt
zeichnet
einen
 Punkt
in
dem
mit
Definierewelt
definierten
Koordinatensystem.

Deklaration:
PROCEDURE
WeltPunkt(x,
y
:
REAL);

Beispiel:
DefiniereWelt(-5,
-2.5,
10,
4.5);Koordinatensystem
mit
-5,0
<=
x
<=
10,0
und
-2,5
<=
y
<=4,5
definieren
und
zeichnen
WeltPunkt(-3,
-2.2);zeichnet
den
Punkt
P(-3/-2,2)

≡≡WeltStrecke

WeltStrecke
verbindet
die
beiden
mit
ihren
x-
und
y-Koordinaten
angegebenen
Punkte
in
dem
mit
DefiniereWelt
definierten
Koordinatensystem.

Deklaration:
PROCEDURE
WeltStrecke(x1,
y1,
x2,
y2
:
REAL);

Beispiel:
yKorrekturAus;gleichmäßiges
Raster
DefiniereWelt(-5,
-2.5,
10,
4.5);Koordinatensystem
mit
-5,0
<=
x
<=
10,0
und
-2,5
<=
y
<=4,5
definieren
und
zeichnen
WeltStrecke(-3,
-2.2,
7.3,
3.4);Strecke
mit
den
Endpunkten
P(-3/-2,2)
und
Q(7,3/3,4)
zeichnen

≡≡WeltStreckeNach

WeltStreckeNach
verbindet
den
angegebenen
 Punkt
mit
dem
Punkt
in
dem
mit
DefiniereWelt
definierten
Koordinatensystem,
auf
dem
sich
der
Weltcursor
befindet.
Der
Weltcursor
wird
anschließend
auf
den
angegebenen
Punkt
gesetzt.

Deklaration:
PROCEDURE
WeltStreckeNach(x,
y
:
REAL);

Beispiel:

≡

yKorrekturAus;gleichmäßiges
Raster
DefiniereWelt(-5,
-2.5,
10,
4.5);Koordinatensystem
mit
-5,0
<=
x
<=
10,0
und
-2,5
<=
y
<=4,5
definieren
und
zeichnen
WeltGeheNach(-3,
-2.2);Weltcursor
auf
P(-3/-2,2)
setzen
WeltStreckeNach(7.3,
3.4);    P(-3/-2,2)
und
Q(7,3/3,4)
verbinden
WeltStreckeNach(-1.3,
0.4);Q(7,3/3,4)
und
R(-1,3/0,4)
verbinden

≡≡Wischen

Mit
Wischen
wird
das
aktive
Grafikfenster
gelöscht.
Die
Farbe
des
Hintergrundes
kann
vorher
mit
PapierFarbe
eingestellt
werden.

Deklaration:
PROCEDURE
Wischen;

Beispiel:
PapierFarbe(Schwarz);
Wischen;Der
Hintergrund
erscheint
schwarz.
PapierFarbe(Grau);
Wischen;Der
Hintergrund
erscheint
grau.
PapierFarbe(Weiß);
Wischen;Der
Hintergrund
erscheint
weiß.

≡≡WoGrafikX

WoGrafikX
liefert
die
x-Koordinate
des
Grafik-Cursors
zurück.

Deklaration:
FUNCTION
WoGrafikX
:
INTEGER;

Beispiel:
MoveTo(100,
50);
Write(WoGrafikX);druckt
100
aus.
LineTo(-200,
40);
Write(WoGrafikX);druckt
-200
aus.

≡≡WoGrafikY

WoGrafikY
liefert
die
y-Koordinate
des
Grafik-Cursors
zurück.

Deklaration:
FUNCTION
WoGrafikY
:
INTEGER;

Beispiel:
MoveTo(100,
50);
Write(WoGrafikY);druckt
50
aus.
LineTo(-200,
40);
Write(WoGrafikY);druckt
40
aus.

≡≡yKorrekturFaktor

Bei
CGA-,
Hercules-
und
EGA-Grafikkarten
stimmen
die
Abstände
zweier
benachbarter
Punkte
in
x-
und
y-Richtung
auf
dem
Monitor
nicht
über-
ein.
Ohne
Korrektur
würde
ein
Kreis
wie
eine
Ellipse
und
ein
Quadrat
wie
ein
Rechteck
aussehen.
Um
so
etwas
zu
vermeiden,
werden
die
Strecken
in
y-Richtung
verkürzt
um
einen
Faktor,
dessen
Wert
die
Funktion
yKorrekturFaktor
zurückliefert.

Deklaration:
FUNCTION
yKorrekturFaktor
:
REAL;

Beispiel:
Write(yKorrekturFaktor);
druckt

0.42
für
CGA-Karten

0.64
für
Hercules-Karten

0.73
für
EGA-Karten

1.00
für
VGA-Karten

≡≡mathematische·Funktionen

ABSARCCOSARCCOTARCSINARCTANBOGENMAß
COSCOTEXP GRADLGLN
SIGNSINSQRSQRTTAN

≡≡ABS

Mit
ABS(x)
wird
der
Betrag
einer
Zahl
bestimmt.

Deklaration:
FUNCTION
ABS(Zahl
:
REAL)
:
REAL;

Beispiel:
ABS(-3.5)
=
3.5;ABS(-2)
=
2;ABS(4.7)
=
4.7

≡≡ARCCOS

α=ArcCos(x)
ist
die
Umkehrfunktion
zu
x=Cos(α).
α=ArcCos(x)
ist
der
Winkel
α,
für
den
gilt
x=Cos(α).

Deklaration:
FUNCTION
ArcCos(Winkel
:
REAL)
:
REAL;

Beispiel:
in
Grad:ArcCos(0.5)
=
60°
im
Bogenmaß:ArcCos(0.5)
=
1.047

Durch
die
Schalter
"InGrad"
und
"ImBogenmaß"
wird
festgelegt,
ob
die
Berechnung
mit
Winkeln
in
Grad
oder
im
Bogenmaß
durchgeführt
wird.

≡≡ARCCOT

α=ArcCot(x)
ist
die
Umkehrfunktion
zu
x=Cot(α).
α=ArcCot(x)
ist
der
Winkel
α,
für
den
gilt
x=Cot(α).

Deklaration:
FUNCTION
ArcCot(Winkel
:
REAL)
:
REAL;

Beispiel:
in
Grad:ArcCot(0.5)
=63.435°
im
Bogenmaß:ArcCot(0.5)
=1.107

Durch
die
Schalter
"InGrad"
und
"ImBogenmaß"
wird
festgelegt,
ob
die
Berechnung
mit
Winkeln
in
Grad
oder
im
Bogenmaß
durchgeführt
wird.

≡≡ARCSIN

α=ArcSin(x)
ist
die
Umkehrfunktion
zu
x=Sin(α).
α=ArcSin(x)
ist
der
Winkel
α,
für
den
gilt
x=Sin(α).

Deklaration:
FUNCTION
ArcSin(Winkel
:
REAL)
:
REAL;

Beispiel:
in
Grad:ArcSin(0.5)
=
30°
im
Bogenmaß:ArcSin(0.5)
=
0.524

Durch
die
Schalter
"InGrad"
und
"ImBogenmaß"
wird
festgelegt,
ob
die
Berechnung
mit
Winkeln
in
Grad
oder
im
Bogenmaß
durchgeführt
wird.

≡≡ARCTAN

α=ArcTan(x)
ist
die
Umkehrfunktion
zu
x=Tan(α).
α=ArcTan(x)
ist
der
Winkel
α,
für
den
gilt
x=Tan(α).

Deklaration:
FUNCTION
ArcTan(Winkel
:
REAL)
:
REAL;

Beispiel:
in
Grad:ArcTan(0.5)
=
26.565°
im
Bogenmaß:ArcTan(0.5)
=0.464

Durch
die
Schalter
"InGrad"
und
"ImBogenmaß"
wird
festgelegt,
ob
die
Berechnung
mit
Winkeln
in
Grad
oder
im
Bogenmaß
durchgeführt
wird.

≡≡BOGENMAß

Die
Funktion
y=Bogenmaß(α)
ergibt
das
Bogenmaß
des
Winkels
α,
der
in
Grad
gegeben
ist.

Deklaration:
FUNCTION
Bogenmaß(WinkelInGrad
:
REAL)
:
REAL;

Beispiel:
Bogenmaß(60°)
=
π/3
Bogenmaß(Grad(π/3))
=
π/3

≡≡COS

Der
Cos(α)
ist
die
Länge
der
Ankathete
eines
rechtwinkligen
Dreiecks
mit
der
Hypotenusenlänge
1.
Er
gibt
für
beliebige
rechtwinklige
Dreiecke
das
Verhältnis
von
Ankathete
zu
Hypotenuse
an.

Deklaration:
FUNCTION
Cos(Winkel
:
REAL)
:
REAL;

Beispiel:
in
Grad:Cos(60°)
=
0.5
im
Bogenmaß:Cos(π/3)
=
0.5

Durch
die
Schalter
"InGrad"
und
"ImBogenmaß"
wird
festgelegt,
ob
die
Berechnung
mit
Winkeln
in
Grad
oder
im
Bogenmaß
durchgeführt
wird.

≡≡COT

Die
Funktion
y=Cot(α)
gibt
in
einem
rechtwinkligen
Dreieck
das
Seitenverhältnis
von
Ankathete
zu
Gegenkathete
an.

Deklaration:
FUNCTION
Cot(Winkel
:
REAL)
:
REAL;

Beispiel:
in
Grad:Cot(60°)
=
0.577
im
Bogenmaß:Cot(π/3)
=
0.577

Durch
die
Schalter
"InGrad"
und
"ImBogenmaß"
wird
festgelegt,
ob
die
Berechnung
mit
Winkeln
in
Grad
oder
im
Bogenmaß
durchgeführt
wird.

≡≡EXP

y=Exp(x)=e^x
ist
die
Exponentialfunktion
mit
der
Basis
e.
e
bezeichnet
die
Eulersche
Zahl
2.718281828...
.

Deklaration:
FUNCTION
Exp(x
:
REAL)
:
REAL;

Beispiel:
Exp(1)
=
2.71828
Exp(-4.1)
=
0.0167
Exp(Ln(4))
=
4

≡≡ GRAD

α=Grad(x)
ergibt
den
zu
dem
Bogen
x
des
Einheitskreises
gehörenden
Winkel
α,
rechnet
also
den
Winkel
x
im
Bogenmaß
in
Grad
um.

Deklaration:
FUNCTION
Grad(WinkelImBogenmaß
:
REAL)
:
REAL;

Beispiel:
Grad(
π/3
)
=
60°
Grad( Bogenmaß(60°)
)
=
60°

≡≡LG

y=Lg(x)
ist
der
Logarithmus
von
x
zur
Basis
10,
auch
dekadischer
Logarithmus
genannt.
Lg(x)
ist
die
Umkehrfunktion
zu
10^x
und
nur
für
x
>
0
definiert.

Deklaration:
FUNCTION
Lg(x
:
REAL)
:
REAL;

Beispiel:
Lg(0.5)
=
-0.301
Lg(3.3)
=
0.519
Lg(10)
=
1
Lg(10^5.7)
=
5.7
Lg(-2)
ist
nicht
definiert

≡≡LN

y=Ln(x)
ist
der
Logarithmus
von
x
zur
Basis
e,
auch
natürlicher
Logarithmus
genannt.
Ln(x)
ist
die
Umkehrfunktion
zu
Exp(x)
und
nur
für
x
>
0
definiert.

Deklaration:
FUNCTION
Ln(x
:
REAL)
:
REAL;

Beispiel:
Ln(0.5)
=
-0.693
Ln(3.3)
=
1.194
Ln(e)
=
1
Ln(Exp(5.7))
=
5.7
Ln(-2)
ist
nicht
definiert

≡≡SIGN

Die
Signumfunktion
y=Sign(x)
ist
definiert
als:
1,
wenn
x
>
0
0,
wenn
x
=
0
-1,
wenn
x
<
0

Deklaration:
FUNCTION
Sign(x
:
REAL)
:
INTEGER;

Beispiel:
Sign(3.5)
=
1
Sign(0)
=
0
Sign(-4)
=
-1

≡≡SIN

Der
Sin(α)
ist
die
Länge
der
Gegenkathete
eines
rechtwinkligen
Dreiecks
mit
der
Hypotenusenlänge
1.
Er
gibt
für
beliebige
rechtwinklige
Dreiecke
das
Verhältnis
von
Gegenkathete
zu
Hypotenuse
an.

Deklaration:
FUNCTION
Sin(Winkel
:
REAL)
:
REAL;

Beispiel:
in
Grad:Sin(60°)
=
0.866
im
Bogenmaß:Sin(π/3)
=
0.866

Durch
die
Schalter
"InGrad"
und
"ImBogenmaß"
wird
festgelegt,
ob
die
Berechnung
mit
Winkeln
in
Grad
oder
im
Bogenmaß
durchgeführt
wird.

≡≡SQR

y=Sqr(x)=x^2
ist
das
Quadrat
der
Zahl
x.
Sqr
steht
für
die
englische
Abkürzung
von
Quadrat
"Square".

Deklaration:
FUNCTION
Sqr(x
:
REAL)
:
REAL;

Beispiel:
Sqr(2)
=
4
Sqr(Sqrt(2))
=
2

≡≡SQRT

y=Sqrt(x)
ist
die
positive
Zahl
y,
deren
Quadrat
x
ergibt.
Sqrt
ist
also
die
Wurzelfunktion.
y=Sqrt(x)
ist
die
Umkehrfunktion
zu
y=Sqr(x).
Sqrt
steht
für
die
englische
Abkürzung
von
Wurzel
"SquareRoot".
Sqrt(x)
ist
definiert
für
x
≥
0.

Deklaration:
FUNCTION
Sqrt(x
:
REAL)
:
REAL;

Beispiel:
Sqrt(4)
=
2
Sqrt(Sqr(2))
=
2
Sqrt(-4)
ist
nicht
definiert.

≡≡TAN

Die
Funktion
y=Tan(α)
gibt
in
einem
rechtwinkligen
Dreieck
das
Seitenverhältnis
von
Gegenkathete
zu
Ankathete
an.

Deklaration:
FUNCTION
Tan(Winkel
:
REAL)
:
REAL;

Beispiel:
in
Grad:Tan(60°)
=
1.732
im
Bogenmaß:Tan(π/3)
=
1.732

Durch
die
Schalter
"InGrad"
und
"ImBogenmaß"
wird
festgelegt,
ob
die
Berechnung
mit
Winkeln
in
Grad
oder
im
Bogenmaß
durchgeführt
wird.

≡≡Standard-Funktionen

ABSARCTAN    CHRCOPYCOS
EOFEXPFilePosFileSizeFRAC
GetMaxXGetMaxYIORESULTINTKeyPressed
LNLENGTH    ODDORDPOS
PREDRandom    ReadKeyROUND
SIN
SQRSQRTSTRSUCCTRUNC
UpCase    WhereX    WhereY

≡≡CHR

Mit
der
Funktion
CHR
wird
eine
Typ-Umwandlung
einer
INTEGER-Zahl
aus
dem
Bereich
0..255
in
einen
Buchstaben
durchgeführt.

Deklaration
:
FUNCTION
CHR(OrdnungsZahl
:
INTEGER)
:
CHAR;

Beispiel
:
Write(CHR(65));druckt
"A",
weil
"A"
den
ASCII-Code
65
hat.
Write(CHR(ORD("B")));druckt
"B".

≡≡COPY

Copy(ZeichenKette,
Anfang,
Anzahl)
liefert
als
Funktionswert
den
Teil
von
ZeichenKette
zurück,
der
bei
dem
Buchstabenindex
Anfang
beginnt
und
Anzahl
Zeichen
umfaßt.

Deklaration
:
FUNCTIONCopy(ZeichenKette
:
STRING;
Anfang,
Anzahl
:
INTEGER)
:
STRING;

Beispiel
:
Write(Copy("abcdefgh",
3,
4));druckt
"cdef".
Write(Copy("abcdefgh",
7,
9));druckt
"gh".
Wenn
am
Ende
der
    Zeichenkette
weniger
Buchstaben
    vorhanden
sind
als
in
Anzahl
an-
    gegeben,
werden
nur
die
noch
    vorhandenen
zurückgegeben.

≡≡FilePos

FilePos(Dateivariable)
gibt
den
Index
des
Datensatzes
aus,
an
dessen
Ende
der
Lesezeiger
in
der
Datei
Dateivariable
steht.

Deklaration
:
FUNCTION
FilePos(f
:
FILE
OF
Datenstruktur)
:
WORD;

Beispiel
:
TYPE
    DatenStruktur
=
RECORD
x
:
INTEGER;
s
:
STRING[20];
    END;

≡

VAR
    Daten
:
DatenStruktur;
    f
:
FILE
OF
DatenStruktur;
BEGIN
    Assign(f,
"TEST.DAT");der
Datei
einen
Namen
zuweisen
    Reset(f);und
zum
Lesen
öffnen
    Seek(f,
3);Zeiger
auf
das
Ende
des
3.Datensatzes
    Read(f,
Daten);    4.Datensatz
lesen!!!!
    Write(FilePos(f));druckt
den
Wert
4
aus!!!
    Close(f);Datei
schließen
END;

≡≡FileSize

FileSize(Dateivariable)
gibt
an,
wieviele
Datensätze
in
einer
Datei
enthalten
sind.

Deklaration
:
FUNCTION
FileSize(f
:
FILE
OF
Datenstruktur)
:
WORD;

Beispiel
:
TYPE
    DatenStruktur
=
RECORD
x
:
INTEGER;
s
:
STRING[20];
    END;

≡

VAR
    Daten
:
DatenStruktur;
    f
:
FILE
OF
DatenStruktur;
BEGIN
    Assign(f,
"TEST.DAT");der
Datei
einen
Namen
zuweisen
    Reset(f);und
zum
Lesen
öffnen
    Write(FileSize(f));druckt
aus,
wieviele
Records
des
Typs
DatenStruktur
in
der
Datei
TEST.DAT
enthalten
sind
    Close(f);Datei
schließen
END;

≡≡FRAC

Mit
Frac
wird
der
Nachkommateil
einer
Variable
des
Typs
REAL
bestimmt
und
als
Funktionswert
zurückgegeben.

Deklaration
:
FUNCTION
Frac(DezimalZahl
:
REAL)
:
REAL;

Beispiel
:
Write(Frac(2.561));druckt
0.561
aus.

≡≡EOF

Mit
EOF(Datei)
kann
festgestellt
werden,
ob
beim
Lesen
einer
Datei
das
Ende
erreicht
wurde.
In
diesem
Fall
ergibt
EOF(Datei)
den
Wert
WAHR
(TRUE).
Die
Datei
darf
dabei
vom
Typ
FILE
oder
vom
Typ
 TEXT
sein.

Deklaration
:
FUNCTION
EOF(t
:
 TEXT)
:
BOOLEAN;
FUNCTION
EOF(f
:FILE)
:
BOOLEAN;

≡

Beispiel
:
VAR
    t
:
 TEXT;
    s
:STRING;
BEGIN
    Assign(t,
'ITG.HLP');Datei
öffnen
    Reset(t);Lesemarke
auf
den
Anfang
setzen
    WHILE
NOT
EOF(t)
DO
BEGINsolange
es
noch
weiteren
Text
gibt,
ReadLn(t,
s);diesen
aus
der
Datei
lesen
und
WriteLn(s);auf
dem
Bildschirm
ausgeben
    END;
    Close(t);Datei
schließen
END;

≡≡IORESULT

Wenn
Datensätze
von
der
Diskette/Festplatte
gelesen
oder
auf
der
Diskette/Festplatte
geschrieben
werden,
kann
mit
einem
anschließenden
Aufruf
von
IOResult
geprüft
werden,
ob
der
Lese-/Schreibvorgang
fehler-
frei
verlaufen
ist
oder
nicht.
IOResult
ergibt
nach
fehlerfreien
Lese-/Schreibzugriffen
den
Wert
0,
sonst
einen
Wert
>
0.

Deklaration
:
FUNCTION
IOResult
:
INTEGER;

Beispiel
:
Write(Datei,
Datensatz);
IF
IOResult
=
0
THEN
BEGIN
Write("kein
Fehler2);
END
ELSE
BEGIN
Write("Fehler
beim
Schreiben
des
Datensatzes");
END;
≡≡INT

Mit
Int
wird
der
Vorkommateil
einer
Variablen
des
Typs
REAL
bestimmt
und
als
Funktionswert
zurückgegeben.

Deklaration
:
FUNCTION
Int(DezimalZahl
:
REAL)
:
REAL;

Beispiel
:
Write(Int(12.561));druckt
12.000
aus.

≡≡KeyPressed

Mit
der
Funktion
KeyPressed
wird
festgestellt,
ob
vor
dem
Zeitpunkt
des
Aufrufs
eine
Taste
gedrückt
wurde,
die
noch
nicht
durch
eine
Read-Anweisung
eingelesen
wurde.

Deklaration
:
FUNCTION
KeyPressed
:
BOOLEAN;

Beispiel
:
Read(c);Alle
vorhandenen
Tastendrücke
einlesen.
GrafikSchirm;
REPEAT
    ZeichneIrgendEtwas;Solange
die
Zeichnung
wiederholen,
bis
UNTIL
KeyPressed;eine
beliebige
Taste
gedrückt
wird.

≡≡LENGTH

Length(ZeichenKette)
ergibt
die
Anzahl
der
Buchstaben
(Länge)
von
ZeichenKette.

Deklaration
:
FUNCTION
Length(ZeichenKette
:
STRING)
:
INTEGER;

Beispiel
:
Write(Length("abcdefgh"));druckt
den
Wert
8
aus.
Write(Length(""));
ergibt
0,
weil
die
Zeichenkette
leer
ist.

≡≡ODD

Odd(GanzeZahl)
prüft,
ob
GanzeZahl
gerade
ist
oder
nicht.
Es
handelt
sich
um
eine
Aussage.
Der
Funktionswert
ist
demnach
vom
Typ
BOOLEAN.

Deklaration
:
FUNCTION
Odd(GanzeZahl
:
INTEGER)
:
BOOLEAN;

Beispiel
:
IF
Odd(GanzeZufallsZahl(100))
THEN
BEGIN
    Write("Zufallszahl
ist
gerade.");
END
ELSE
BEGIN
    Write("Zufallszahl
ist
ungerade.");
END;

≡≡ORD

Die
Funktion
Ord(Variable)
(Ordnung)
liefert
bei
einem
Aufzählungstyp
die
Stelle,
an
der
Variable
in
diesem
Typ
definiert
ist,
wobei
die
erste
vorkommende
Variable
immer
die
Ordnung
0
hat.

Deklaration
:
FUNCTION
Ord(Variable
:
Aufzählungstyp)
:
INTEGER;

Beispiel
:
Ord("A");ergibt
65,
weil
der
Buchstabe
"A"

an
66.
(!)
Stelle
in
der

ASCII-Tabelle
steht.
TYPE
    Farbe
=
(Schwarz,
Grau,
Weiß);Aufzählungstyp
Farbe
definieren.
Ord(Schwarz);ergibt
0.
Ord(Grau);ergibt
1.
Ord(Weiß);ergibt
2.

≡≡POS

Pos(TeilZeichenKette,
ZeichenKette)
ergibt
die
Stelle,
an
der
TeilZeichenKette
in
ZeichenKette
beginnt.
Wenn
TeilZeichenKette
nicht
in
ZeichenKette
enthalten
ist,
ist
der
Funktionswert
0.

Deklaration
:
FUNCTIONPos(TeilZeichenKette,
ZeichenKette
:
STRING)
:
INTEGER;

Beispiel
:
Pos("c",
"abcdefgh");ist
3.
Pos("def",
"abcdefgh");ist
4.
Pos("B",
"abcdefgh");ist
0,
weil
"B"
nicht
in
"abcdefgh"
vorkommt.

≡≡PRED

Pred(Variable)
ergibt
den
Vorgänger
von
Variable,
wenn
es
sich
um
einen
Aufzählungstyp
handelt.
(s.
auch
Ord,
Succ)

Deklaration
:
FUNCTION
Pred(Variable
:
Aufzählungstyp)
:
Aufzählungstyp;

Beispiel
:
Pred(3);ist
2.
Pred("B");ist
"A",
weil
"A"
in
der
ASCII-

Tabelle
der
Vorgänger
von
"B"

ist.
TYPE
    Farbe
=
(Schwarz,
Grau,
Weiß);Aufzählungstyp
Farbe
definieren.
Pred(Schwarz);ist
nicht
definiert.
Pred(Grau);ergibt
Schwarz.
Pred(Weiß);ergibt
Grau.

≡≡Random

Random(ObereGrenze)
erzeugt
eine
ganze
Zufallszahl
zwischen
0
und
ObereGrenze-1!
Der
Wert
für
ObereGrenze
muß
zwischen
0
und
32768
liegen.

Deklaration
:
FUNCTION
Random(ObereGrenze
:
WORD)
:
WORD;

Beispiel
:
Write(Random(100));druckt
eine
Zufallszahl
zwischen
0
und
99!

≡≡ReadKey

Mit
ReadKey
wird
eine
Taste
gelesen,
ohne
daß
die
Eingabe
mit
der
RETURN-
(ENTER-)
Taste
abgeschlossen
werden
muß.

Deklaration
:
FUNCTION
ReadKey
:
CHAR;

Beispiel
:
Write("noch
einmal
(j/n)
:");Meldung
ausgeben.
REPEATSolange
das
Einlesen
von
    CharVariable
:=
UpCase(ReadKey);Zeichen
wiederholen,
bis
UNTIL
(CharVariable
=
"J")
der
Großbuchstabe
der

OR
(CharVariable
=
"N");    gedrückten
Taste
"J"
oder
"N"
ist.

≡≡ROUND

Durch
Round
wird
eine
Variable
des
Typs
REAL
in
eine
Variable
des
Typs
INTEGER
umgewandelt.
Dabei
wird
im
Gegensatz
zu
Trunc
auf-
oder
abgerundet.

Deklaration
:
FUNCTION
Round(RealVariable
:
REAL)
:
INTEGER;

Beispiel
:
Round(3.2);ergibt
3.
Round(3.8);ergibt
4.
Round(-3.2);ergibt
-3.
Round(-3.8);ergibt
-4.

≡≡SUCC

Succ(Variable)
ergibt
den
Nachfolger
von
Variable,
wenn
es
sich
um
einen
Aufzählungstyp
handelt.
(s.
auch
Ord,
Pred)

Deklaration
:
FUNCTION
Succ(Variable
:
Aufzählungstyp)
:
Aufzählungstyp;

Beispiel
:
Succ(3);ist
4.
Succ("B");ist
"C",
weil
"C"
in
der
ASCII-

Tabelle
der
Nachfolger
von
"B"

ist.
TYPE
    Farbe
=
(Schwarz,
Grau,
Weiß);Aufzählungstyp
Farbe
definieren.
Succ(Schwarz);ergibt
Grau.
Succ(Grau);ergibt
Weiß.
Succ(Weiß);ist
nicht
definiert.

≡≡TRUNC

Durch
Trunc
wird
eine
Variable
des
Typs
REAL
in
eine
Variable
des
Typs
INTEGER
umgewandelt.
Dabei
wird
im
Gegensatz
zu
Round
nicht
auf-
oder
abgerundet.

Deklaration
:
FUNCTION
Trunc(RealVariable
:
REAL)
:
INTEGER;

Beispiel
:
Trunc(3.2);ergibt
3.
Trunc(3.8);ergibt
3.
Trunc(-3.2);ergibt
-3.
Trunc(-3.8);ergibt
-3.

≡≡UpCase

UpCase(Buchstabe)
ergibt
als
Funktionsergebnis
den
Großbuchstaben
von
Buchstabe.
Die
Umwandlung
wird
auch
für
alle
deutschen
Sonder-
zeichen
(ä,
ö,
ü)
durchgeführt.

Deklaration
:
FUNCTION
UpCase(Buchstabe
:
CHAR)
:
CHAR;

Beispiel
:
Write(UpCase("a"));druckt
"A".
Write(UpCase("A"));druckt
"A".
Write(UpCase("ö"));druckt
"Ö".

≡≡WhereX

Die
x-Koordinate
des
Cursors
im
Textschirm
wird
durch
die
Funktion
WhereX
ausgelesen.
Beim
vollen
Textschirm
hat
der
linke
Rand
die
x-Koordinate
1
und
der
rechte
die
x-Koordinate
80.

Deklaration
:
FUNCTIONWhereX
:
INTEGER;

Beispiel
:
GotoXY(5,
3);setzt
den
Cursor
auf
den
 Punkt
P(5/3).
Write(WhereX);druckt
den
Wert
5
aus.

≡≡WhereY

Die
y-Koordinate
des
Cursors
im
Textschirm
wird
durch
die
Funktion
WhereY
ausgelesen.
Beim
vollen
Textschirm
hat
der
obere
Rand
die
y-Koordinate
1
und
der
untere
die
y-Koordinate
25.

Deklaration
:
FUNCTIONWhereY
:
INTEGER;

Beispiel
:
GotoXY(5,
3);setzt
den
Cursor
auf
den
 Punkt
P(5/3).
Write(WhereY);druckt
den
Wert
3
aus.

≡≡ITG-Pascal-Funktionen

ARCCOSARCCOTARCSIN
BogenmaßBuchstabeCOT
DezimalZufallszahlEsGibtDatei    FunktionsWert
GanzeZufallsZahl GradIgelWinkel
IgelZeigen
LetzteTaste    LiesPort
SIGNStopZeitTAN
WeltPixelDX    WeltPixelDY    WeltXMax
WeltXMinWeltYMaxWeltYMin
WoGrafikXWoGrafikYWoIgelX
WoIgelYyKorrekturFaktor

≡≡Buchstabe

Die
Funktion(Zeichenkette,
nterBuchstabe)
liefert
den
n.
Buchstaben
in
der
Zeichenkette
zurück.
Dabei
muß
1
≤
n
≤
Anzahl
der
Buchstaben
in
der
Zeichenkette
sein.

Deklaration
:
FUNCTIONBuchstabe(Zeichenkette
:
STRING;
nterBuchstabe
:
INTEGER)
:
CHAR;

Beispiel
:
Write(Buchstabe("abcdefg",
3));
druckt
"c"
aus.

≡≡DezimalZufallszahl

DezimalZufallszahl(ObereSchranke)
ergibt
eine
Zufallszahl
x
des
Typs
REAL,
wobei
0
≤
x
<
ObereSchranke
gilt.
Der
Wert
0
kann
angenommen
werden,
der
Wert
ObereSchranke
wird
nie
angenommen.

Deklaration
:
FUNCTION
DezimalZufallszahl(ObereSchranke
:
REAL)
:
REAL;

Beispiel
:
Write(DezimalZufallszahl(4.5));druckt
eine
Zahl
x
mit
    0
≤
x
<
4.5!
(siehe
auch
    GanzeZufallszahl)

≡≡EsGibtDatei

Die
Funktion
EsGibtDatei(Dateiname)
dient
dazu,
zu
prüfen,
ob
eine
Datei
mit
dem
Dateinamen
auf
der
Diskette/Festplatte
existiert.
Sie
liefert
den
Wert
WAHR,
wenn
es
eine
solche
Datei
gibt,
sonst
den
Wert
FALSCH.
Der
Typ
der
Datei
(Textdatei
oder
andere)
läßt
sich
nicht
feststellen.

Deklaration
:
FUNCTION
EsGibtDatei(DateiName
:
STRING)
:
BOOLEAN;

Beispiel
:
Write(EsGibtDatei("ITG.HLP"));druckt
WAHR
aus,
wenn
es
die
    Datei
ITG.HLP
im
aktuellen
    Verzeichnis
gibt,
sonst
FALSCH

≡≡FunktionsWert

Wenn
mit
DefiniereFunktionsterm
ein
Funktionsterm
festgelegt
wurde,
kann
mit
FunktionWert
ein
Wert
an
einer
Stelle
berechnet
werden.

Deklaration
:
FUNCTION
FunktionsWert(x
:
REAL)
:
REAL;

Beispiel
:
DefiniereFunktionsterm("5*x");zuerst
Funktionsterm
festlegen
FOR
n
:=
1
TO
5
DO
BEGIN
    WriteLn(FunktionsWert(n));und
erst
dann
Funktionswerte
END;berechnen

≡≡GanzeZufallsZahl

GanzeZufallszahl(ObereSchranke)
ergibt
eine
Zufallszahl
x
des
Typs
INTEGER,
wobei
0
≤
x
<
ObereSchranke
gilt.
Der
Wert
0
kann
angenommen
werden,
der
Wert
ObereSchranke
wird
nie
angenommen.

Deklaration
:
FUNCTION
GanzeZufallszahl(ObereSchranke
:
INTEGER)
:
INTEGER;

Beispiel
:
Write(GanzeZufallszahl(5));druckt
eine
der
Zahlen
0..4!

≡≡LetzteTaste

Die
Funktion
LetzteTaste
liefert
den
Buchstaben
der
Taste,
die
zuletzt
gedrückt
wurde.
Damit
kann
nach
Read-,
Auswahl-
und
LiesEingaben-
Anweisungen
festgestellt
werden,
ob
die
Anweisungen
z.B.
mit
der
ESC-
Taste
abgebrochen
wurden.

Deklaration
:
FUNCTIONLetzteTaste
:
CHAR;

Beispiele
:

≡

1)
    VAR
c1,
c2
:
CHAR;

    c1
:=
ReadKey;
    c2
:=
LetzteTaste;c1
und
c2
sind
gleich,
weil
LetzteTaste
das
Lesen
eines
Zeichen
wiederholt.

2)
    REPEAT
EingabeFeld(...);
LiesEingaben;Wurde
LiesEingaben
mit
der
ESC-Taste
    UNTIL
LetzteTaste
=
ESC;beendet?
Wenn
ja
Abbrechen,
sonst
wiederholen.

≡≡LiesPort

Mit
LiesPort(WelcherPort)
kann
der
momentane
Wert,
der
am
Port
WelcherPort
anliegt,
gelesen
werden.
Mit
dieser
Funktion
kann
z.B.
der
Druckerstatus
oder
der
Timer
des
Computers
abgefragt
werden
oder
es
können
Meßwerte
von
einem
Interface
eingelesen
werden.
ACHTUNG:
Vor
der
Benutzung
dieser
Funktion
muß
eine
genaue
Information
über
die
entsprechende
Hardware
erfolgen,
die
abgefragt
werden
soll.

Deklaration
:
FUNCTIONLiesPort(WelcherPort
:
INTEGER)
:
INTEGER;

Beispiel
:
Write(LiesPort(nnn));
druckt
den
Wert,
der
am
(Drucker-)
Port
anliegt
(,
wenn
nnn
der
im
Computer
verwendete
Drucker-Port
ist).

≡≡StopZeit

Die
Funktion
StopZeit
liefert
die
Zeitdifferenz
in
Sekunden
zwischen
dem
letzten
Aufruf
der
Prozedur
StarteStopUhr
bzw.
dem
Programmstart,
wenn
StarteStopUhr
um
Programm
nicht
aufgerufen
wurde.
Die
Auflösung
beträgt
1/100
Sekunden
mit
einer
Genauigkeit
von
ca.
5/100
Sekunden,
die
durch
den
im
Computer
eingebauten
Timer
und
DOS
bedingt
ist.

Deklaration
:
FUNCTIONStopZeit
:
REAL;

Beispiel
:
StarteStopUhr;Stopuhr
auf
0
setzen
TueIrgendetwas;
Write(StopZeit);Zeitdauer
in
Sekunden
anzeigen,
die
für
TueIrgendetwas
benötigt
wurden.

≡≡WeltPixelDX

WeltPixelDX
liefert
die
Differenz
der
x-Koordinaten
zweier
benachbarter
Bildpunkte
in
einem
mit
DefiniereWelt
definierten
Koordiantensystem.

Deklaration:
FUNKTION
WeltPixelDX
:
REAL;

Beispiel:
DefiniereWelt(-3,
-4,
5,
6);Welt
definieren
WriteLn(WeltPixelDX);    druckt
die
Differenz
der
x-Koordinaten
zweier
benachbarter
Bildpunkte

≡≡WeltPixelDY

WeltPixelDY
liefert
die
Differenz
der
y-Koordinaten
zweier
benachbarter
Bildpunkte
in
einem
mit
DefiniereWelt
definierten
Koordiantensystem.

Deklaration:
FUNKTION
WeltPixelDY
:
REAL;

Beispiel:
DefiniereWelt(-3,
-4,
5,
6);Welt
definieren
WriteLn(WeltPixelDY);    druckt
die
Differenz
der
y-Koordinaten
zweier
benachbarter
Bildpunkte

≡≡WeltXMax

WeltXMax
liefert
die
x-Koordinate
des
äußersten
rechten
Bildpunktes
in
einem
mit
DefiniereWelt
definierten
Koordiantensystem.
Der
Wert
ist
meistens
größer
als
der
bei
DefiniereWelt
für
diesen
Wert
übergebene
Parameter,
da
ITG-PASCAL
das
Koordiantensystem
immer
so
anlegt,
daß
gleiche
Intervallbreiten
auf
einer
Achse
auch
immer
gleich
viele
Bildpunkte
enthalten.

Deklaration:
FUNKTION
WeltXMax
:
REAL;

Beispiel:
DefiniereWelt(-3,
-4,
5,
6);Welt
definieren
WriteLn(WeltXMax);druckt
den
Wert
der
x-Koordinate
des
äußersten
rechten
Bildpunktes
des
Koordinatensystems.
Der
Wert
ist
etwas
größer
als
5.

≡≡WeltXMin

WeltXMin
liefert
die
x-Koordinate
des
äußersten
linken
Bildpunktes
in
einem
mit
DefiniereWelt
definierten
Koordiantensystem.
Der
Wert
ist
meistens
kleiner
als
der
bei
DefiniereWelt
für
diesen
Wert
übergebene
Parameter,
da
ITG-PASCAL
das
Koordiantensystem
immer
so
anlegt,
daß
gleiche
Intervallbreiten
auf
einer
Achse
auch
immer
gleich
viele
Bildpunkte
enthalten.

Deklaration:
FUNKTION
WeltXMin
:
REAL;

Beispiel:
DefiniereWelt(-3,
-4,
5,
6);Welt
definieren
WriteLn(WeltXMin);druckt
den
Wert
der
x-Koordinate
des
äußersten
linken
Bildpunktes
des
Koordinatensystems.
Der
Wert
ist
etwas
kleiner
als
5.

≡≡WeltYMax

WeltYMax
liefert
die
y-Koordinate
des
obersten
Bildpunktes
in
einem
mit
DefiniereWelt
definierten
Koordiantensystem.
Der
Wert
ist
meistens
größer
als
der
bei
DefiniereWelt
für
diesen
Wert
übergebene
Parameter,
da
ITG-PASCAL
das
Koordiantensystem
immer
so
anlegt,
daß
gleiche
Intervall-
breiten
auf
einer
Achse
auch
immer
gleich
viele
Bildpunkte
enthalten.

Deklaration:
FUNKTION
WeltYMax
:
REAL;

Beispiel:
DefiniereWelt(-3,
-4,
5,
6);Welt
definieren
WriteLn(WeltYMax);druckt
den
Wert
der
y-Koordinate
des
obersten
Bildpunktes
des
Koordinaten-
systems.
Der
Wert
ist
etwas
größer
als
5.

≡≡WeltYMin

WeltYMin
liefert
die
y-Koordinate
des
untersten
Bildpunktes
in
einem
mit
DefiniereWelt
definierten
Koordiantensystem.
Der
Wert
ist
meistens
kleiner
als
der
bei
DefiniereWelt
für
diesen
Wert
übergebene
Parameter,
da
ITG-PASCAL
das
Koordiantensystem
immer
so
anlegt,
daß
gleiche
Intervallbreiten
auf
einer
Achse
auch
immer
gleich
viele
Bildpunkte
enthalten.

Deklaration:
FUNKTION
WeltYMin
:
REAL;

Beispiel:
DefiniereWelt(-3,
-4,
5,
6);Welt
definieren
WriteLn(WeltYMin);druckt
den
Wert
der
y-Koordinate
des
untersten
Bildpunktes
des
Koordinaten-
systems.
Der
Wert
ist
etwas
kleiner
als
5.

≡≡Standard-Prozeduren

Assign    Circle    Close
ClrEol    ClrScr
DECDelay
Delete    EXITGotoXY
HALTHighVideoINCInsert    InversVideo
LineLineTo    LowVideoMoveTo    NoSound
Random    RandomizeREADREADLN    ReName
Reset
ReWriteSeekSound
STR
VALWindow    WRITE
WRITELN

≡≡Assign

Assign
verbindet
eine
Dateivariable
DATEI
der
Typen
FILE
oder
 TEXT
mit
einem
Dateinamen
NAME
und
öffnet
sie
für
Lese-
und
Schreib-
zugriffe.
Anschließend
erfolgen
alle
Operationen
mit
DATEI
mit
der
Datei
des
Namens
NAME.
Vor
der
Verknüpfung
mit
Assign
kann
KEIN
Zugriff
auf
die
Datei
erfolgen!

Deklaration
:
PROCEDURE
Assign(Datei
:FILE;
DateiName
:
STRING);
PROCEDURE
Assign(Datei
:
 TEXT;
DateiName
:
STRING);

Beispiel
:

≡

VAR
    Datei
:
 TEXT;
    s
:STRING;
BEGIN
    Assign(Datei,
'ITG.HLP');Datei
mit
dem
Namen
verknüpfen
    Reset(Datei);Anfang
der
Datei
suchen
    WHILE
NOT
EOF(Datei)
DO
BEGINwenn
das
Dateiende
noch
nicht

erreicht
ist,
ReadLn(Datei,
s);lies
eine
Zeile
aus
der
Datei

in
die
Variable
s
WriteLn(s);und
drucke
s
auf
dem
Bildschirm
    END;aus.
    Close(Datei);Schließe
die
Datei.
END;

≡≡Close

Close(DATEI)
schließt
die
Datei.
Anschließend
können
keine
weiteren
Operationen
mit
DATEI
mehr
erfolgen.
Jede
Datei,
die
mit
Assign
geöffnet
wurde,
muß
im
Laufe
des
Programms
auch
mit
Close
geschlossen
werden!

Deklaration
:
PROCEDURE
Close(Datei
:FILE);
PROCEDURE
Close(Datei
:
 TEXT);

Beispiel
:

≡

VAR
    Datei
:
 TEXT;
    s
:STRING;
BEGIN
    Assign(Datei,
'ITG.HLP');Datei
mit
dem
Namen
verknüpfen
    Reset(Datei);Anfang
der
Datei
suchen
    WHILE
NOT
EOF(Datei)
DO
BEGINwenn
das
Dateiende
noch
nicht

erreicht
ist,
ReadLn(Datei,
s);lies
eine
Zeile
aus
der
Datei

in
die
Variable
s
WriteLn(s);und
drucke
s
auf
dem
Bildschirm
    END;aus.
    Close(Datei);Schließe
die
Datei.
END;

≡≡ClrEol

ClrEol
löscht
das
Ende
einer
Textzeile
ab
der
augenblicklichen
Cursorposition.
Die
Cursorposition
wird
dabei
nicht
verändert.

Deklaration
:
PROCEDURE
ClrEol;

Beispiel
:
HighVideo;Bildschirmattribut
auf
hell
setzen
GotoXY(30,
5);Cursor
auf
das
30.
Zeichen
der
5.
Zeile
setzen
ClrEol;    die
letzten
50
Zeichen
der
5.
Zeile
mit
Leerzeichen
auffüllen
und
das
Attribut
"hell"
verwenden
und
den
Cursor
auf
dem
30.
Zeichen
der
5.
Zeile
lassen
InversVideo;Bildschirmattribut
auf
invers
setzen
GotoXY(10,
8);Cursor
auf
das
10.
Zeichen
der
8.
Zeile
setzen
ClrEol;    die
letzten
70
Zeichen
der
8.
Zeile
mit
Leerzeichen
auffüllen
und
das
Attribut
"invers"
verwenden
und
den
Cursor
auf
dem
10.
Zeichen
der
8.
Zeile
lassen

≡≡ClrScr

ClrScr
löscht
das
aktive
Textfenster.
Weil
in
ITG-PASCAL
die
Textausgabe
auch
im
Grafikmodus
mit
Write(....)
erfolgen
kann,
löscht
ClrScr
den
Grafikschirm
-
also
auch
Grafiken
-,
wenn
der
Grafikmodus
aktiv
ist.

Deklaration
:
PROCEDURE
ClrScr;

Beispiel
:
Write("Irgend
etwas");Text
schreiben
Delay(2000);2s
(2000ms)
warten
ClrScr;Bildschirm
löschen
Delay(2000);wieder
warten,
damit
das
Ergebnis

betrachtet
werden
kann.

≡≡DEC

DEC(VARIABLE,
WERT)
verringert
VARIABLE
um
WERT.
VARIABLE
kann
vom
Typ
CHAR,
BYTE,
INTEGER,
WORD
oder
LONGINT
sein.
Der
zweite
Parameter
WERT
muß
nicht
mit
angegeben
werden.
In
diesem
Fall
erfolgt
eine
Verringerung
um
1!

Deklaration
:
PROCEDURE
DEC(VAR
c
:
CHAR;
Wert
:
LONGINT);
PROCEDURE
DEC(VAR
c
:
CHAR);
PROCEDURE
DEC(VAR
b
:
BYTE;
Wert
:
LONGINT);
PROCEDURE
DEC(VAR
b
:
BYTE);
PROCEDURE
DEC(VAR
i
:
INTEGER;
Wert
:
LONGINT);
PROCEDURE
DEC(VAR
i
:
INTEGER);
PROCEDURE
DEC(VAR
w
:
WORD;
Wert
:
LONGINT);
PROCEDURE
DEC(VAR
w
:
WORD);
PROCEDURE
DEC(VAR
l
:
LONGINT;
Wert
:
LONGINT);
PROCEDURE
DEC(VAR
l
:
LONGINT);

≡

Beispiel
:
c
:=
'C';
DEC(c,
2);c
hat
jetzt
den
Wert
'A',
weil
'A'
in
der
ASCII-Tabelle
das
zweite
Zeichen
vor
'C'
ist.
l
:=
12345;
DEC(l);l
hat
den
Wert
12344.
Der
zweite
Parameter
wird
in
diesem
Fall
automatisch
auf
1
gesetzt!

≡≡Delay

Delay(nMilliSekunden)
hält
die
Programmausführung
für
die
angegebenen
Millisekunden
an.

Deklaration
:
PROCEDURE
Delay(MilliSekunden
:
WORD);

Beispiel
:
WriteLn('erster
Text');
Delay(3000);wartet
3s
(3000ms)
WriteLn('zweiter
Text');
Delay(1500);wartet
1,5s
(1500ms)
WriteLn('dritter
Text');

≡≡Delete

Delete(ZEICHENKETTE,
AB,
ANZAHL)
löscht
in
ZEICHENKETTE
ab
dem
AB.ten
Zeichen
ANZAHL
von
Zeichen.

Deklaration
:
PROCEDURE
Delete(VAR
Zeichenkette
:
STRING;
Ab,
Anzahl
:
WORD);

Beispiel
:
Zeichenkette
:=
'ABCDEFGH';Wertzuweisung
Delete(Zeichenkette,
4,
2);In
der
Zeichenkette
wird
der
4.
Buchstabe
(hier
'D')
gesucht.
Einschließlich
dieses
Buchstabens
werden
2
Buchstaben
(hier
'D'
und
'E')
gelöscht.
WriteLn(Zeichenkette);Druckt
'ABCFGH'
auf
den
Bildschirm.

≡≡EXIT

Mit
der
Anweisung
EXIT
erreicht
man,
daß
die
Ausführung
einer
Prozedur
oder
Funktion
sofort
abgebrochen
wird.
Im
Hauptprogramm
sollte
HALT
verwendet
werden.

Deklaration
:
PROCEDURE
EXIT;

≡

Beispiel
:
PROCEDURE
ExitTest(n
:
INTEGER);
BEGIN
IF
n
>
10
THEN
BEGINwenn
n
>
10,
dann

WriteLn("n
>
10");Text
ausgeben
und

EXIT;die
Prozedur
sofort
verlassen
END
ELSE
BEGIN

WriteLn("n
<=
10");
sonst
Text
ausgeben
END;
.und
den
Rest
der
Prozedur
.abarbeiten
END;

≡≡GotoXY

GotoXY(x,y)
setzt
den
Cursor
auf
den
 Punkt
P(x/y).
Der
linke
obere
Eckpunkt
des
Bildschirms
hat
die
Koordinaten
(1/1).
Die
x-Werte
nehmen
nach
rechts
bis
80
zu,
die
y-Werte
nach
unten
bis
25.

Deklaration
:
PROCEDURE
GotoXY(x,
y
:
WORD);

Beispiel
:
GotoXY(1,
1);linker
oberer
Eckpunkt
GotoXY(1,
25);linker
unterer
Eckpunkt
GotoXY(80,
1);rechter
oberer
Eckpunkt
GotoXY(80,
25);rechter
unterer
Eckpunkt

≡≡HALT

HALT
beendet
die
Programmausführung
sofort.

Deklaration
:
PROCEDURE
Halt;

Beispiel
:
x
:=
Random(100)
-
50;Zufallszahl
zwischen
-50
und
49!
erzeugen
IF
x
<
0
THEN
BEGINfür
x
<
0
ist
√x
nicht
    WriteLn("x
<
0!");definiert,
deshalb
die
    HALT;Programmausführung
abbrechen
END
ELSE
BEGIN
    WriteLn("√",
x,
"=",
SQRT(x));sonst
√x
ausdrucken
END;

≡≡HighVideo

Setzt
das
Schreibattribut
auf
helle
Schrift
auf
dunklem
Untergrund.

Deklaration
:
PROCEDURE
HighVideo;

Beispiel
:
HighVideo;helle
Schrift
auf
dunklem
Untergrund
WriteLn("helle
Schrift");
LowVideo;dunklere
Schrift
auf
dunklem
Untergrund
WriteLn("dunklere
Schrift");
InversVideo;dunkle
Schrift
auf
hellem
Untergrund
WriteLn("inverse
Schrift");

≡≡INC

INC(VARIABLE,
WERT)
erhöht
VARIABLE
um
WERT.
VARIABLE
kann
vom
Typ
CHAR,
BYTE,
INTEGER,
WORD
oder
LONGINT
sein.
Der
zweite
Parameter
WERT
muß
nicht
mit
angegeben
werden.
In
diesem
Fall
erfolgt
eine
Erhöhung
um
1!

Deklaration
:
PROCEDURE
INC(VAR
c
:
CHAR;
Wert
:
LONGINT);
PROCEDURE
INC(VAR
c
:
CHAR);
PROCEDURE
INC(VAR
b
:
BYTE;
Wert
:
LONGINT);
PROCEDURE
INC(VAR
b
:
BYTE);
PROCEDURE
INC(VAR
i
:
INTEGER;
Wert
:
LONGINT);
PROCEDURE
INC(VAR
i
:
INTEGER);
PROCEDURE
INC(VAR
w
:
WORD;
Wert
:
LONGINT);
PROCEDURE
INC(VAR
w
:
WORD);
PROCEDURE
INC(VAR
l
:
LONGINT;
Wert
:
LONGINT);
PROCEDURE
INC(VAR
l
:
LONGINT);

≡

Beispiel
:
c
:=
'C';
INC(c,
2);c
hat
jetzt
den
Wert
'E',
weil
'E'
in
der
ASCII-Tabelle
das
zweite
Zeichen
nach
'C'
ist.
l
:=
12345;
INC(l);l
hat
den
Wert
12346.
Der
zweite
Parameter
wird
in
diesem
Fall
automatisch
auf
1
gesetzt!

≡≡Insert

Mit
Insert
wird
eine
Zeichenkette
in
eine
andere
Zeichenkette
an
einer
vorgegebenen
Position
eingefügt.

Deklaration
:
PROCEDURE
Insert(Was
:
STRING;
VAR
WoHinein
:
STRING;
Wo
:
INTEGER);
PROCEDURE
Insert(Was
:
CHAR;
VAR
WoHinein
:
STRING;
Wo
:
INTEGER);

Beispiel
:

≡

Was
:=
"DE";
WoHinein
:=
"ABCFGH";
Insert(Was,
WoHinein,
4);Der
erste
Buchstabe
der
Zeichenkette
Was
("D")
wird
als
4.
Buchstabe,
der
zweite
aus
Was
("E")
als
5.
Buchstabe
in
WoHinein
eingefügt.
Die
Position
der
übrigen
Buchstaben
aus
WoHinein
verschiebt
sich
dadurch
um
zwei
nach
rechts.
WoHinein
hat
anschließend
den
Wert
"ABCDEFGH".

≡≡InversVideo

Setzt
das
Schreibattribut
auf
dunkle
Schrift
auf
hellem
Untergrund.

Deklaration
:
PROCEDURE
HighVideo;

Beispiel
:
HighVideo;helle
Schrift
auf
dunklem
Untergrund
WriteLn("helle
Schrift");
LowVideo;dunklere
Schrift
auf
dunklem
Untergrund
WriteLn("dunklere
Schrift");
InversVideo;dunkle
Schrift
auf
hellem
Untergrund
WriteLn("inverse
Schrift");

≡≡LowVideo

Setzt
das
Schreibattribut
auf
dunklere
Schrift
auf
dunklem
Untergrund.

Deklaration
:
PROCEDURE
LowVideo;

Beispiel
:
HighVideo;helle
Schrift
auf
dunklem
Untergrund
WriteLn("helle
Schrift");
LowVideo;dunklere
Schrift
auf
dunklem
Untergrund
WriteLn("dunklere
Schrift");
InversVideo;dunkle
Schrift
auf
hellem
Untergrund
WriteLn("inverse
Schrift");

≡≡NoSound

NoSound
schaltet
den
im
Computer
eingebauten
Lautsprecher
ab.

Deklaration
:
PROCEDURE
NoSound;

Beispiel
:
Sound(1000);Ton
mit
der
Frequenz
f=1000Hz
1s
(1000ms)
Delay(1000);lang
ausgeben,
NoSound;dann
die
Tonausgabe
abschalten

≡≡Randomize

Randomize
erzeugt
den
Anfang
einer
neuer
Folge
von
Zufallszahlen.

Deklaration
:
PROCEDURE
Randomize;

Beispiel
:
Randomize;Anfang
einer
neuen
Folge
erzeugen
Write(Random(100));Zufallszahl
zwischen
0
und
99
drucken

≡≡READ

Mit
Read
erfolgen
Eingaben
über
die
Tastatur
oder
die
Diskette
/
Festplatte.
Dabei
sind
Variablen
beliebigen
Typs
(im
Unterschied
zu
TURBO-PASCAL
auch
ARRAY-
und
RECORD-Variablen
bei
der
Tastatur-
Eingabe)
zugelassen.
Für
REAL-Variablen
können
abweichend
zu
TURBO-
PASCAL
auch
Terme
eingegeben
werden,
die
allerdings
keine
Variablen
enthalten
dürfen.
Bei
STRING-Variablen
wird
das
Eingabefenster
in
einer
Länge
geöffnet,
die
der
Deklaration
entspricht.
Im
Unterschied
zu
TURBO-PASCAl
können
die
Variablen
mit
Werten
vorbelegt
werden,
die
dann
im
Eingabefeld
erscheinen
und
editiert
werden
können.
Dabei
stehen
die
Tasten
<-,
->,
Home
(Pos1),
End
(Ende),
Del
(Lösch),
BackSpace
(<--)
und
Ins
(Einf)
zur
Verfügung.
Wenn
das
erste
Zeichen
keines
dieser
Editorzeichen
ist,
wird
das
Eingabefenster
gelöscht.
Der
Cursor
bleibt
nach
der
Eingabe
direkt
hinter
dem
letzten
eingegebenen
Zeichen
stehen.
Bei
Dateien
darf
mit
READ
nur
ein
Lesevorgang
in
FILE-Typen
vorgenommen
werden.

≡

Deklaration
:
PROCEDURE
Read(VAR
v
:
VariableBeliebigenTyps);
PROCEDURE
Read(VAR
f
:
FILE;
VAR
v
:
VariableBeliebigenTyps);

Beispiel
:
VAR
    r
:
REAL;
    s
:
STRING[20];
    a
:
ARRAY[1..5]
OF
INTEGER;
    f
:
FILE;
BEGIN

≡

    s
:=
"abcd";
    Read(s);Es
wird
ein
20
Zeichen
langes
Eingabefeld
geöffnet.
Eingabe
:
"ABCD"Bei
dem
ersten
Zeichen
"A"
wird
das
Eingabefenster
gelöscht.
Dann
wird
"A"
als
erstes
Zeichen
geschrieben.
Eingabe
:
RETURN-TasteDer
Wert
wird
unverändert
über-
nommen.
Eingabe
:
->Der
Cursor
bewegt
sich
um
ein
Zeichen
nach
rechts
auf
"b".
Wenn
jetzt
"z"
gedrückt
wird,
wird
dieses
Zeichen
an
der
zweiten
Stelle
eingefügt
und
es
steht
"azbcd"
im
Eingabefeld.

≡

    Read(r);Eingabe
:
1.234
oder
1.234E+3
oder
sin(2*pi*100)
    Read(a);Auf
dem
Bildschirm
erscheint
der
Text
"A[1]".
Direkt
anschließend
ist
das
Eingabefeld
geöffnet
und
es
kann
der
erste
Wert
bearbeitet
werden.
Nach
<RETURN>
erscheint
"A[2]"
mit
dem
Eingabefeld
usw.
Die
Eingabe
kann
mit
<ESC>
vorzeitig
abgebrochen
werden.

≡

    Assign(f,
'DATEN.DAT');
Datei
öffnen
    Reset(f);Lesemarke
auf
den
Anfang
setzen
    Read(f,
a);das
Array
a
aus
der
Datei
lesen
    Close(f);Datei
schließen
END;

≡≡READLN

Die
Prozedur
ReadLn
entspricht
weitgehend
der
Prozedur
Read.
Es
gibt
aber
zwei
Unterschiede
:
1)
Nach
ReadLn
wird
der
Cursor
auf
den
Anfang
der
folgenden
Zeile
gesetzt.
2)
Bei
Dateien
darf
mit
ReadLn
nur
ein
Lesevorgang
in
 TEXT-Typen
vorgenommen
werden.

Deklaration
:
PROCEDURE
ReadLn(VAR
v
:
VariableBeliebigenTyps);
PROCEDURE
ReadLn(VAR
t
:
 TEXT;
VAR
v
:
VariableBeliebigenTyps);

Beispiel
:
Read(s);Cursor
bleibt
hinter
dem
letzten
Zeichen
stehen
WriteLn;Cursor
an
den
Anfang
der
nächsten
Zeile
ReadLn(s);Cursor
an
den
Anfang
der
nächsten
Zeile
(Kombination
aus
Read(s)
und
WriteLn)

≡≡ReName

ReName
ändert
den
Namen
einer
Datei.

Deklaration
:
PROCEDURE
ReName(f
:FILE;
NeuerName
:
STRING);
PROCEDURE
ReName(t
:
 TEXT;
NeuerName
:
STRING);

Beispiel
:

≡

VAR
    Datei
:
 TEXT;
BEGIN
    Assign(Datei,
'ITG.HLP');Datei
mit
dem
Namen
verknüpfen
    ReName(Datei,
'ITG.BAK');Namen
von
ITG.HLP
auf
der

Diskette
/
Festplatte
in

ITG.BAK
umändern
    Close(Datei);Schließe
die
Datei.
END;

≡≡Reset

Reset
setzt
die
Lese-
/
Schreibposition
in
einer
Datei
auf
den
Anfang
der
Datei.

Deklaration
:
PROCEDURE
Reset(f
:FILE);
PROCEDURE
Reset(t
:
 TEXT);

Beispiel
:

≡

VAR
    Datei
:
 TEXT;
    s
:
STRING;
BEGIN
    Assign(Datei,
'ITG.HLP');Datei
mit
dem
Namen
verknüpfen
    Reset(Datei);Anfang
der
Datei
suchen
    WHILE
NOT
EOF(Datei)
DO
BEGINwenn
das
Dateiende
noch
nicht

erreicht
ist,
ReadLn(Datei,
s);lies
eine
Zeile
aus
der
Datei

in
die
Variable
s
WriteLn(s);und
drucke
s
auf
dem
Bildschirm
    END;aus.
    Close(Datei);Schließe
die
Datei.
END;

≡≡ReWrite

ReWrite
löscht
die
mit
dieser
Dateivariablen
verknüpfte
Datei,
sofern
eine
unter
diesem
Namen
existiert,
erzeugt
eine
neue
unter
dem
gleichen
Namen
und
setzt
die
Lese-
/
Schreibposition
auf
den
Anfang
dieser
Datei.

Deklaration
:
PROCEDURE
ReWrite(f
:FILE);
PROCEDURE
ReWrite(t
:
 TEXT);

Beispiel
:

≡

VAR
    Datei
:
 TEXT;
    s
:
STRING;
BEGIN
    Assign(Datei,
'NEU.DAT');Datei
mit
dem
Namen
verknüpfen
    ReWrite(Datei);neue
Datei
anlegen
und
Schreib-
position
auf
den
Anfang
setzen
    s
:=
"Anfang
einer
neuen
Datei";
    WriteLn(Datei,
s);s
an
den
Anfang
der
Datei
    .
schreiben
und
gegebenenfalls
    .
weitere
Texte
anhängen
    Close(Datei);Schließe
die
Datei.
END;

≡≡Seek

Seek(Dateivariable,
Position)
setzt
den
Lesezeiger
in
der
Datei
Dateivariable
an
das
Ende
des
Datensatzes
mit
dem
Index
Position.

Deklaration
:
PROCEDURE
Seek(f
:
FILE
OF
Datenstruktur;
Position
:
WORD);

≡

Beispiel
:
TYPE
    DatenStruktur
=
RECORD
x
:
INTEGER;
s
:
STRING[20];
    END;
VAR
    Daten
:
DatenStruktur;
    f
:
FILE
OF
DatenStruktur;
BEGIN
    Assign(f,
"TEST.DAT");der
Datei
einen
Namen
zuweisen
    Reset(f);und
zum
Lesen
öffnen
    Seek(f,
3);Zeiger
auf
das
Ende
des
3.Datensatzes
    Read(f,
Daten);    4.Datensatz
lesen!!!!
    Close(f);Datei
schließen
END;

≡≡Sound

Sound(f)
schaltet
den
im
Computer
eingebauten
Lautsprecher
ein
und
bewirkt
eine
Tonerzeugung
eines
Tones
mit
der
Frequenz
f.

Deklaration
:
PROCEDURE
Sound(Frequenz
:
WORD);

Beispiel
:
Sound(1000);Ton
mit
der
Frequenz
f=1000Hz
1s
(1000ms)
Delay(1000);lang
ausgeben,
NoSound;dann
die
Tonausgabe
abschalten

≡≡STR

STR
wandelt
eine
Zahl
in
eine
Zeichenkette
um
(Umkehrprozedur
zu
VAL).

Deklaration
:
PROCEDURE
STR(b
:
BYTE;
VAR
s
:
STRING);
PROCEDURE
STR(i
:
INTEGER;
VAR
s
:
STRING);
PROCEDURE
STR(w
:
WORD;
VAR
s
:
STRING);
PROCEDURE
STR(l
:
LONGINT;
VAR
s
:
STRING);
PROCEDURE
STR(r
:
REAL;
VAR
s
:
STRING);

Beispiel
:

≡

VAR
    w
:
WORD;
    r
:
REAL;
    s
:
STRING;
BEGIN
    w
:=
1234;
    STR(w,
s);s
erhält
den
Wert
"1234"
    r
:=
1.234;
    STR(r,
s);s
erhält
den
Wert
"1.2340000000E+0000"
END;

≡≡VAL

VAL
wandelt
eine
Zeichenkette
in
eine
Zahlenvariable
um
(Umkehrprozedur
zu
STR).

Deklaration
:
PROCEDURE
VAL(s
:
STRING;
VAR
b
:
BYTE;
FehlerPos
:
WORD);
PROCEDURE
VAL(s
:
STRING;
VAR
i
:
INTEGER;
FehlerPos
:
WORD);
PROCEDURE
VAL(s
:
STRING;
VAR
w
:
WORD;
FehlerPos
:
WORD);
PROCEDURE
VAL(s
:
STRING;
VAR
l
:
LONGINT;
FehlerPos
:
WORD);
PROCEDURE
VAL(s
:
STRING;
VAR
r
:
REAL;
FehlerPos
:
WORD);

Beispiel
:

≡

VAR
w,
FehlerPos
:
WORD
BEGIN
VAL("1234",
w,
FehlerPos);w
erhält
den
Wert
1234,
FehlerPos
ist
0
VAL("12q4",
w,
FehlerPos);FehlerPos
ist
3,
weil
an
der
3.
Stelle
der
Zeichenkette
ein
Zeichen
steht,
das
keine
Ziffer
ist
END;

≡≡Window

Window
definiert
ein
Textfenster
auf
dem
Bildschirm.
Alle
nachfolgenden
Write-
/
GotoXY-Anweisungen
beziehen
sich
auf
dieses
Fenster.

Deklaration
:
PROCEDURE
Window(xMin,
yMin,
xMax,
yMax
:
WORD);

Beispiel
:
Window(10,
3,
60,
8);definiert
einen
Teilausschnitt
des
Bild-
als
Textfenster.
Die
Koordinaten
beziehen
sich
auf
den
vollen
Bildschirm.
GotoXY(1,
1);
setzt
den
Cursor
in
die
linke
obere
Ecke
des
Fensters
(absolute
Koordinaten
(10/3)
und
(60/8))
Window(1,
1,
80,
25);

≡≡WRITE

Mit
Write
erfolgen
Ausgaben
auf
den
Bildschirm
oder
die
Diskette
/
Festplatte.
Dabei
sind
Variablen
beliebigen
Typs
(im
Unterschied
zu
TURBO-PASCAL
auch
ARRAY-
und
RECORD-Variablen
bei
der
Bildschirm-
Ausgabe)
zugelassen.
REAL-Variablen
werden
soweit
wie
möglich
ohne
Expontialdarstellung
gedruckt.
Der
Cursor
bleibt
nach
der
Ausgabe
direkt
hinter
dem
letzten
ausgegebenen
Zeichen
stehen.
Bei
Dateien
darf
mit
WRITE
nur
ein
Schreibvorgang
in
FILE-Typen
vorgenommen
werden.

Deklaration
:
PROCEDURE
Write(v
:
VariableBeliebigenTyps);
PROCEDURE
Write(VAR
f
:
FILE;
v
:
VariableBeliebigenTyps);

Beispiel
:

≡

VAR
    a
:
ARRAY[1..3]
OF
INTEGER;
    f
:
FILE;
BEGIN
    s
:=
"abcd";
    Write(s);Es
wird
"abcd"
gedruckt.
    Write(s:6);Es
wird
"abcd"
gedruckt.
Die
Ausgabe
erfolgt
über
mindestens
6
Zeichen.
Wenn
die
Zeichenkette
weniger
als
6
Zeichen
enthält,
werden
vor
dem
ersten
Zeichen
solange
Leerzeichen
einfügt,
bis
die
Zeichenkette
6
Zeichen
enthält.
In
diesem
Fall
werden
also
6-4
=
2
Leerzeichen
eingefügt.
    Write("a");druckt
"a"
    Write("a":3);druckt
"a"
wie
oben
beschrieben

≡

    Write(1234);druckt
"1234"
    Write(1234:6);druckt
"1234"
    Write(pi);druckt
"3.141592654"
abweichend
von
TURBO-PASCAL
    Write(pi:13);druckt
"3.141592654"
(13
Zeichen)
    Write(pi:10:5)druckt
"3.14159"
(10
Zeichen
insgesamt,
davon
5
Nachkommastellen)

≡

    a[1]
:=
1;
    a[2]
:=
2;
    a[3]
:=
3;
    Write(a);druckt
"(A[1]=1,A[2]=2,A[3]=3)"
mit
Angabe
des
Variablen-Namens,
des
Feldindexes
und
des
Wertes
(in
TURBO-PASCAL
nicht
möglich)
    Write(a:3);druckt
"(A[1]=1,A[2]=2,A[3]=3)"
und
verwendet
für
die
Darstellung
des
Variablen-
inhaltes
3
Zeichen

≡

    Assign(f,
'DATEN.DAT');
Datei
öffnen
    ReWrite(f);Schreibmarke
auf
den
Anfang
setzen
    Write(f,
a);das
Array
a
in
die
Datei
schreiben
    Close(f);Datei
schließen
END;

≡≡WRITELN

Die
Prozedur
WriteLn
entspricht
weitgehend
der
Prozedur
Write.
Es
gibt
aber
zwei
Unterschiede
:
1)
Nach
WriteLn
wird
der
Cursor
auf
den
Anfang
der
folgenden
Zeile
gesetzt.
2)
Bei
Dateien
darf
mit
WriteLn
nur
ein
Schreibvorgang
in
 TEXT-Typen
vorgenommen
werden.

Deklaration
:
PROCEDURE
WriteLn(v
:
VariableBeliebigenTyps);
PROCEDURE
WriteLn(VAR
t
:
 TEXT;
v
:
VariableBeliebigenTyps);

Beispiel
:
Write(s);Cursor
bleibt
hinter
dem
letzten
Zeichen
stehen
WriteLn;Cursor
an
den
Anfang
der
nächsten
Zeile
WriteLn(s);Cursor
an
den
Anfang
der
nächsten
Zeile
(Kombination
aus
Write(s)
und
WriteLn)

≡≡ITG-Pascal-Prozeduren

AusgabeAufBildschirm
AusgabeAufDiskette
AusgabeAufDruckerAuswahl
AuswahlFeld Bogen
BreakPointDatenAufDiskette
DatenVonDisketteDebugEin
DebugAusDefiniereFunktionsterm
DreheAufDruckeBildschirm
EingabeFeldEingabeVonTastatur
EingabeVonDisketteEinzelschrittEin
EinzelschrittAusErsetzeBuchstaben
FärbenFügeBuchstabenEin
GeheNachGrafikFenster
GrafikSchirmHinten
InGradImBogenmaß
KreisLiesEingaben
LinkerBogen Links
LöscheBuchstabenMenü

≡

MitCursorMitIgel
MitProtokollMitStift
NeueZufallsZahlenFolgeÖffneAusgabeDatei
ÖffneEingabeDateiÖffneFenster
OhneCursorOhneIgel
OhneProtokollOhneStift
PapierFarbePause
 PunktRechterBogen

 RechtsSchließeAusgabeDatei
SchließeEingabeDatei
SchließeFenster
SchreibPortStarteStopUhr
StiftFarbeStrecke
TextSchirmTon
UrsprungVertausche
VorneWähleDatei
Wischen

≡≡AusgabeAufBildschirm

Wenn
die
Ausgabe,
die
mit
Write
/
WriteLn
normalerweise
auf
den
Bildschirm
erfolgt,
mit
AusgabeAufDrucker
auf
den
Drucker
oder
mit
AusgabeAufDiskette
auf
die
Diskette
umgelenkt
wurde,
kann
sie
mit
AusgabeAufBildschirm
wieder
auf
den
Bildschirm
zurückgelenkt
werden.

Deklaration
:
PROCEDURE
AusgabeAufBildschirm;

Beispiel
:
AusgabeAufDrucker;
WriteLn("Diese
Ausgabe
erfolgt
auf
den
Drucker!");
AusgabeAufBildschirm;
WriteLn("Diese
Ausgabe
erfolgt
auf
den
Bildschirm.");

≡≡AusgabeAufDiskette

Mit
AusgabeAufDiskette
wird
die
Ausgabe,
die
mit
Write
/
WriteLn
normalerweise
auf
den
Bildschirm
erfolgt,
auf
die
Diskette
/
Festplatte
umgelenkt.
Zuvor
muß
aber
eine
Ausgabedatei
mit
ÖffneAusgabeDatei(DateiName)
geöffnet
werden!

Deklaration
:
PROCEDURE
AusgabeAufDiskette;

Beispiel
:
ÖffneAusgabeDatei("AUSGABE.TXT");
AusgabeAufDiskette;
WriteLn("Diese
Ausgabe
erfolgt
auf
Diskette!");
AusgabeAufBildschirm;
WriteLn("Diese
Ausgabe
erfolgt
auf
den
Bildschirm.");
SchließeAusgabeDatei;

≡≡AusgabeAufDrucker

Mit
AusgabeAufDrucker
wird
die
Ausgabe,
die
mit
Write
/
WriteLn
normalerweise
auf
den
Bildschirm
erfolgt,
auf
den
Drucker
umgelenkt.

Deklaration
:
PROCEDURE
AusgabeAufDrucker;

Beispiel
:
AusgabeAufDrucker;
WriteLn("Diese
Ausgabe
erfolgt
auf
den
Drucker!");
AusgabeAufBildschirm;
WriteLn("Diese
Ausgabe
erfolgt
auf
den
Bildschirm.");

≡≡Auswahl

Mit
Auswahl
kann
eine
Wahl
aus
einer
Liste
von
Daten
erfolgen,
die
mit
AuswahlFeld
vorher
definiert
wurden.
In
der
Variablen
Index
wird
dabei
zurückgegeben,
als
wievieltes
Element
das
mit
RETURN
angewählte
in
der
Liste
eingetragen
wurde.
Wenn
die
Auswahl
mit
ESC
abgebrochen
wird,
ist
Index
=
0!
Beim
Verlassen
der
Auswahl
wird
die
Anzahl
der
Auswahlelemente
automatisch
auf
Null
gesetzt.
Der
linke
obere
Eckpunkt
des
Auswahlfenster
hat
die
Koordinaten
P(x/y).

Deklaration
:
PROCEDURE
Auswahl(x,
y
:
INTEGER;
VAR
Index
:
INTEGER);

Beispiel
:
VAR
    Liste
:
ARRAY[1..60]
OF
STRING[20];
    n,
Wahl
:
INTEGER;

≡

BEGIN
    FOR
n
:=
1
TO
60
DO
BEGIN
Str(n:5,
Liste[n]);
AuswahlFeld(Liste[n]);Elemente
als
STRING
in
die
    END;Auswahlliste
eintragen
    ÖffneFenster(1,
1,
80,
25,
OhneRahmen);alten
Bildschirminhalt
speichern
    Auswahl(10,
3,
Wahl);linken
oberen
Eckpunkt
der
Auswahl
auf
P(10/3)
setzen
und
das
Menü
aufrufen
Wahl
enthält
den
Index
des
gewählten
Listenelementes
    SchließeFenster;alten
Bildschirm
wieder-
herstellen

≡

    IF
Wahl
>
0
THEN
BEGIN
WriteLn(Liste[Wahl]);
    END
    ELSE
BEGIN
WriteLn("Auswahl
wurde
mit
<ESC>
abgebrochen");
    END;
END.

≡≡AuswahlFeld

AuswahlFeld
fügt
einer
Liste,
aus
der
ein
Element
ausgewählt
werden
soll,
ein
Element
hinzu.
Der
Text,
der
in
dem
Auswahlmenü
erscheinen
soll,
muß
der
Prozedur
AuswahlFeld
als
STRING
übergeben
werden.

Deklaration
:
PROCEDURE
AuswahlFeld(DatenText
:
STRING[40]);

Beispiel
:
VAR
    Liste
:
ARRAY[1..60]
OF
STRING[20];
    n,
Wahl
:
INTEGER;

≡

BEGIN
    FOR
n
:=
1
TO
60
DO
BEGIN
Str(n:5,
Liste[n]);
AuswahlFeld(Liste[n]);Elemente
als
STRING
in
die
    END;Auswahlliste
eintragen
    ÖffneFenster(1,
1,
80,
25,
OhneRahmen);alten
Bildschirminhalt
speichern
    Auswahl(10,
3,
Wahl);linken
oberen
Eckpunkt
der
Auswahl
auf
P(10/3)
setzen
und
das
Menü
aufrufen
Wahl
enthält
den
Index
des
gewählten
Listenelementes
    SchließeFenster;alten
Bildschirm
wieder-
herstellen

≡

    IF
Wahl
>
0
THEN
BEGIN
WriteLn(Liste[Wahl]);
    END
    ELSE
BEGIN
WriteLn("Auswahl
wurde
mit
<ESC>
abgebrochen");
    END;
END.

≡≡DatenAufDiskette

Mit
der
Anweisung
DatenAufDiskette
kann
der
Inhalt
einer
beliebigen
Variablen,
die
allerdings
keine
Dateivariable
( TEXT
oder
FILE)
sein
darf,
unter
dem
angegebenen
Dateinamen
auf
Diskette
gespeichert
werden.

Deklaration
:
PROCEDURE
DatenAufDiskette(DateiName
:
STRING;
v
:
VariableBeliebigenTyps);

Beispiel
:

≡

TYPE
    DatenSatz
=
RECORDDatenstruktur
definieren
Firma
:
STRING[40];
Ort
:
STRING[20];
Plz
:
WORD;
    END;
VAR
    d
:
DatenSatz;Variable
deklarieren
BEGIN
    d.Firma
:=
"Software
Vertrieb";Variable
mit
Werten
    d.Ort
:=
"Kiel";belegen
    d.Plz
:=
2300;und
unter
dem
Namen
    DatenAufDiskette("FIRMEN.DAT",
d);"FIRMEN.DAT"
abspeichern
END;

≡≡DatenVonDiskette

Mit
der
Anweisung
DatenVonDiskette
kann
der
Inhalt
einer
beliebigen
Variablen,
die
allerdings
keine
Dateivariable
( TEXT
oder
FILE)
sein
darf,
unter
dem
angegebenen
Dateinamen
von
Diskette
gelesen
werden.

Deklaration
:
PROCEDURE
DatenVonDiskette(DateiName
:
STRING;
VAR
v
:
VariableBeliebigenTyps);

Beispiel
:
TYPE
    DatenSatz
=
RECORDDatenstruktur
definieren
Firma
:
STRING[40];
Ort
:
STRING[20];
Plz
:
WORD;
    END;

≡

VAR
    d
:
DatenSatz;Variable
deklarieren
BEGIN
    IF
EsGibtDatei("FIRMEN.DAT")
THEN
BEGINgibt
es
die
Datei
"FIRMEN.DAT"?
DatenVonDiskette("FIRMEN.DAT",
d);wenn
ja
von
Diskette
in
die
Variable
d
lesen
WriteLn(d);und
ausdrucken
    END
    ELSE
BEGIN
WriteLn("FIRMEN.DAT
nicht
gefunden");sonst
Fehlermeldung
    END;
END;

≡≡DefiniereFunktionsTerm

Wenn
mit
DefiniereFunktionsterm
ein
Funktionsterm
festgelegt
wurde,
kann
mit
FunktionWert
ein
Wert
an
einer
Stelle
berechnet
werden.

Deklaration
:
PROCEDURE
DefiniereFunktionsterm(Term
:
STRING);

Beispiel
:
DefiniereFunktionsterm("5*x");    zuerst
Funktionsterm
festlegen
IF
FunktionstermFehler
=
0
THEN
BEGINkein
Fehler
enthalten?
    FOR
n
:=
1
TO
5
DO
BEGIN
WriteLn(FunktionsWert(n));    erst
dann
Funktionswerte
    END;berechnen
END;


≡≡DruckeBildschirm

Mit
DruckeBildschirm
wird
der
Inhalt
des
Text-
oder
des
Grafikschirms
ausgedruckt.

Deklaration
:
PROCEDUREDruckeBildschirm;

Beispiel
:
Grafikschirm;    in
den
Grafikmodus
schalten
ZeichneIrgendEtwas;Grafik
erstellen
DruckeBildschirm;und
ausdrucken

≡≡EingabeFeld

Mit
EingabeFeld
wird
ein
Feld
einer
Bildschirmmaske
zur
Eingabe
eines
Datensatzes
definiert.
Wenn
alle
gewünschten
Felder
definiert
wurden,
wird
das
Einlesen
mit
LiesEingaben
ausgeführt.
Dabei
kann
mit
den
Tasten
"Auf(CrsUp)",
"Ab(CrsDn)",
"Pos1(Home)"
und
"Ende(End)"
zwischen
den
Eingabefeldern
beliebig
oft
gewechselt
werden.
Die
Eingabe
wird
beendet,
wenn
in
dem
zuletzt
definierten
Feld
die
RETURN-Taste
gedrückt
wird
oder
in
einem
beliebigen
Feld
die
ESC-Taste
oder
eine
der
Tastenkombinationen
Ctrl-Bild-Auf(Ctrl-PgUp)
oder
Ctrl-Bild-Ab(Ctrl-PgDn)
gedrückt
wird.

≡

Deklaration
:
PROCEDURE
EingabeFeld(x,
y
:
INTEGER;
Erklärung
:
STRING;
VAR
v
:
EinfacheVariable);

EinfacheVariable
ist
vom
Typ
CHAR,
STRING,
BYTE,
INTEGER,
WORD,
LONGINT,
REAL,
DOUBLE,
EXTENDED
oder
BOOLEAN

Beispiel
:

≡

VAR
    r
:
REAL;
    i
:
INTEGER;
    s
:
STRING[20];
BEGIN
    r
:=
1.234;Belegung
der
Variablen
mit
Startwerten,
    i
:=
500;die
editiert
werden
sollen
    Name
:=
"Irgendwer";

≡

    REPEAT
EingabeFeld(5,
3,
"Dezimalzahl
:
",
r);
EingabeFeld(2,
6,
"ganze
Zahl
zwischen
0
und
1000
:
",
i);
EingabeFeld(10,
15,
"Name
:
",
s);

Zuerst
wird
für
alle
zu
bearbeitenden

Variablen
ein
Eingabefeld
definiert.

Diese
Definition
muß
innerhalb
der

Schleife
stehen,
weil
LiesEingaben

beim
Beenden
alle
Definitionen
löscht!
LiesEingaben;Jetzt
wird
der
Editor
für
die
Eingabe-

felder
aufgerufen.
    UNTIL
((0
>=
i)
AND
(i
<=
1000))
OR
(LetzteTaste
=
ESC);

Wurde
mit
ESC
abgebrochen?

≡≡EingabeVonTastatur

EingabeVonTastatur
aktiviert
die
Tastatur
als
Eingabemedium,
wenn
irgendwann
vorher
im
Programm
die
Eingabe
mit
EingabeVonDiskette
auf
die
Diskette
umgelenkt
wurde.
Beim
Start
eines
Programms
erfolgt
die
Eingabe
automatisch
über
die
Tastatur,
wenn
keine
andere
Anweisung
gegeben
wurde.

Deklaration
:
PROCEDURE
EingabeVonTastatur;

Beispiel
:

≡

VAR
    s
:
STRING;
BEGIN
    ÖffneEingabeDatei("EINGABEN.DAT");Eingabedatei
zuweisen
    EingabeVonDiskette;und
aktivieren
    Write("Eingabe
von
der
Diskette:");
    ReadLn(s);String
von
der
Diskette
lesen
    EingabeVonTastatur;Tastatur
aktivieren
    Write("Eingabe
von
der
Tastatur:");
    ReadLn(s);String
über
die
Tastatur
lesen
    SchließeEingabeDatei;Datei
wieder
schließen
END;

≡≡EingabeVonDiskette

EingabeVonDiskette
aktiviert
die
Diskette
anstelle
der
Tastatur
als
Eingabemedium,
wenn
irgendwann
vorher
im
Programm
mit
ÖffneEingabeDatei
eine
Datei
festgelegt
wurde,
aus
der
die
Zeichen
gelesen
werden
sollen.

Deklaration
:
PROCEDURE
EingabeVonDiskette;

Beispiel
:

≡

VAR
    s
:
STRING;
BEGIN
    ÖffneEingabeDatei("EINGABEN.DAT");Eingabedatei
zuweisen
    EingabeVonDiskette;und
aktivieren
    Write("Eingabe
von
der
Diskette:");
    ReadLn(s);String
von
der
Diskette
lesen
    EingabeVonTastatur;Tastatur
aktivieren
    Write("Eingabe
von
der
Tastatur:");
    ReadLn(s);String
über
die
Tastatur
lesen
    SchließeEingabeDatei;Datei
wieder
schließen
END;

≡≡ErsetzeBuchstaben

ErsetzeBuchstaben
ersetzt
einen
Buchstaben
eines
Strings
durch
einen
anderen.

Deklaration
:
PROCEDURE
ErsetzeBuchstaben(VAR
Zeichenkette
:
STRING;
WievielterBuchstabe
:
WORD;
DurchWelchenBuchstaben
:
CHAR);

Beispiel
:
s
:=
"abcdef";
ErsetzeBuchstaben(s,
3,
"x");
ersetzt
den
dritten
Buchstaben
"c"
durch
"x".
s
ist
dann
"abxdef".

≡≡FügeBuchstabenEin

FügeBuchstabenEin
fügt
einen
Buchstaben
oder
einen
String
in
einen
String
ab
einer
vorgegebenen
Position
ein.

Deklaration
:
PROCEDURE
FügeBuchstabenEin(WelchenBuchstaben
:
CHAR;
VAR
InZeichenkette
:
STRING;
WievielterBuchstabe
:
WORD);
PROCEDURE
FügeBuchstabenEin(WelcheZeichenkette
:
STRING;
VAR
InZeichenkette
:
STRING;
AbWelchemBuchstaben
:
WORD);

Beispiel
:

≡
1)
    s
:=
"abcdef";
    FügeBuchstabenEin("x",
s,
3);
fügt
den
Buchstaben
"x"
an
die
dritte
Stelle
zwischen
"b"
und
"c"
ein.
s
ist
dann
"abxcdef".

2)
    s
:=
"abcdef";
    t
:=
"xy";
    FügeBuchstabenEin(t,
s,
5);fügt
die
Zeichenkette
"xy"
beginnend
an
der
fünften
Stelle
zwischen
"d"
und
"e"
ein.
s
ist
dann
"abcdxyef".

≡≡InGrad

InGrad
bewirkt,
daß
alle
Berechnungen
mit
trigonometrischen
Funktionen
in
Grad
(Altgrad
:
α=360°
für
den
Vollkreis)
durchgeführt
werden.

Deklaration
:
PROCEDURE
InGrad;

Beispiel
:
InGrad;in
Grad
rechnen
WriteLn(sin(90));ergibt
1.00000..
ImBogenmaß;im
Bogenmaß
rechnen
WriteLn(sin(pi/2));ergibt
1.00000..

≡≡ImBogenmaß

ImBogenmaß
bewirkt,
daß
alle
Berechnungen
mit
trigonometrischen
Funktionen
im
Bogenmaß
(α=2*pi
für
den
Vollkreis)
durchgeführt
werden.
Beim
Start
eines
Programms
erfolgt
die
Berechnung
immer
in
Grad,
wenn
keine
andere
Anweisung
gegeben
wurde.

Deklaration
:
PROCEDURE
ImBogenmaß;

Beispiel
:
ImBogenmaß;im
Bogenmaß
rechnen
WriteLn(sin(pi/2));ergibt
1.00000..
InGrad;in
Grad
rechnen
WriteLn(sin(90));ergibt
1.00000..

≡≡LiesEingaben

Mit
LiesEingaben
wird
die
Eingabe
eines
Datensatzes
gestartet,
der
zuvor
elementweise
mit
EingabeFeld
definiert
wurde.
Dabei
kann
mit
den
Tasten
"Auf(CrsUp)",
"Ab(CrsDn)",
"Pos1(Home)"
und
"Ende(End)"
zwischen
den
Eingabefeldern
beliebig
oft
gewechselt
werden.
Die
Eingabe
wird
beendet,
wenn
in
dem
zuletzt
definierten
Feld
die
RETURN-Taste
gedrückt
wird
oder
in
einem
beliebigen
Feld
die
ESC-Taste
gedrückt
wird.

Deklaration
:
PROCEDURE
LiesEingaben;

Beispiel
:

≡

VAR
    r
:
REAL;
    i
:
INTEGER;
    s
:
STRING[20];
BEGIN
    r
:=
1.234;Belegung
der
Variablen
mit
Startwerten,
    i
:=
500;die
editiert
werden
sollen
    Name
:=
"Irgendwer";

≡

    REPEAT
EingabeFeld(5,
3,
"Dezimalzahl
:
",
r);
EingabeFeld(2,
6,
"ganze
Zahl
zwischen
0
und
1000
:
",
i);
EingabeFeld(10,
15,
"Name
:
",
s);

Zuerst
wird
für
alle
zu
bearbeitenden

Variablen
ein
Eingabefeld
definiert.

Diese
Definition
muß
innerhalb
der

Schleife
stehen,
weil
LiesEingaben

beim
Beenden
alle
Definitionen
löscht!
LiesEingaben;Jetzt
wird
der
Editor
für
die
Eingabe-

felder
aufgerufen.
    UNTIL
(0
<=
i)
AND
(i
<=
1000);

≡≡LöscheBuchstaben

LöscheBuchstaben
löscht
einen
oder
mehrere
aufeinanderfolgende
Buchstaben
beginnend
ab
einer
vorgegebenen
Stelle.

Deklaration
:
PROCEDURE
LöschenBuchstaben(VAR
Zeichenkette
:
STRING;
WelchenBuchstaben,
WievieleBuchstaben
:
WORD);

Beispiel
:
s
:=
"abxycdef";
LöscheBuchstaben(s,
3,
2);löscht
ab
dem
dritten
Buchstaben
zwei
Buchstaben.
s
ist
dann
"abcdef".

≡≡Menü

Menü
errichtet
ein
Pulldownmenü
an
einer
vorgegebenen
Stelle
des
Bildschirms
mit
vorgegebenen
Hotkeys,
über
die
ein
Menüpunkt
direkt
angewählt
werden
kann.
Dem
als
Hotkey
vorgesehenen
Buchstaben
wird
das
Zeichen
^
vorangestellt.
Innerhalb
des
Menüs
kann
der
Anwahlbalken
auch
mit
den
Tasten
"Auf(CrsUp)",
"Ab(CrsDn)",
"Ende(End)"
und
"Pos1(Home)"
verschoben
werden.
CR
aktiviert
den
mit
dem
Balken
unterlegten
Menüpunkt
und
liefert
als
Ergebnis
den
als
Hotkey
vorgesehenen
Buchstaben
zurück.
ESC
bricht
die
Anwahl
ab
und
liefert
ESC
(CHR(27))
als
Ergebnis.

Deklaration
:
PROCEDURE
Menü(x,
y
:
WORD;
Menüpunkte
:
STRING;
VAR
Angewählt
:
CHAR);

≡

Beispiel
:
VAR
    c
:
CHAR;
BEGIN
    REPEAT
Menü(10,
5,
"
^Laden;
^Bearbeiten;
^Speichern;
^Ende;",
c);
Das
Menü
hat
für
den
linken
oberen
Eckpunkt
die
Koordinaten
(10/5).
Als
Hotkeys
sind
"L",
"B",
"S"
und
"E"
durch
das
vorangestellte
"^"
definiert.
Die
einzelnen
Menüpunkte
werden
durch
ein
Semikolon
";"
getrennt.
Im
Menü
ist
beim
Start
die
oberste
Zeile
mit
"
Laden"
vollständig
hell
unterlegt.
In
den
folgenden
Zeilen
sind
es
die
Buchstaben
"B",
"S"
und
"E".
Durch
Drücken
der
RETURN-Taste
oder
des
"L"'s
erhält
c
den
Wert
"L".

≡

Auf
dem
Bildschirm
erscheint
das
folgende
Menü
:

╔════════════╗
║
Laden║Diese
Zeile
ist
hell
unterlegt.
║
Bearbeiten
║"B"
ist
hell
unterlegt.
║
Speichern║"S"
ist
hell
unterlegt.
║
Ende║"E"
ist
hell
unterlegt.
╚══════CR/ESC╝

≡

Jetzt
wird
die
Variable
c
ausgewertet
und
es
werden
die
einzelnen
Prozeduren
je
nach
Inhalt
von
c
aufgerufen.

CASE
c
OF
"L"
:
Laden;
"B"
:
Bearbeiten;
"S"
:
Speichern;
ELSE
ClrScr;Jeder
mögliche
Fall
muß
bei
CASE
berücksichtigt
werden,
sonst
kommt
es
zu
einem
Programm-Abbruch
END;
    UNTIL
(c
=
"E")
OR
(c
=
CHR(27));"E"
oder
ESC-Taste

≡≡MitCursor

In
ITG-PASCAL
ist
der
Cursor
normalerweise
nur
in
READ-Anweisungen
sichtbar.
Wenn
man
erreichen
will,
daß
der
Cursor
auch
sonst
sichtbar
ist,
muß
man
ihn
durch
MitCursor
einschalten.
Startvorgabe
eines
Programms
ist
ohne
Cursor.

Deklaration
:
PROCEDURE
MitCursor;

Beispiel
:

≡

MitCursor;Cursor
einschalten
Write("Geben
Sie
einen
Buchstaben
ein
:
");
Cursor
blinkt
hinter
":
"
c
:=
ReadKey;Zeichen
über
die
Tastatur
einlesen
OhneCursor;Cursor
ausschalten
Write("Geben
Sie
einen
Buchstaben
ein
:
");
Cursor
blinkt
nicht
hinter
":
"
c
:=
ReadKey;Zeichen
über
die
Tastatur
einlesen

≡≡MitProtokoll

ITG-PASCAL
protokolliert
alle
Textausgaben
mit
Write-
und
Read-
Anweisungen
in
einem
zweiten
Editorfenster
mit,
sofern
genügend
Speicherplatz
zur
Verfügung
steht.
Wenn
dieses
Protokoll
zwischendurch
durch
OhneProtokoll
abgeschaltet
wurde,
kann
es
durch
MitProtokoll
wieder
eingeschaltet
werden.
Startvorgabe
eines
Programms
ist
mit
Protokoll.

Deklaration
:
PROCEDURE
MitProtokoll;

Beispiel
:
OhneProtokoll;
Write("Dieser
Text
wird
nicht
im
zweiten
Editorfenster");
WriteLn("mitprotokolliert.");
MitProtokoll;
Write("Dieser
Text
wird
im
zweiten
Editorfenster");
WriteLn("mitprotokolliert.");

≡≡NeueZufallsZahlenFolge

NeueZufallsZahlenFolge
erzeugt
den
Anfang
einer
neuer
Folge
von
Zufallszahlen.

Deklaration
:
PROCEDURE
NeueZufallsZahlenFolge;

Beispiel
:
NeueZufallsZahlenFolge;Anfang
einer
neuen
Folge
erzeugen
Write(GanzeZufallsZahl(100));Zufallszahl
zwischen
0
und
99
drucken


≡≡ÖffneAusgabeDatei

Bevor
die
Ausgabe,
die
mit
Write
/
WriteLn
normalerweise
auf
den
Bildschirm
erfolgt,
mit
AusgabeAufDiskette
auf
die
Diskette
/
Festplatte
umgelenkt
wird,
muß
eine
Ausgabedatei
mit
ÖffneAusgabeDatei(DateiName)
geöffnet
werden!

Deklaration
:
PROCEDURE
ÖffneAusgabeDatei(DateiName
:
STRING);

Beispiel
:
ÖffneAusgabeDatei("AUSGABE.TXT");
AusgabeAufDiskette;
WriteLn("Diese
Ausgabe
erfolgt
auf
Diskette!");
AusgabeAufBildschirm;
WriteLn("Diese
Ausgabe
erfolgt
auf
den
Bildschirm.");
SchließeAusgabeDatei;

≡≡ÖffneEingabeDatei

Bevor
die
Eingabe,
die
normalerweise
über
die
Tastatur
erfolgt,
mit
EingabeVonDiskette
auf
die
Diskette
/
Festplatte
umgelenkt
werden
kann,
muß
mit
ÖffneEingabeDatei
zum
Lesen
deklariert
werden.

Deklaration
:
PROCEDURE
ÖffneEingabeDatei(DateiName
:
STRING);

Beispiel
:

≡

VAR
    s
:
STRING;
BEGIN
    ÖffneEingabeDatei("EINGABEN.DAT");Eingabedatei
zuweisen
    EingabeVonDiskette;und
aktivieren
    Write("Eingabe
von
der
Diskette:");
    ReadLn(s);String
von
der
Diskette
lesen
    EingabeVonTastatur;Tastatur
aktivieren
    Write("Eingabe
von
der
Tastatur:");
    ReadLn(s);String
über
die
Tastatur
lesen
    SchließeEingabeDatei;Datei
wieder
schließen
END;

≡≡ÖffneFenster

ÖffneFenster
speichert
den
augenblicklichen
Inhalt
des
Textbildschirmes
ab
und
definiert
ein
neues
Textfenster,
das
mit
einem
Rahmen
versehen
werden
kann.
Der
linke
obere
Eckpunkt
des
Fensters
ist
für
alle
jetzt
folgenden
Textausgaben
der
 Punkt
P(1/1).
Jedes
Fenster,
das
geöffnet
wurde,
muß
auch
wieder
geschlossen
werden!

Deklaration
:
PROCEDURE
ÖffneFenster(xLinks,
yOben,
xRechts,
yUnten,
MitOderOhneRahmen
:
INTEGER);


Es
muß
gelten
:
1
<=
xLinks
<
xRechts
<=
80
1
<=
yOben<
yUnten<=
25
MitOderOhneRahmenε{
MitRahmen,
OhneRahmen
}

Beispiel
:

≡

GotoXY(10,
10);
Write("Dieser
Text
verschwindet
unter
dem
Fenster");
Delay(2000);
ÖffneFenster(5,
5,
75,
20,
MitRahmen);alten
Bildschirminhalt
sichern
und
Fenster
öffnen
ClrScr;Fensterinhalt
löschen
GotoXY(5,
5);relative
Koordinaten
im
Fenster
Write("absolute
Koordinaten
(10/10)");
Delay(2000);2
Sekunden
warten
SchließeFenster;alten
Bildschirminhalt
wiederherstellen
und
altes
Fenster
wieder
öffnen
Delay(2000);

≡≡OhneCursor

In
ITG-PASCAL
ist
der
Cursor
normalerweise
nur
in
READ-Anweisungen
sichtbar.
Wenn
man
erreichen
will,
daß
der
Cursor
auch
sonst
sichtbar
ist,
muß
man
ihn
durch
MitCursor
einschalten.
Durch
OhneCursor
wird
er
wieder
abgeschaltet.
Startvorgabe
eines
Programms
ist
ohne
Cursor.

Deklaration
:
PROCEDURE
OhneCursor;

Beispiel
:

≡

MitCursor;Cursor
einschalten
Write("Geben
Sie
einen
Buchstaben
ein
:
");Cursor
steht
hinter
":
"
c
:=
ReadKey;
Zeichen
über
die
Tastatur
einlesen
OhneCursor;Cursor
ausschalten
Write("Geben
Sie
einen
Buchstaben
ein
:
");Cursor
blinkt
nicht
hinter
":
"
c
:=
ReadKey;
Zeichen
über
die
Tastatur
einlesen

≡≡OhneProtokoll

ITG-PASCAL
protokolliert
alle
Textausgaben
mit
Write-
und
Read-
Anweisungen
in
einem
zweiten
Editorfenster
mit,
sofern
genügend
Speicherplatz
zur
Verfügung
steht.
Dieses
Protokoll
kann
durch
OhneProtokoll
abgeschaltet
werden.
Startvorgabe
eines
Programms
ist
mit
Protokoll.

Deklaration
:
PROCEDURE
OhneProtokoll;

Beispiel
:
OhneProtokoll;
Write("Dieser
Text
wird
nicht
im
zweiten
Editorfenster");
WriteLn("mitprotokolliert.");
MitProtokoll;
Write("Dieser
Text
wird
im
zweiten
Editorfenster");
WriteLn("mitprotokolliert.");

≡≡Pause

Pause
unterbricht
ein
Programm
solange,
bis
die
RETURN-Taste
gedrückt
wird.

Deklaration
:
PROCEDURE
Pause;

Beispiel
:
WriteLn("Weiter
mit
der
RETURN-Taste");
Pause;auf
Drücken
der
RETURN-
Taste
warten
WriteLn("Die
RETURN-Taste
wurde
betätigt");

≡≡SchließeAusgabeDatei

Wenn
die
Ausgabe,
die
mit
Write
/
WriteLn
normalerweise
auf
den
Bildschirm
erfolgt,
mit
AusgabeAufDiskette
auf
die
Diskette
/
Festplatte
umgelenkt
wurde,
muß
die
Ausgabedatei
vor
dem
Programmende
mit
SchließeAusgabeDatei
geschlossen
werden!

Deklaration
:
PROCEDURE
SchließeAusgabeDatei;

Beispiel
:
ÖffneAusgabeDatei("AUSGABE.TXT");
AusgabeAufDiskette;
WriteLn("Diese
Ausgabe
erfolgt
auf
Diskette!");
AusgabeAufBildschirm;
WriteLn("Diese
Ausgabe
erfolgt
auf
den
Bildschirm.");
SchließeAusgabeDatei;

≡≡SchließeEingabeDatei

SchließeEingabeDatei
schließt
die
Datei,
die
mit
ÖffneEingabeDatei
zum
Lesen
von
Eingaben
anstelle
der
Tastatur
geöffnet
wurde.

Deklaration
:
PROCEDURE
SchließeEingabeDatei;

Beispiel
:

≡

VAR
    s
:
STRING;
BEGIN
    ÖffneEingabeDatei("EINGABEN.DAT");Eingabedatei
zuweisen
    EingabeVonDiskette;und
aktivieren
    Write("Eingabe
von
der
Diskette:");
    ReadLn(s);String
von
der
Diskette
lesen
    EingabeVonTastatur;Tastatur
aktivieren
    Write("Eingabe
von
der
Tastatur:");
    ReadLn(s);String
über
die
Tastatur
lesen
    SchließeEingabeDatei;Datei
wieder
schließen
END;

≡≡SchließeFenster

SchließeFenster
stellt
den
Inhalt
und
die
Fensterkoordinaten
des
Textfensters
wieder
her,
wie
es
dem
Aufruf
der
Prozedur
ÖffneFenster
vorhanden
war.
Es
dürfen
mehrere
Fenster
gleichzeitig
geöffnet
sein.
Geschlossen
wird
immer
das
zuletzt
geöffnete
Fenster.
Jedes
Fenster,
das
geöffnet
wurde,
muß
auch
wieder
geschlossen
werden!

Deklaration
:
PROCEDURE
SchließeFenster;

Beispiel
:

≡

GotoXY(10,
10);
Write("Dieser
Text
verschwindet
unter
dem
Fenster");
Delay(2000);
ÖffneFenster(5,
5,
75,
20,
MitRahmen);alten
Bildschirminhalt
sichern
und
Fenster
öffnen
ClrScr;Fensterinhalt
löschen
GotoXY(5,
5);relative
Koordinaten
im
Fenster
Write("absolute
Koordinaten
(10/10)");
Delay(2000);2
Sekunden
warten
SchließeFenster;alten
Bildschirminhalt
wiederherstellen
und
altes
Fenster
wieder
öffnen
Delay(2000);

≡≡SchreibPort

Mit
SchreibPort
wird
ein
Wert
über
einen
Port
des
Computers
an
die
Peripherie
ausgegeben.
ACHTUNG:
Vor
der
Benutzung
dieser
Anweisung
sollte
man
sich
aber
genau
informieren,
da
ein
Schreiben
in
einen
falschen
Port
zu
Zerstörungen
führen
kann!

Deklaration
:
PROCEDURE
SchreibPort(PortAdresse,
Ausgabewert
:
WORD);

Beispiel
:
SchreibPort(PortAdresse,
Ausgabewert);schreibt
den
Ausgabewert
an
die
Portadresse

≡≡StarteStopUhr

StarteStopUhr
setzt
die
Zeit
für
eine
Stopuhr
auf
0
und
startet
eine
Zeitmessung.
Die
während
der
Programmausführung
verstrichene
Zeit
kann
mit
der
Funktion
StopZeit
ausgelesen
werden.

StarteStopUhr
wird
automatisch
bei
jedem
Programmstart
aufgerufen.

Deklaration
:
PROCEDURE
StarteStopUhr;

Beispiel
:
StarteStopUhr;Stopuhr
auf
0
setzen
TueIrgendetwas;
Write(StopZeit);Zeitdauer
in
Sekunden
anzeigen,
die
für
TueIrgendetwas
benötigt
wurden.

≡≡Ton

Ton
erzeugt
einen
Ton
mit
vorgegebener
Frequenz
und
Dauer.

Deklaration
:
PROCEDURE
Ton(Frequenz,
MilliSekunden
:
WORD);

Beispiel
:
Ton(440,
1000);erzeugt
für
1000ms
(1s)
einen
Ton
der
Frequenz
440Hz

≡≡Vertausche

Vertausche
vertauscht
die
Inhalte
zweier
Variablen
beliebigen
Typs
außer
FILE-
und
 TEXT-Variablen
gegeneinander.

Deklaration
:
PROCEDURE
Vertausche(VAR
a,
b
:
VariableBeliebigenTyps);

Beispiel
:
a
:=
"a";Wertzuweisungen
b
:=
"b";
Vertausche(a,
b);jetzt
hat
a
den
Inhalt
"b"
und
b
den
Inhalt
"a"

≡≡WähleDatei

WähleDatei(x,
y,
Maske,
Dateiname)
öffnet
ein
Auswahlfenster
mit
dem
linken
oberen
Eckpunkt
P(x/y)
als
Bildschirmkoordinaten,
in
dem
alle
Verzeichnisse
und
alle
Dateien,
die
der
Maske
entsprechen,
angezeigt
werden.
Mit
den
Cursortasten
wird
ein
Verzeichnis
oder
ein
Dateiname
angewählt.
Im
Falle
eines
Verzeichnisses
wird
in
dieses
vorübergehend
gewechselt,
im
Falle
eines
Dateinamens
wird
dieser
an
das
ausführende
Programm
übergeben.
Mit
der
ESC-Taste
kann
die
Wahl
abgebrochen
werden.
Der
Dateiname
ist
dann
leer.
Der
Bildschirm
wird
nach
Verlassen
des
Menüs
automatisch
restauriert.

Deklaration
:
PROCEDURE
WähleDatei(x,
y
:
INTEGER;
Maske
:
STRING;
VAR
Dateiname
:
STRING);

≡

Beispiel
:
VAR

Dateiname
:
STRING;
BEGIN

WähleDatei(10,
3,
"*.PAS",
Dateiname);alle
PASCAL-Programme
anzeigen

IF
Dateiname
<>
""
THEN
BEGIN
DatenVonDiskette(Dateiname,
Variable);
Inhalt
der
Datei
an

END;Variable
übergaben
END;

≡≡Debugger

DebugEin
DebugAus
BreakPoint
EinzelschrittEin
EinzelschrittAus

≡≡DebugEin

Ab
diesem
Zeitpunkt
werden
alle
durch
ein
in
der
Deklaration
vorangestelltes
"!"
markierten
Variablen
mit
ihrem
Wert
und
der
Quelltextzeile
angezeigt,
bis
die
Anweisung
DebugAus
ausgeführt
wird.

Zusätzlich
zur
Anzeige
auf
dem
Bildschirm
werden
alle
Informationen
in
ein
zweites
Editor-Fenster
geschrieben,
sofern
genügend
Speicherplatz
zur
Verfügung
steht,
und
können
nach
Beendigung
des
Programms
unter
"Editor
/
Programm-/Fehler-Ausgabe
ansehen"
betrachtet
und
gegebenenfalls
auch
mit
"Blockschreiben"
auf
Diskette
gespeichert
werden.

2
Beispiele
:

≡


1)
PROCEDURE
p(!a,
b
:
INTEGER);

(*
nur
die
Variable
a
ist
markiert,
b
nicht
*)
VAR
c,
!d
:
REAL;

(*
nur
die
Variable
d
ist
markiert,
c
nicht
*)
BEGIN
c
:=
a^b;

(*
keine
Ausgabe
der
Variablen
*)
DebugEin;

(*
Quelltextausgabe
und
Ausgabe
der
Variablen
wird
ab
hier
ausgeführt
*)
d
:=
c
/
a;
c
:=
d
*
c;
DebugAus;

(*
Ausgabe
wird
nicht
mehr
durchgeführt
*)
b
:=
a;
END;
≡

2)
PROGRAM
Fakultät;
VAR
!n,
!m
:
INTEGER;
FUNCTION
Fak(!n
:
GanzeZahl)
:
INTEGER;
VAR

!f
:
INTEGER;
(*
f
wird
hier
benutzt,
weil
Funktionsergebnisse
sonst
nicht
angezeigt
werden.
*)
BEGIN
IF
n
>
1
THEN
BEGIN

f
:=
n
*
Fak(n-1);
END
ELSE
BEGIN

f
:=
1;
END;
Fak
:=
f;
END;
≡

BEGIN
n
:=
3;
Write('Berechnung
von
n!n
=
');
ReadLn(n);
DebugEin;
(*
Nur
während
der
rekursiven
Funktionsaufrufe
werden
die
Inhalte
der
Variablen
angezeigt.
Dabei
ist
die
Rekursionsstufe
zu
erkennen,
wie
im
folgenden
Beispiel
für
3!
gezeigt
wird.
*)
m
:=
Fak(n);
DebugAus;
WriteLn(n,
'!=',
m);
END.

≡

Berechnung
von
n!n
=
3
(*
hier
normale
Textausgabe
mit
"WRITE"
*)
    IF
n
>
1
THEN
BEGIN
10>
F
=
0N
=
3|
M
=
0N
=
3
^
Globale
Variablen
stehen
immer
am
Ende
der
Liste
nach
dem
letzten
"|".
    ^
Lokale
Variablen
führen
die
Liste
vor
dem
letzten
"|"
an.
Die
Variablen
der
gerade
aktiven
Prozedur/Funktion
stehen
ganz
links,
danach
folgen
die
Variablen
der
Prozedur/Funktion,
aus
der
die
gerade
aktive
aufgerufen
wurde
usw.
bis
zu
den
globalen
Variablen.
Hier
stehen
in
diesem
Fall
die
Variablen
des
ersten
Aufrufs
der
Funktion
"Fak".

≡

    IF
n
>
1
THEN
BEGIN
10>
F
=
0N
=
2|
F
=
0N
=
3|
M
=
0N
=
3
^
globale
Variablen
^
erster
Aufruf
von
"Fak"
    ^
zweiter
Aufruf
von
"Fak"
    f
:=
1;
14>
F
=
1N
=
1|
F
=
0N
=
2|
F
=
0N
=
3|
M
=
0N
=
3
^global
^
erster
Aufruf
von
"Fak"
^
zweiter
Aufruf
von
"Fak"
    ^
dritter
Aufruf
von
"Fak"
Jetzt
ist
n
=
1.
Damit
werden
die
rekursiven
Aufrufe
beendet
und
es
geht
rückwärts,
wie
in
den
nächsten
Zeilen
zu
sehen
ist.

≡

    Fak
:=
f;
16>
F
=
1N
=
1|
F
=
0N
=
2|
F
=
0N
=
3|
M
=
0N
=
3
    f
:=
n
*
Fak(n-1);
11>
F
=
2N
=
2|
F
=
0N
=
3|
M
=
0N
=
3
    Fak
:=
f;
16>
F
=
2N
=
2|
F
=
0N
=
3|
M
=
0N
=
3
    f
:=
n
*
Fak(n-1);
11>
F
=
6N
=
3|
M
=
0N
=
3
    Fak
:=
f;
16>
F
=
6N
=
3|
M
=
0N
=
3
    m
:=
Fak(n);
24>
M
=
6N
=
3
    3!=6

≡≡DebugAus

Schaltet
die
Ausgabe
der
Inhalte
der
markierten
Variablen
und
der
Quelltextzeile
aus.

Eine
ausführlichere
Beschreibung
und
ein
Beispiel
sind
unter
DebugEin
zu
finden.

≡≡BreakPoint

An
dieser
Stelle
wird
ein
laufendes
Programm
unterbrochen
und
es
erscheint
folgendes
Menü
am
Bildschirmrand:

╔═════BreakPoint════╗
║
Run║
║
Variablen
zeigen║
║
weitere
Variablen
║
║
Variablen
ändern║
║
Menü-Lage    ║
║
Programm-Abbruch║
╚═══════════════════╝

Die
Bedeutung
der
einzelnen
Menüpunkte:

≡

1)
Run:
Das
Programm
wird
fortgesetzt,
bis
es
beendet
ist
oder
bis
es
wieder
auf
die
Anweisung
"BreakPoint"
trifft.

2)
Variablen
zeigen:
Der
Inhalt
der
durch
"!"
markierten
Variablen
und
der
im
nächsten
Punkt
"weitere
Variablen"
markierten
wird
angezeigt,
wie
unter
"DebugEin"
beschrieben.

3)
weitere
Variablen:
Zusätzlich
zu
den
in
der
Deklaration
mit
"!"
markierten
Variablen
können
weitere
in
einem
Auswahlfenster
mit
"ENTER"
markiert
werden.
Ebenso
ist
ein
Löschen
der
Markierung
mit
"ENTER"
möglich.
Markierte
Variablen
sind
durch
ein
vorangestelltes
"√"
gekennzeichnet.
Die
Reihenfolge
der
Variablen
im
Auswahlfenster
ist
unter
4)
beschrieben.

≡

4)
Variablen
ändern:
Wenn
man
testen
möchte,
wie
das
Programm
mit
anderen
Variablenwerten
weiterläuft,
kann
sich
in
einem
Auswahlfenster
Variablen
mit
"ENTER"
wählen,
deren
Inhalt
anschließend
in
einem
Editorfenster
geändert
werden
kann.
Lokale
Variablen
erscheinen
oben
im
Auswahlfenster,
globale
Variablen
zuletzt.
Dabei
wird
dieselbe
Reihenfolge
wie
unter
"DebugEin"
beschrieben
eingehalten,
es
sind
nur
links
mit
oben
und
rechts
mit
unten
zu
vertauschen.

≡

5)
Menü-Lage:
Wenn
dieses
Menü
Informationen
verdeckt,
kann
es
in
eine
andere
Bildschirmecke
verschoben
werden.
Die
Lage
des
Menüs
wechselt
dabei
zyklisch
zwischen
den
Positionen
links
oben,
rechts
oben,
links
unten
und
rechts
unten.

6)
Programm-Abbruch:
Das
Programm
wird
sofort
beendet.
Dabei
erfolgt
ein
Post-Mortem-Dump.

≡≡EinzelschrittEin

EinzelschrittEin
bewirkt,
daß
jeweils
nur
eine
Programmzeile
abgearbeitet
wird.
Anschließend
wartet
das
Programm
auf
einen
Tastendruck,
dann
wird
die
nächste
Programmzeile
abgearbeitet.

Beispiel
:
DebugEin;Inhalt
der
markierten
Variablen
wird
angezeigt
EinzelschrittEin;warte
jeweils
nach
Ausführung
einer
Programmzeile
auf
einen
Tastendruck
FOR
n
:=
1
TO
100
DO
BEGIN
m
:=
n^2;
END;
EinzelschrittAus;setze
die
Programmausführung
ohne
Warten
auf
Tastendruck
fort
DebugAus;zeige
die
Variableninhalte
nicht
mehr
an

≡≡EinzelschrittAus

EinzelschrittAus
bewirkt,
daß
nach
Ausführung
einer
Programmzeile
nicht
mehr
auf
einen
Tastendruck
gewartet
wird.

Beispiel:
DebugEin;Inhalt
der
markierten
Variablen
wird
angezeigt
EinzelschrittEin;warte
jeweils
nach
Ausführung
einer
Programmzeile
auf
einen
Tastendruck
FOR
n
:=
1
TO
100
DO
BEGIN
m
:=
n^2;
END;
EinzelschrittAus;setze
die
Programmausführung
ohne
Warten
auf
Tastendruck
fort
DebugAus;zeige
die
Variableninhalte
nicht
mehr
an

≡≡parallele·Prozesse

NächsterProzeßNeuerProzeß    ProzeßEnde
SendeSignal    StarteProzesseStarteZeitscheibenVerfahren
UnterbrechungWarteAufSignal

Mit
parallelen
Prozessen
kann
Einblick
genommen
werden
in
die
Programm-
ausführung
von
Multitaskingsystemen,
auf
denen
mehrere
Programme
quasi
gleichzeitig
von
einem
Prozessor
abgearbeitet
werden,
und
Mehrprozessorsystemen,
bei
denen
mehrere
Prozessoren
gleichzeitig
an
einem
Programm
arbeiten.
Dabei
ist
die
Prozeßumschaltung
und
die
Prozeßsynchronisation
von
Bedeutung.

≡≡NächsterProzeß

NächsterProzeß(ProzeßIndex)
dient
dazu,
die
weitere
Programmausführung
einem
bestimmten
Prozeß
zu
übergeben.

Deklaration
:
PROCEDURE
NächsterProzeß(ProzeßIndex
:
INTEGER);

Beispiel:
PROCEDURE
P1;
BEGIN
    WriteLn("1.:
P1");
    NächsterProzeß(2);an
P2
übergeben
    WriteLn("5.:
P1");
    ProzeßEnde(1);P1
ordnungsgemäß
beenden
END;

≡

PROCEDURE
P2;
BEGIN
    WriteLn("2.:
P2");
    NächsterProzeß(3);an
P3
übergeben
    WriteLn("4.:
P2");
    NächsterProzeß(1);an
P1
übergeben
    ProzeßEnde(2);P2
ordnungsgemäß
beenden
END;

PROCEDURE
P3;
BEGIN
    WriteLn("3.:
P3");
    NächsterProzeß(2);an
P2
übergeben
    ProzeßEnde(3);P3
ordnungsgemäß
beenden
END;

≡

BEGIN
    NeuerProzeß(1,
100,
1,
P1);Prozesse
definieren,
Index
festlegen,
    NeuerProzeß(2,
100,
1,
P2);Stackgröße
und
Priorität
festlegen,
    NeuerProzeß(3,
100,
1,
P3);Prozeßprozedur
festlegen
    StarteProzesse;ersten
Prozeß
starten
END.

Auf
dem
Bildschirm
erscheint:

1.:P1
2.:P2
3.:P3
4.:P2
5.:P1

≡≡NeuerProzeß

NeuerProzeß
reiht
eine
parameterlose
Prozedur
in
die
Liste
der
Prozeduren
ein,
zwischen
denen
wie
bei
einem
Multitaskingsystem
hin-
und
her-
geschaltet
werden
kann.

Deklaration
:
PROCEDURE
NeuerProzeß(Index,
StackGröße,
Priorität
:
INTEGER;
Prozeß
:
parameterlose
Prozedur);

Beispiel:

≡

PROCEDURE
P1;
BEGIN
    WriteLn("1.:
P1");
    NächsterProzeß(2);an
P2
übergeben
    WriteLn("3.:
P1");
    ProzeßEnde(1);P1
ordnungsgemäß
beenden
END;

PROCEDURE
P2;
BEGIN
    WriteLn("2.:
P2");
    NächsterProzeß(1);an
P1
übergeben
    ProzeßEnde(2);P2
ordnungsgemäß
beenden
END;

≡

BEGIN
    NeuerProzeß(1,
100,
1,
P1);Prozesse
definieren,
Index
festlegen,
    NeuerProzeß(2,
100,
1,
P2);Stackgröße
und
Priorität
festlegen,
    StarteProzesse;Prozeßprozedur
festlegen
END.ersten
Prozeß
starten

≡≡ProzeßEnde

ProzeßEnde
sorgt
dafür,
daß
ein
Prozeß
ordnungsgemäß
beendet
wird.
Jeder
Prozeß
muß
entweder
aus
einer
Endlosschleife
bestehen
oder
durch
die
Anweisung
ProzeßEnde
vor
dem
Erreichen
der
END-Anweisung
der
Prozeßprozedur
beendet
werden.

Deklaration
:
PROCEDURE
ProzeßEnde(ProzeßIndex
:
INTEGER);

Beispiel:
ProzeßEnde(1);beendet
den
Prozeß
mit
dem
Index
1

≡≡SendeSignal

Durch
SendeSignal(SignalVar)
kann
einem
anderen
Prozeß
mitgeteilt
werden,
daß
die
Bearbeitung
bis
zu
einem
bestimmten
Punkt
vorangeschritten
ist.

Deklaration
:
PROCEDURE
SendeSignal(VAR
SignalVar
:
SIGNAL);

Beispiel:
VAR
    P1Fertig,
P2Fertig
:
SIGNAL;
    x,
y
:
REAL;

≡

PROCEDURE
P1;
BEGIN
    x
:=
0.1;
    WHILE
x
<
10
DO
BEGIN
SendeSignal(P1Fertig);x-Wert
fertig,
P2
kann
rechnen
WarteAufSignal(P2Fertig);warten,
bis
P2
mit
Rechnung
fertig
x
:=
x
+
y;und
gültiger
y-Wert
vorhanden
    END;
    ProzeßEnde(1);Prozesse
beenden
    ProzeßEnde(2);
END;

≡

PROCEDURE
P2;
BEGIN
    y
:=
0.3;
    WHILE
TRUE
DO
BEGIN
WarteAufSignal(P1Fertig);auf
gültigen
x-Wert
warten
y
:=
y
+
x;
SendeSignal(P2Fertig);P1
kann
auf
y-Wert
zugreifen
    END;
END;

BEGIN
    NeuerProzeß(1,
100,
1,
P1);Prozesse
initialisieren
    NeuerProzeß(2,
100,
1,
P2);
    StarteProzesse;
END.

≡≡StarteProzesse

StarteProzesse
sucht
beginnend
beim
Prozeßindex
1
den
Prozeß
mit
der
höchsten
Priorität
und
startet
ihn.

Deklaration
:
PROCEDURE
StarteProzesse;

Beispiel:

≡

PROCEDURE
P1;
BEGIN
    WriteLn("1.:
P1");
    NächsterProzeß(2);an
P2
übergeben
    WriteLn("3.:
P1");
    ProzeßEnde(1);P1
ordnungsgemäß
beenden
END;

PROCEDURE
P2;
BEGIN
    WriteLn("2.:
P2");
    NächsterProzeß(1);an
P1
übergeben
    ProzeßEnde(2);P2
ordnungsgemäß
beenden
END;

≡

BEGIN
    NeuerProzeß(1,
100,
1,
P1);Prozesse
definieren,
Index
festlegen,
    NeuerProzeß(2,
100,
1,
P2);Stackgröße
und
Priorität
festlegen,
    StarteProzesse;Prozeßprozedur
festlegen
END.ersten
Prozeß
starten

≡≡StarteZeitscheibenVerfahren

StarteZeitscheibenVerfahren
startet
alle
initialisierten
Prozesse
und
sorgt
dafür,
daß
nach
der
Ausführung
einer
vorgegebenen
Anzahl
von
Opcodes
der
aktive
Prozeß
gewechselt
wird.
ACHTUNG:
Ein
aktiver
Prozeß
sollte
die
Kontrolle
dann
nicht
mit
========
"Unterbrechung"
an
den
nächsten
Prozeß
abgeben.

Deklaration
:
PROCEDURE
StarteZeitscheibenVerfahren(AnzahlDerOpcodes
:
INTEGER);

Beispiel:

≡

PROCEDURE
P1;
    VAR
n
:
INTEGER;
BEGIN
    FOR
n
:=
1
TO
1000
DO
BEGIN
Write(n:5);
    END;
    HALT;
END;

≡

PROCEDURE
P2;
    VAR
n
:
INTEGER;
BEGIN
    FOR
n
:=
2000
TO
3000
DO
BEGIN
Write(n:5);
    END;
    HALT;
END;

≡

BEGIN
    NeuerProzeß(1,
100,
1,
P1);Prozesse
definieren,
Index
fest-
    NeuerProzeß(2,
100,
1,
P2);legen,
Stackgröße
und
Priorität
    StarteZeitscheibenVerfahren(10);festlegen,
Prozeßprozedur
fest-
END.
legen
und
ersten
Prozeß
starten.
Nach
der
Ausführung
von
10
Opcodes
erfolgt
eine
Umschaltung.

≡≡Unterbrechung

Unterbrechung
unterbricht
die
Ausführung
eines
Prozesses
und
sucht
den
aktiven
Prozeß
in
der
Warteliste,
der
zur
Zeit
die
höchste
Priorität
hat.
Dieser
Prozeß
wird
fortgesetzt.
Seine
Priorität
wird
dabei
um
eins
verringert,
damit
er
bei
der
nächsten
Unterbrechung
nicht
unbedingt
wieder
der
Prozeß
mit
der
höchsten
Priorität
ist.

Deklaration
:
PROCEDURE
Unterbrechung;

≡

Beispiel:
PROCEDURE
P1;
    VAR
n
:
INTEGER;
BEGIN
    FOR
n
:=
1
TO
1000
DO
BEGIN
GotoXY(10,
3);
Write(n:4);
Unterbrechung;unterbrechen
und
auf
den
Prozeß
mit
    END;der
derzeit
höchsten
Priorität
    HALT;umschalten
END;

≡

PROCEDURE
P2;
    VAR
n
:
INTEGER;
BEGIN
    FOR
n
:=
1
TO
1000
DO
BEGIN
GotoXY(20,
3);
Write(n:4);
Unterbrechung;unterbrechen
und
auf
den
Prozeß
mit
    END;der
derzeit
höchsten
Priorität
    HALT;umschalten
END;

≡

BEGIN
    NeuerProzeß(1,
100,
3,
P1);da
die
Priorität
von
P1
dreimal
so
    NeuerProzeß(2,
100,
1,
P2);hoch
ist
wie
die
von
P2,
wird
P1
auch
    StarteProzesse;dreimal
so
oft
aufgerufen
wie
P2.
END.Zählstände
am
Ende
:
P1:1000,
P2:333

≡≡WarteAufSignal

Durch
WarteAufSignal(SignalVar)
kann
solange
gewartet
werden,
bis
die
Bearbeitung
in
einem
anderen
Prozeß
bis
zu
einem
bestimmten
Punkt
vorangeschritten
ist.

Deklaration
:
PROCEDURE
WarteAufSignal(VAR
SignalVar
:
SIGNAL);

Beispiel:
VAR
    P1Fertig,
P2Fertig
:
SIGNAL;
    x,
y
:
REAL;

≡

PROCEDURE
P1;
BEGIN
    x
:=
0.1;
    WHILE
x
<
10
DO
BEGIN
SendeSignal(P1Fertig);x-Wert
fertig,
P2
kann
rechnen
WarteAufSignal(P2Fertig);warten,
bis
P2
mit
Rechnung
fertig
x
:=
x
+
y;und
gültiger
y-Wert
vorhanden
    END;
    ProzeßEnde(1);Prozesse
beenden
    ProzeßEnde(2);
END;

≡

PROCEDURE
P2;
BEGIN
    y
:=
0.3;
    WHILE
TRUE
DO
BEGIN
WarteAufSignal(P1Fertig);auf
gültigen
x-Wert
warten
y
:=
y
+
x;
SendeSignal(P2Fertig);P1
kann
auf
y-Wert
zugreifen
    END;
END;

BEGIN
    NeuerProzeß(1,
100,
1,
P1);Prozesse
initialisieren
    NeuerProzeß(2,
100,
1,
P2);
    StarteProzesse;
END.

≡≡Fischertechnik·LEGO


 Aus EinLinksDrehenRechtsDrehen
Lampe
Motor
Warte
Zustand

Die
hier
aufgeführten
Konstanten,
Prozeduren
und
Funktionen
stehen
nur
dann
zur
Verfügung,
wenn
ITG-PASCAL
aus
dem
mitgelieferten
Rahmenprogramm
zur
Ansteuerung
von
Interfaces
heraus
gestartet
wurde.

ACHTUNG:
Wenn
der
Start
nicht
aus
dem
Rahmenprogramm
heraus
gestartet
========
wurde,
kommt
es
bei
Verwendung
der
hier
aufgeführten
Konstanten,
Prozeduren
und
Funktionen
zu
einer
Fehlermeldung
beim
compilieren,
obwohl
ein
Programm
unter
Umständen
schon
fehlerfrei
lief!

≡≡ Aus

Die
Konstante
Aus
dient
zum
Ausschalten
von
Lampen
und
Motoren.
Ihr
Wert
ist
0.

≡≡ Ein

Die
Konstante
Ein
dient
zum
Einschalten
von
Lampen.
Ihr
Wert
ist
1.

≡≡LinksDrehen

Die
Konstanten
LinksDrehen
dient
dazu,
einen
Motor
gegen
den
Uhrzeiger-
sinn
drehen
zu
lassen.
Ihr
Wert
ist
1.

≡≡RechtsDrehen

Die
Konstanten
RechtsDrehen
dient
dazu,
einen
Motor
im
den
Uhrzeigersinn
drehen
zu
lassen.
Ihr
Wert
ist
2.

≡≡Lampe

Mit
der
Prozedur
Lampe(Nr,
Ein)
wird
die
Spannung
am
Ausgang
mit
dem
Index
Nr
eingeschaltet.

Deklaration
:
PROCEDURE
Lampe(Nr,
AusOderEin
:
WORD);

Beispiel
:
Lampe(3,
Ein);Lampe
3
einschalten
und
Warte(1.5);1,5
Sekunden
lang
brennen
lassen
Lampe(3,
Aus);dann
wieder
ausschalten

≡≡Motor

Mit
der
Prozedur
Motor(Nr,
Drehrichtung)
wird
die
Spannung
am
Motor-
Ausgang
mit
dem
Index
Nr
so
eingeschaltet,
daß
der
Motor
sich
in
die
angegebene
Richtung
dreht.

Deklaration
:
PROCEDURE
Motor(Nr,
Drehrichtung
:
WORD);

Beispiel
:
Motor(3,
LinksDrehen);Motor
3
einschalten
und
1,5
Sekunden
nach
Warte(1.5);links
drehen
lassen
Motor(3,
Aus);dann
wieder
ausschalten

≡≡Warte

Mit
der
Prozedur
Warte(Sekunden)
wird
die
automatische
Abschaltung
beim
Fischer-Interface
unterbunden,
die
sonst
nach
0,5
Sekunden
eintritt.

Deklaration
:
PROCEDURE
Warte(Sekunden
:
REAL);

Beispiel
:
Lampe(3,
Ein);Lampe
3
einschalten
und
Warte(1.5);1,5
Sekunden
lang
brennen
lassen
Lampe(3,
Aus);dann
wieder
ausschalten

≡≡Zustand

Die
Funktion
Zustand(Nr)
ergibt
1,
wenn
am
Digitaleingang
mit
dem
Index
Nr
eine
Spannung
anliegt.
Sonst
ergibt
sie
0.

Deklaration
:
FUNCTION
Zustand(DigitalEingang
:
WORD)
:
WORD;

Beispiel
:
IF
Zustand(2)
=
1
THEN
BEGIN
    WriteLn("Am
Digitaleingang
2
liegt
Spannung
an.");
END
ELSE
BEGIN
    WriteLn("Am
Digitaleingang
2
liegt
keine
Spannung
an.");
END;

≡≡Editor

Der
Editor
ist
so
gestaltet,
daß
seine
Bedienung
kompatibel
zu
dem
TURBO-PASCAL-Editor
ist.
Allerdings
ist
der
Umfang
der
zur
Verfügung
stehenden
Befehle
auf
das
nötige
beschränkt.
Zusätzlich
ist
aber
noch
ein
Makro-Recorder
vorhanden,
durch
den
durch
Drücken
einer
Taste
bis
zu
100
Zeichen
auf
einmal
in
den
Programmtext
eingefügt
werden
können.

Pfeiltasten:
Cursor
um
ein
Zeichen
/
eine
Zeile
in
die
Pfeilrichtung
bewegen
<-
(BackSpace)
:
Zeichen
links
vom
Cursor
löschen
Entf:
Zeichen
unter
dem
Cursor
löschen
Enter
:
Text
rechts
vom
Cursor
in
eine
neue
Zeile
schreiben
/
neue
Zeile
beginnen.
Diese
Angaben
gelten
nur,
wenn
der
Einfügenmodus
aktiv
ist.
Achtung
:
Im
Überschreibmodus,
der
an
dem
größeren
Cursor
und
der
Anzeige
in
der
Statuszeile
zu
erkennen
ist,
erfolgt
kein
Zeilenumbruch!

≡

Einfg
:
zwischen
Einfügen
und
Überschreiben
umschalten
Sowohl
am
Cursor
als
auch
an
der
Statuszeile
ist
der
aktivierte
Modus
abzulesen
:
CursorAnzeige
in
der
Statuszeile
EinfügenkleinEinfügen
ÜberschreibengroßÜberschreiben
F1:
Hilfe
zu
ITG-PASCAL
Strg-F1:
Hilfe
zum
Editor
Diese
Befehlsübersicht
wird
angezeigt.
F2:
Sichern
des
Programmtextes
auf
Diskette/Festplatte
F3:
Laden
eines
auf
Diskette/Festplatte
vorhandenen
Programmtextes
F9:
Compilieren
des
Programms
Strg-F9:
Starten
des
Programms
F10,
ESC:
Verlassen
des
Editors,
Wechsel
ins
Menü

≡

Strg-BildAuf:
Cursor
auf
den
Textanfang
setzen
Strg-BildAb:
Cursor
ans
Textende
setzen
Strg-QF:
Suchen
nach
Zeichenfolgen
im
Text
In
der
obersten
Bildschirmzeile
erscheint
die
Frage
"Suchen
:
".
Die
zu
suchende
Zeichenfolge
ist
jetzt
einzugeben
und
mit
ENTER
abzuschließen.
Anschließend
wird
nach
den
Suchoptionen
gefragt
"Optionen
(g/n/u/w/b)
:
".
Auch
diese
Eingabe
ist
mit
ENTER
abzuschließen.
Bedeutung
der
Optionen
:
g
:
global
/
im
ganzen
Text
suchen
n
:
nicht
nachfragen
beim
Ersetzen
u
:
Groß-
und
Kleinschreibung
nicht
unterscheiden
w
:
nur
ganze
Worte
suchen
b
:
ab
der
Cursorposition
rückwärts
suchen

≡

Standardvorgabe
beim
Suchen
ist
:
-
Suchen
ab
Cursorposition
-
Berücksichtigen
von
Groß-
und
Kleinschreibung
-
Suchen
auch
nach
Wortteilen
Strg-QA:
Suchen
und
Ersetzen
von
Zeichenfolgen
im
Text
Es
wird
nach
einer
Zeichenfolge
gesucht,
die
anschließend
durch
eine
andere
ersetzt
wird.
Das
Vorgehen
entspricht
dem
unter
"Suchen
nach
Zeichenfolgen
im
Text"beschrie-
benen,
zusätzlich
wird
als
zweites
durch
"Ersetzen
durch:"
nach
der
Zeichenfolge
gefragt,
die
die
erste
ersetzen
soll.

≡

Wenn
die
Option
n
nicht
gewählt
wurde,
wird
die
gesuchte
Zeichenfolge,
sofern
sie
gefunden
wurde,
auf
dem
Bild-
schirm
hervorgehoben
und
es
erscheint
in
der
obersten
Bildschirmzeile
die
Frage
"Ersetzen
(j/n):".
Wenn
"j"
oder
"J"
eingegeben
wurde,
wird
ersetzt,
bei
"n"
bzw.
"N"
nicht.
Strg-L    :
letztes
Suchen
bzw.
Suchen/Ersetzen
wiederholen
Wenn
zuletzt
nach
einer
Zeichenfolge
gesucht
wurde,
wird
diese
Suche
mit
den
eingegebenen
Optionen
wiederholt,
andernfalls
wird
"Suchen
und
Ersetzen"
wiederholt.
Strg-T    :
Wort
rechts
vom
Cursor
löschen
Strg-KB:
Blockanfang
markieren
Strg-KK:
Blockende
markieren
Ein
markierter
Block,
dessen
Anfang
vor
seinem
Ende
steht,
wird
durch
eine
invertierte
Darstellung
von
Zeichen
und
Hintergrund
hervorgehoben.

≡

Strg-KH:
Blockmarkierung
ein-
/
ausschalten
Die
Hervorhebung
eines
Blocks
wird
dadurch
aufgehoben
bzw.
wieder
ausgeführt.
Strg-KC:
Block
kopieren
Wenn
ein
Block
mit
Strg-KB
und
Strg-KK
markiert
wurde,
wird
er
an
die
Cursorposition
kopiert.
Der
Textblock
bleibt
an
der
ursprünglichen
Position
erhalten.
Strg-KV:
Block
verschieben
Wenn
ein
Block
mit
Strg-KB
und
Strg-KK
markiert
wurde,
wird
er
an
die
Cursorposition
verschoben.
Der
Textblock
wird
an
der
ursprünglichen
Position
gelöscht.
Strg-KY:
Block
löschen
Wenn
ein
Block
mit
Strg-KB
und
Strg-KK
markiert
wurde,
wird
er
gelöscht.

≡

Strg-KP:
Block
drucken
Wenn
ein
Block
mit
Strg-KB
und
Strg-KK
markiert
wurde,
wird
er
auf
dem
Drucker
ausgegeben.
Strg-KW:
Block
in
eine
Datei
schreiben
Wenn
ein
Block
mit
Strg-KB
und
Strg-KK
markiert
wurde,
wird
er
in
eine
Datei
geschrieben,
nachdem
in
der
obersten
Bildschirmzeile
der
Dateiname
nach
"Block
schreiben:"
eingegeben
wurde.
Strg-KR:
Block
aus
einer
Datei
lesen
In
der
obersten
Bildschirmzeile
wird
mit
"Block
lesen:"
nach
dem
Namen
einer
Textdatei
gefragt,
die
ab
der
Cursorposition
in
den
Text
eingefügt
wird,
wenn
es
eine
Textdatei
unter
diesem
Namen
gibt.

≡

Im
Editor
können
Zeichenfolgen
als
Makros
definiert
werden.
Auf
diese
Weise
lassen
sich
durch
Drücken
einer
einzigen
Taste
bis
zu
100
Zeichen
auf
einmal
ab
der
Cursorposition
in
den
Text
einfügen.
Eine
Übersicht
über
vorhandene
Makros
erhält
man
durch
die
Tastenkombination
Alt-F5.

Beispiele:
<Alt-P>
:
PROCEDURE
<Alt-F>
:
FUNCTION

Diese
Angaben
bedeuten,
daß
durch
Drücken
der
Tastenkombination
Alt-P
ein
Makro
eingefügt
wird,
der
einen
Prozedurrahmen
enthält.

Beim
Start
von
ITG-PASCAL
wird
die
Datei
EDIT.MAC
mit
den
bisher
definierten
Makros
geladen,
beim
Verlassen
von
ITG-PASCAL
werden
die
derzeit
definierten
Makros
in
dieser
Datei
abgespeichert,
sodaß
sie
beim
nächsten
Start
wieder
zur
Verfügung
stehen.

≡

Die
Aufnahme
eines
Makros
wird
durch
die
Tastenkombination
Ctrl-F5
gestartet.
Anschließend
wird
die
Tastenkombination
abgefragt,
mit
der
dieses
Makro
gestartet
werden
soll.
Dann
können
bis
zu
100
Tasten
einge-
geben
werden.
Die
Aufnahme
wird
durch
Ctrl-F5
beendet.
Jetzt
wird
ein
Informationstext
abgefragt,
der
mit
Alt-F5
angezeigt
werden
kann.
(siehe
auch
Beispiele
oben)

Beispiel:
Aufnahme
des
Prozedur-Makros
Alt-P:

≡

1)
Ctrl-F5
drückenAufnahme
starten
2)
Alt-P
drückenTastenkombination
festlegen
3)
Text
wie
gewohnt
eingeben
PROCEDURE
;Durch
Bewegen
des
Cursors
auf
das
VARSemikolon
hinter
PROCEDURE
wird
erreicht,
daß
der
Cursor
nach
Einfügen
BEGINdes
Makros
an
dieser
Stelle
stehen-
bleibt,
damit
der
Prozedurname
einge-
END;geben
werden
kann.
4)
Ctrl-F5
drückenAufnahme
beenden
5)
Informationstext
eingeben
<Alt-P>
:
PROCEDURE
aussagekräftigen
Text
mit
Tastenkombi-
nation
und
Wirkung
wählen!

Damit
ist
die
Aufnahme
beendet.
Durch
Alt-P
kann
der
Text
jetzt
beliebig
oft
eingefügt
werden.

≡

Ein
Makro
wird
mit
Ctrl-F6
gelöscht,
indem
im
Anschluß
die
Makrotaste
gedrückt
wird.

Beispiel:
1)
Ctrl-F6    Löschen
starten
2)
Alt-PTastenkombination
Alt-P
aus
der
Makroliste
streichen

≡≡Fehler-Hilfe

Zu
jeder
Fehlermeldung
des
Compilers
können
Hilfstext
über
die
Taste
F1
aufgerufen
werden,
wenn
der
Cursor
auf
der
Fehlerposition
steht.
Es
ist
in
der
vorliegenden
Form
nicht
vorgesehen,
daß
diese
Hilfstexte
über
das
Hilfesystem
einzeln
angesehen
werden
können.
Diese
Möglichkeit
kann
vom
Anwender
aber
bei
Bedarf
hinzugefügt
werden.

≡≡Variable·deklarieren

In
Pascal
muß
der
Typ
einer
Variablen
vor
der
ersten
Verwendung
festgelegt
sein.
Dazu
ist
wie
unter
Prozedur·deklarieren
beschrieben
eine
Deklaration
vor
dem
Anweisungsteil
des
Programms,
der
Prozedur
oder
der
Funktion
vorzunehmen.
Die
Deklaration
wird
durch
das
reservierte
Wort
VAR
eingeleitet.
Dann
folgen
der
Name
der
Variablen
und
ihr
Typ
(s.
auch
Typen),
wobei
eigene
Variablentypen
aufbauend
auf
den
Standardtypen
definiert
werden
können.

ITG-PASCAL
bietet
allerdings
auch
die
Möglichkeit,
Variablendeklarationen
vom
Compiler
unter
dem
Menüpunkt
"EDITOR"
in
den
Quelltext
einfügen
zu
lassen.
Diese
Möglichkeit
ist
eingebaut
für
Wertzuweisungen,
Prozeduren
mit
Variablenparametern
und
bei
Vergleichen
nach
IF
,
WHILE
und
REPEAT.
Wenn
der
benötigte
Datentyp
eindeutig
feststeht,
fügt
ITG-PASCAL
die
Deklaration
selbständig
ein,
sonst
erscheint
der
Quelltext
mit
der
hervorgehoben
dargestellten
Variablen
und
einem
Auswahlmenü
mit
den
möglichen
Typen.

≡

Alle
Deklarationen
werden
lokal
in
die
jeweilige
Prozedur
/
Funktion
oder
in
das
Programm
eingefügt.
Es
können
keine
selbstdefinierten
Typen
verwendet
werden.
Aus
diesen
Bedingungen
ergibt
sich,
daß
die
auto-
matische
Deklaration
nur
in
der
Anfangsphase
eingesetzt
werden
sollte.

VAR
VariablenName
:
TypDerVariablen;

Beispiele
:
VAR
Zähler
:
INTEGER;
Produkt,
Quotient
:
REAL;Produkt
und
Quotient
sind
vom
Typ
REAL

≡≡Prozedur·deklarieren

Ein
Pascal-Programm
sollte
in
kleinere,
überschaubare
Programmteile
aufgegliedert
werden,
die
dann
als
Prozeduren
oder
Funktionen
zu
deklarieren
sind.
Bei
Bedarf
können
der
Prozedur
beliebig
viele
Parameter
übergeben
werden,
deren
Veränderung
innerhalb
der
Prozedur
dem
aufrufen
Programmteil
mitgeteilt
wird
oder
nicht.
Die
Typen
der
Variablen
sind
in
einer
Parameterliste
anzugeben.

Beispiel
:

≡

PROCEDURE
ErhöheX(VAR
x
:
INTEGER;
Der
Wert
von
x
wird
verändert
und
y
:
INTEGER);dem
aufrufenden
Programmteil
zurück-
geliefert.
Dazu
muß
vor
x
VAR
stehen.
VARDeklaration
einer
lokalen
Variablen
n
:
INTEGER;n,
die
nur
innerhalb
dieser
Prozedur
bekannt
ist.
Die
Deklaration
muß
zwischen
dem
Kopf
der
Prozedur
(PROCEDURE
xyz(...);)
und
dem
Anfang
des
Anweisungsteils
(BEGIN)
stehen!
BEGINHier
beginnt
der
Anweisungsteil.
n
:=
ABS(y);Den
Betrag
von
y
bilden
INC(x,
n);und
zu
x
addieren.
Die
Prozedur
INC
END;hat
die
gleiche
Parameterliste
wie
ErhöheX!

≡≡Funktion·deklarieren

Eine
Funktion
in
einem
Pascal-Programm
entspricht
in
ihrer
Wirkung
einer
mathematischen
Funktion,
bei
der
eine
oder
mehrere
Variablen
in
einen
Funktionsterm
eingesetzt
werden
und
ein
Funktionswert
ausgerechnet
wird.
Dieser
Wert
wird
bei
der
Programmausführung
anstelle
des
Funktionsnamens
und
der
Parameterliste
als
Wert
in
den
Anweisungsteil
eingesetzt.

Beispiel
:

≡

FUNCTION
xQuadratMinus1(x
:
REAL)
:
REAL;Der
Funktion
wird
der
Para-
meter
x
vom
Typ
REAL
(x
:
REAL)
übergeben.
Anschließend
wird
festgelegt,
daß
das
Ergebnis
der
Berechnung
ebenfalls
vom
Typ
REAL
ist
(
)
:
REAL;
).
BEGIN
xQuadratMinus1
:=
x^2-1;Das
Ergebnis
der
Berechnung
END;x^2-1
wird
als
Zuweisung
zu
dem
Funktionsnamen
als
Funk-
tionswert
definiert.

≡≡Fehler-Hilfe:0

mögliche
Fehlerursachen:

-
Es
wird
eine
Variable
verwendet,
die
noch
nicht
deklariert
wurde.
Abhilfe
:
Variable·deklarieren!

-
Es
wird
eine
Prozedur
oder
eine
Funktion
aufgerufen,
die
nicht
deklariert
wurde.
Abhilfe
:
Prozedur·deklarieren
oder
Funktion·deklarieren!

≡

-
Der
Name
der
Variablen,
Prozedur
oder
Funktion
wurde
falsch
geschrieben
oder
enthält
ein
Leerzeichen
"
",
daß
in
PASCAL
dazu
dient,
Bezeichnernamen
zu
trennen.

Beispiel
:
    falsch
:
Grafik
Schirm
    richtig:
GrafikSchirm

Abhilfe
:
Schreibweise
korrigieren!

≡≡Fehler-Hilfe:1

Fehlerursache:

Ein
Variablenname
wurde
global
oder
lokal
in
einer
Prozedur
/
Funktion
mehrfach
verwendet.

Beispiel
:
    VAR
Zahl
:
REAL;
Zahl
:
INTEGER;

Abhilfe
:
Eine
der
Variablen
umbenennen!

≡≡Fehler-Hilfe:2

Fehlerursache:

Es
wird
ein
Variablenname,
eine
Prozedur
oder
eine
Funktion
erwartet.

Beispiel
:
    falsch:INTEGER
:=
3
*
4;
    richtig
:VAR
Zahl
:
INTEGER;
.
Zahl
:=
3
*
4;

Abhilfe
:Variable·deklarieren
und
deren
Namen
einsetzen,
Prozedur
oder
Funktion
aufrufen.

≡≡Fehler-Hilfe:3

Fehlerursache:

Der
Programmkopf
"PROGRAM
Name;"
wurde
ausgelassen.

Beispiel
:
    falsch:
VAR
n
:
INTEGER;
    richtig
:
PROGRAM
IrgendEinName;
VAR
n
:
INTEGER;

Abhilfe
:
Am
Anfang
des
Programms
"PROGRAM
ProgrammName;"
einfügen.

≡≡Fehler-Hilfe:4

Fehlerursache:

")"
wurde
vergessen.

Beispiel
:
falsch:Write("Text";
richtig
:Write("Text");

Abhilfe
:")"
einfügen.

≡≡Fehler-Hilfe:5

Fehlerursache:

":"
wurde
vergessen
oder
es
wurde
ein
anderes
Zeichen
geschrieben.

Beispiel
:
falsch:VAR
n
=
INTEGER;
richtig
:VAR
n
:
INTEGER;

Abhilfe
:":"
einfügen.

≡≡Fehler-Hilfe:6

Fehlerursache:

Die
Syntaxregeln
wurden
nicht
eingehalten.

Beispiel
:
falsch:FOR
n
:=
1
TO
10
DO
BEGINfalsche
Schachtelung
REPEAT
.
END;
UNTIL
m
>
1000;

≡

richtig
:FOR
n
:=
1
TO
10
DO
BEGIN
REPEAT
.
UNTIL
m
>
1000;
END;

Abhilfe
:
Programmstruktur
untersuchen
-
eventuell
zur
Vereinfachung
den
Programmtext
formatieren
lassen
-
und
korrigieren

≡≡Fehler-Hilfe:7

Fehlerursache:

Es
wird
ein
Variablenname,
eine
Prozedur
oder
eine
Funktion
erwartet.

Beispiel
:
    falsch:INTEGER
:=
3
*
4;
    richtig
:VAR
Zahl
:
INTEGER;
.
Zahl
:=
3
*
4;

Abhilfe
:Variable·deklarieren
und
deren
Namen
einsetzen,
Prozedur
oder
Funktion
aufrufen.

≡≡Fehler-Hilfe:8

Fehlerursache:

"OF"
wurde
vergessen
oder
es
wurde
etwas
anderes
geschrieben.

Beispiel
:
falsch:CASE
n
BEGIN
richtig
:CASE
n
OF

Abhilfe
:"OF"
einfügen.

≡≡Fehler-Hilfe:9

Fehlerursache:

"("
wurde
vergessen.

Beispiel
:
falsch:Write
"Text";
richtig
:Write("Text");

Abhilfe
:"("
einfügen.

≡≡Fehler-Hilfe:10

Fehlerursache:

Es
wird
eine
ARRAY-Variable
erwartet.

Beispiel
:
VAR
nArray
:
ARRAY[1..10]
OF
INTEGER;
n:
INTEGER;
falsch:nArray
:=
n;n
muß
vom
gleichen
Typ
wie
nArray
sein.
richtig
:nArray[1]
:=
n;nArray[1]
ist
vom
Typ
INTEGER.

Abhilfe
:
Zuweisung
korrigieren.

≡≡Fehler-Hilfe:11

Fehlerursache:

"["
wurde
vergessen
oder
es
wurde
etwas
anderes
geschrieben.

Beispiel
:
falsch:VAR
n
:
ARRAY
1..10
OF
INTEGER;
richtig
:VAR
n
:
ARRAY[1..10]
OF
INTEGER;

Abhilfe
:"["
einfügen.

≡≡Fehler-Hilfe:12

Fehlerursache:

"]"
wurde
vergessen
oder
es
wurde
etwas
anderes
geschrieben.

Beispiel
:
falsch:VAR
n
:
ARRAY
1..10
OF
INTEGER;
richtig
:VAR
n
:
ARRAY[1..10]
OF
INTEGER;

Abhilfe
:"]"
einfügen.

≡≡Fehler-Hilfe:13

Fehlerursache:

".."
wurde
vergessen
oder
es
wurde
etwas
anderes
geschrieben.

Beispiel
:
falsch:VAR
n
:
ARRAY[1.10]
OF
INTEGER;
richtig
:VAR
n
:
ARRAY[1..10]
OF
INTEGER;

Abhilfe
:".."
einfügen.

≡≡Fehler-Hilfe:14

Fehlerursache:
-
Es
wurde
ein
Semikolon
vergessen.
Abhilfe
:
Semikolon
einfügen!
Beispiele
:
    GrafikSchirm;Prozedur-
und
Funktions-Aufrufe
müssen
mit
einem
Semikolon
abgeschlossen
werden.

    VARn
:
INTEGER;Bei
Deklarationen
werden
verschiedene
Typen
r
:
REAL;durch
ein
Semikolon
getrennt.

    x
:=
a
*
b
+
c;Nach
Wertzuweisungen
einer
Variablen
muß
ein
Semikolon
folgen.

≡

    END;END
muß
ein
Semikolon
folgen,
wenn
als
nächstes
eine
Zuweisung
oder
ein
Prozedur-/
Funktions-Aufruf
folgt.
END
darf
ein
Semikolon
folgen,
wenn
ein
weiteres
END
folgt,
muß
aber
nicht.
END
darf
kein
Semikolon
folgen,
wenn
ein
ELSE
folgt!

≡≡Fehler-Hilfe:15

Fehlerursache:

Statt
eines
Funktionsaufrufs
erfolgt
ein
Prozeduraufruf.

Beispiele
:
falsch:n
:=
Write("....");
richtig
:n
:=
ROUND(n^2);

Abhilfe
:Funktion
aufrufen.

≡≡Fehler-Hilfe:16

Fehlerursache:

"="
wurde
vergessen
oder
es
wurde
etwas
anderes
geschrieben.

Beispiele
:
falsch:TYPE
Str80
:
STRING[80];
richtig
:TYPE
Str80
=
STRING[80];
falsch:IF
n
:=
5
THEN
BEGIN
richtig
:IF
n
=
5
THEN
BEGIN

Abhilfe
:"="
einfügen.

≡≡Fehler-Hilfe:17

Fehlerursache:

Es
wurde
keine
boolsche
Variable
und
keine
Aussageform
verwendet.

Beispiel
:
falsch:IF
Write("Text")
THEN
BEGIN
richtig
:IF
Zahl
=
1
THEN
BEGIN

Abhilfe
:Boolschen
Term
verwenden.

≡≡Fehler-Hilfe:19

Fehlerursache:

Es
wurde
eine
unzulässige
Typzuweisung
versucht.

Beispiel
:
VAR
s
:
STRING[20];
r
:
REAL;
i
:
INTEGER;
falsch:r
:=
s;
richtig
:VAL(s,
r,
i);STRING
in
REAL
umwandeln
falsch:i
:=
r;
richtig
:i
:=
ROUND(r);REAL
in
INTEGER
umwandeln

Abhilfe
:
Typumwandlung
verwenden.

≡≡Fehler-Hilfe:21

Fehlerursache:

Ein
ARRAY
oder
RECORD
wurde
zu
groß
deklariert.

Beispiel
:
falsch:
VAR
n
:
ARRAY[1..30000]
OF
INTEGER;
für
ITG-PASCAL
zu
groß
richtig
:
VAR
n
:
ARRAY[1..5000]
OF
INTEGER;

Abhilfe
:
Elementzahl
des
Arrays
/
Records
verringern.

≡≡Fehler-Hilfe:23

Fehlerursache:

Es
wurde
versucht,
eine
Fallunterscheidung
mit
CASE
mit
Arrays
oder
Records
durchzuführen.

Beispiel
:
VAR
Zahlen
:
ARRAY[1..100]
OF
INTEGER;
falsch:CASE
Zahlen
OFARRAY
verwendet
richtig
:CASE
Zahlen[1]
OFINTEGER
verwendet

Abhilfe
:Einfachen
Datentyp
zur
Fallunterscheidung
verwenden.

≡≡Fehler-Hilfe:24

Fehlerursache:

Es
wurde
statt
eines
Buchstaben
etwas
anderes
verwendet.

Beispiel
:
VAR
s
:
STRING[10];
falsch:ErsetzeBuchstaben(s,
1,
5);Zahlenwert
5
verwendet
richtig
:ErsetzeBuchstaben(s,
1,
"5");

Abhilfe
:
Buchstaben
oder
CHAR-Variable
verwenden.

≡≡Fehler-Hilfe:25

Fehlerursache:

Statt
einer
Konstanten
wurde
eine
Variable
oder
etwas
anderes
verwendet.

Beispiel
:
CONST
MaxZahlen
=
100;
VARMax
:
INTEGER;
falsch:
VAR
Zahlen
:
ARRAY[1..Max]
OF
INTEGER;
Variable
verwendet
richtig
:
VAR
Zahlen
:
ARRAY[1..MaxZahlen]
OF
INTEGER;
oder
VAR
Zahlen
:
ARRAY[1..100]
OF
INTEGER;

Abhilfe
:
Konstante
verwenden.

≡≡Fehler-Hilfe:26

Fehlerursache:

Es
wird
eine
Zuweisung
eines
falschen
Typs
zu
einem
Array-Element
versucht.

Beispiel
:
VAR
GanzeZahl
:
ARRAY[1..20]
OF
INTEGER;
falsch:
GanzeZahl[1]
:=
1.34;
richtig
:
GanzeZahl[1]
:=
ROUND(1.34);Real-Variable
nach
Integer
konvertieren

Abhilfe
:
auf
gleiche
Typen
achten
oder
Typ-Konvertierung
benutzen.

≡≡Fehler-Hilfe:27

Fehlerursache:

Die
untere
und
die
obere
Grenze
eines
Arrays
muß
durch
eine
ganze
Zahl
definiert
werden.
Statt
dessen
wurde
ein
andere
Typ
(Real
oder
String)
verwendet.

Beispiel
:
falsch:
VAR
Zahlen
:
ARRAY[1.3..2.5]
OF
REAL;
richtig
:
VAR
Zahlen
:
ARRAY[1..3]
OF
REAL;

Abhilfe
:
ganze
Zahl
als
Grenze
verwenden.

≡≡Fehler-Hilfe:28

Fehlerursache:

Es
wird
ein
Zugriff
auf
ein
Element
einer
Variablen
versucht,
die
kein
Array
ist.

Beispiel
:VAR
n
:
INTEGER;
falsch:
n[1]
:=
2;
richtig
:
n
:=
2;

Abhilfe
:
Array-Variable
verwenden
oder
Index
weglassen.

≡≡Fehler-Hilfe:29

Fehlerursache:

Als
Typ-Bezeichner
eines
Record-Elementes
wird
ein
elementarer
Typ
oder
ein
bereits
deklarierter
Typ
erwartet,
in
ITG-PASCAL
aber
keinesfalls
z.B.
Prozedur-,
Funktions-
oder
Objekt-Typen.

Beispiel
:
falsch:TYPE
EinRecord
=
RECORD
EinElementDrucken
:
Write;Prozedur-Typ
ist
nicht
END;erlaubt

≡

richtig
:TYPE
EinRecord
=
RECORD
EinElement
:
STRING[20];einfacher
Typ
ist
erlaubt
END;

Abhilfe
:
einfachen
Typ
oder
bereits
deklarierten
Typ
verwenden.

≡≡Fehler-Hilfe:30

Fehlerursache:

Der
verwendete
Typ
wurde
noch
nicht
deklariert.

Beispiel
:
falsch:
VAR
Beispiel
:
EinBeispiel;in
ITG-PASCAL
so
nicht
bekannt
richtig
:
TYPE
EinBeispiel
=
STRING[10];
neuen
Typ
erst
deklarieren
VAR
Beispiel
:
EinBeispiel;

Abhilfe
:
zuerst
neuen
Typ
deklarieren
oder
Schreibfehler
beseitigen.

≡≡Fehler-Hilfe:31

Fehlerursache:

Es
wurde
versucht,
in
einer
Variablen,
die
kein
Record
(keine
Daten-
struktur)
ist,
auf
ein
Record-Element
zuzugreifen.

Beispiel
:
falsch:
VAR
Person
:
ARRAY[1..2]
OF
STRING[20];
Person.Nachname
:=
"XYZ";
richtig
:
TYPE
Person
=
RECORD
Vorname,
Nachname
:
STRING[20];
END;
Person.Nachname
:=
"XYZ";

Abhilfe
:
Je
nach
Fall
einfache
Variable
oder
Record-Variable
verwenden.

≡≡Fehler-Hilfe:32

Fehlerursache:

Es
wurde
statt
eines
Wahrheitswertes
(BOOLEAN)
etwas
anderes
zugewiesen.

Beispiel
:VAR
IstWahr
:
BOOLEAN;
n
:=
INTEGER;
falsch:
IstWahr
:=
1;1
ist
kein
Wahrheitswert
richtig
:
IstWahr
:=
TRUE;TRUE
oder
FALSE
sind
Wahrheitswerte
IstWahr
:=
(n
=
1);Der
rechte
Teil
der
Zuweisung
ist
eine
Aussageform,
die
genau
dann
wahr
ist,
wenn
n
=
1
ist.
IstWahr
erhält
dann
den
Wert
TRUE,
sonst
den
Wert
FALSE.
Abhilfe
:
Wahrheitwert
verwenden.

≡≡Fehler-Hilfe:33

Fehlerursache:

Es
wurde
versucht,
mit
einer
Variablen
/
Konstantenzu
rechnen,
die
keine
Zahl
ist.

Beispiel
:
falsch:s
:=
"1.23"
/
"4.56";
Division
zweier
Zeichenketten
ist

nicht
definiert.
richtig
:r
:=
1.23
/
4.56;Division
zweier
Dezimalzahlen

Abhilfe
:
Zahlenwerte
/
Zahlenvariablen
verwenden.

≡≡Fehler-Hilfe:34

Fehlerursache:

Als
Index
wurde
etwas
anderes
als
eine
ganze
Zahl
verwendet.

Beispiel
:VAR
s
:
STRING[20];
c
:
CHAR;
falsch:c
:=
s[1.3];Welcher
Buchstabe
steht
an
der
1,3.Stelle
von
s?
richtig
:c
:=
s[2];Index
muß
ganzzahlig
sein!
falsch:Write(Copy(s,
1.3,
1));s.o.
richtig
:Write(Copy(s,
2,
1));

Abhilfe
:
Integer-Typ
verwenden.

≡≡Fehler-Hilfe:35

Fehlerursache:

Es
wurden
Typen
verwendet,
die
in
diesem
Fall
nicht
kompatibel
(gleichwertig)
sind.

Beispiel
:VAR
s
:
STRING[20];
c
:
CHAR;
falsch:
IF
s
=
c
THEN
...STRINGS
und
CHARS
können
nicht
direkt
miteinander
verglichen
werden.
richtig
:
IF
s[1]
=
c
THEN
...
s[1]
ist
vom
Typ
CHAR.

Abhilfe
:
Kompatible
Typen
verwenden
oder
Typkonvertierung
(Typumwandlung)
verwenden.

≡≡Fehler-Hilfe:36

Fehlerursache:

An
eine
Prozedur
/
Funktion
wurde
ein
Parameter
eines
falschen
Typs
übergeben.

Beispiel
:PROCEDURE
Beispiel(r
:
REAL);
falsch:
Beispiel("1.5");"1.5"
ist
ein
STRING
und
damit
nicht
kompatibel
zum
Typ
REAL.
richtig
:
Beispiel(1.5);REAL-Parameter

Abhilfe
:
Richtigen
Parameter-Typ
verwenden
oder
Typ
konvertieren.

≡≡Fehler-Hilfe:37

Fehlerursache:

Anstelle
einer
Variablen
wurde
eine
Konstante
verwendet.

Beispiel
:VAR
s
:
STRING[20];
falsch:
Read("XYZ");    "XYZ"
ist
eine
STRING-Konstante
richtig
:
s
:=
"XYZ";
Variable
mit
einem
Wert
belegen
Read(s);und
als
Parameter
übergeben

Abhilfe
:
Variable
verwenden
und
gegebenenfalls
vorher
mit
einem
Wert
belegen.

≡≡Fehler-Hilfe:38

Fehlerursache:

Anstelle
einer
STRING-Variablen
wurde
ein
anderer
Typ
verwendet.

Beispiel
:
falsch:Write(Copy(1.234,
3,
2));aus
einer
Zahl
können
so
keine
Ziffern
herausgezogen
werden.
richtig
:Write(Copy("1.234",
3,
2));ergibt
"23"

Abhilfe
:
STRING-Konstante
oder
Variable
verwenden.

≡≡Fehler-Hilfe:39

Fehlerursache:

Einer
Prozedur
/
Funktion
wurden
zuwenig
Parameter
übergeben.

Beispiel
:
falsch:
Strecke(1,
3);
richtig
:
Strecke(1,
3,
100,
150);

Abhilfe
:
Die
nötigen
Parameter
hinzufügen.

≡≡Fehler-Hilfe:40

Fehlerursache:

In
einer
INTEGER-Konstanten
wurden
andere
Zeichen
als
0,
1,
..9
für
Ziffern
verwendet.

Beispiel
:
falsch:
1x2x
kann
keine
Ziffer
sein
richtig
:
132

Abhilfe
:
Nur
0
-
9
als
Ziffern
verwenden.

≡≡Fehler-Hilfe:41

Fehlerursache:

Statt
eines
einfachen
Datentyps
wurde
anderer
Typ
(z.B.
File,
 Text)
verwendet.

Beispiel
:VAR
File1,
File2
:
FILE;
a
:
ARRAY[1..10]
OF
STRING[20];
falsch:
Write(File1,
File2);Eine
Dateivariable
kann
nicht
in
    eine
Datei
hineingeschrieben
werden.
richtig
:
Write(File1,
a);Arrays
können
in
eine
Datei
    geschrieben
werden.

Abhilfe
:
Einfachen
Typ
verwenden.

≡≡Fehler-Hilfe:42

Fehlerursache:

Es
wurde
statt
einer
REAL-Variablen
/Konstanten
ein
anderer
Typ
verwendet.

Beispiel
:VAR
i
:
INTEGER;
r
:
REAL;
s
:
STRING;
falsch:
Str(i:10:5,
s);eine
Integer-Variable
hat
keine
Nach-
kommastellen.
richtig
:
Str(r:10:5,
s);s
hat
nach
der
Konvertierung
die
Länge
10,
davon
sind
5
Nachkommastellen.

Abhilfe
:
REAL-Variable
/
Konstante
verwenden.

≡≡Fehler-Hilfe:43

Fehlerursache:

Statt
einer
INTEGER-Variablen
/
Konstanten
wurde
ein
anderer
Typ
verwendet.

Beispiel
:
falsch:
Strecke(1.5,
2.3,
150.3,
123.7);
Bildschirmpunkte
haben
immer
ganzzahlige
Koordinaten.
richtig
:
Strecke(2,
2,
150,
124);

Abhilfe
:
INTEGER-Variable
/
Konstante
verwenden.

≡≡Fehler-Hilfe:44

Fehlerursache:

Statt
einer
Variablen,
Konstanten
oder
Funktion
wurde
etwas
anderes
verwendet.

Beispiel
:VAR
n
:
INTEGER;
falsch:
Write(INTEGER);Typen
sind
hier
nicht
zulässig
richtig
:
Write(n);n
ist
eine
Variable
falsch:
Write(Grafikschirm);Prozedur-Aufrufe
sind
hier
nicht
zulässig
richtig
:
Write(EsGibtDatei("XYZ"));EsGibtDatei
ist
eine
Funktion

Abhilfe
:
Variable,
Konstante
oder
Funktion
verwenden.

≡≡Fehler-Hilfe:45

Fehlerursache:

Statt
einer
Variablen,
der
ein
Wert
zugewiesen
werden
soll,
oder
eines
Prozeduraufrufes
wurde
etwas
anderes
verwendet.

Beispiel
:VAR
n
:
INTEGER;
falsch:
INTEGER
:=
5;einem
Typ
kann
kein
Wert
zugewiesen
werden
richtig
:
n
:=
5;
einer
Variablen
kann
ein
neuer
Wert
zugewiesen
werden

Abhilfe
:
Variable
oder
Prozeduraufruf
verwenden.

≡≡Fehler-Hilfe:46

Fehlerursache:

Es
sollen
die
Inhalte
zweier
Variablen
verschiedenen
Typs
vertauscht
werden.

Beispiel
:VAR
r1,
r2
:
REAL;
n1,
n2
:
INTEGER;
falsch:
Vertausche(n1,
r2);n1
und
r2
sind
verschiedene
Typen
richtig
:
Vertausche(r1,
r2);r1
und
r2
sind
vom
gleichen
Typ
Vertausche(n1,
n2);n1
und
n2
sind
vom
gleichen
Typ

Abhilfe
:
Gleiche
Typen
verwenden.

≡≡Fehler-Hilfe:47

Fehlerursache:

In
der
Fallunterscheidung
mit
CASE
Variable
OF
wurde
innerhalb
der
Vergleichsliste
eine
Konstante
verwendet,
die
nicht
vom
gleichen
Typ
wie
Variable
ist.

Beispiel
:VAR
c
:
CHAR;
falsch:
CASE
c
OF
1:
...;1
ist
eine
INTEGER-Konstante
"XYZ"
:
...;"XYZ"
ist
eine
STRING-Konstante
richtig
:
CASE
c
OF
"1"
:
...;"1"
ist
vom
Typ
CHAR
"X"
:
...;"X"
ist
vom
Typ
CHAR

Abhilfe
:
Gleiche
Typen
verwenden.

≡≡Fehler-Hilfe:48

Fehlerursache:

Einer
Variablen
soll
ein
Funktionswert
zugewiesen
werden,
der
nicht
dem
Typ
der
Variablen
entspricht.

Beispiel
:VAR
c
:
CHAR;
r
:
REAL;
falsch:
c
:=
SQR(3);Die
Funktion
SQR
gibt
einen
REAL-Wert
zurück
richtig
:
r
:=
SQR(3);Es
werden
gleiche
Typen
benutzt.

Abhilfe
:
Gleichewertige
Typen
verwenden.

≡≡Fehler-Hilfe:49

Fehlerursache:

Der
freie
Speicher
des
Computers
ist
erschöpft.
Für
das
Speichern
einer
STRING-Konstanten
steht
kein
Platz
mehr
zur
Verfügung.

Beispiel
:kein
Benutzerfehler
falsch:
-
richtig
:
-

Abhilfe
:
Nicht
benötigte
STRING-Konstanten
aus
dem
Programm
entfernen.

≡≡Fehler-Hilfe:50

Fehlerursache:

Statt
einer
Konstanten
wurde
etwas
anderes
verwendet.

Beispiel
:CONST
StringLänge
=
20;
VARLänge
:
INTEGER;
falsch:
VAR
s
:
STRING[Länge];Länge
ist
eine
Variable
richtig
:
VAR
s
:
STRING[StringLänge];StringLänge
ist
eine
Konstante
VAR
s
:
STRING[20];

Abhilfe
:
Konstante
verwenden.

≡≡Fehler-Hilfe:51

Fehlerursache:

Bei
einer
Zuweisung
wurde
als
Zuweisungsopeartor
etwas
anderes
als
":="
verwendet.

Beispiel
:VAR
r
:
REAL;
falsch:
r
=
5.4
*
3.1;"="
darf
bei
Zuweisungen
nicht
verwendet
werden
richtig
:
r
:=
5.4
*
3.1;Zuweisungsoperator
":="
verwendet

Abhilfe
:
":="
verwenden.

≡≡Fehler-Hilfe:52

Fehlerursache:

Bei
einer
IF-Anweisung
wurde
etwas
anderes
als
THEN
verwendet.

Beispiel
:
falsch:
IF
r
=
1.3
DO
...falsche
Syntax
richtig
:
IF
r
=
1.3
THEN
...

Abhilfe
:
THEN
oder
THEN
BEGIN
verwenden.

≡≡Fehler-Hilfe:53

Fehlerursache:

Eine
REPEAT-Schleife
wurde
nicht
mit
UNTIL
geschlossen.

Beispiel
:
falsch:
REPEAT
Anweisungen;
END;falsche
Syntax
richtig
:
REPEAT
Anweisungen;
UNTIL
wahre
Bedingung;

Abhilfe
:
UNTIL
verwenden.
Unter
Umständen
sind
Programm-Blöcke
nicht
richtig
geschachtelt.

≡

Beispiel
:
    FOR
n
:=
1
TO
100
DO
BEGIN
REPEAT
Anweisungen;
END;falsche
Schachtelung
der
Schleifen
    UNTIL
n
>
100;

≡≡Fehler-Hilfe:54

Fehlerursache:

In
einer
FOR-TO-Schleife
wurde
etwas
anderes
als
DO
verwendet.

Beispiel
:
falsch:
FOR
n
:=
1
TO
100
BEGIN
...
richtig
:
FOR
n
:=
1
TO
100
DO
BEGIN
...

Abhilfe
:
DO
oder
DO
BEGIN
verwenden.

≡≡Fehler-Hilfe:55

Fehlerursache:

In
einer
FOR-TO-Schleife
wurde
etwas
anderes
als
TO
oder
DOWNTO
verwendet.

Beispiel
:
falsch:
FOR
n
:=
1
DO
...Syntax-Fehler
richtig
:
FOR
n
:=
1
TO
100
DO
...in
Einerschritten
aufwärts
FOR
n
:=
100
DOWNTO
1
DO
...in
Einerschritten
abwärts

Abhilfe
:
TO
oder
DOWNTO
verwenden.

≡≡Fehler-Hilfe:56

Fehlerursache:

Statt
BEGIN
wurde
etwas
anderes
verwendet.

Beispiel
:
falsch:
PROGRAM
Name;
WriteLn("XYZ");BEGIN
fehlt
END.
richtig
:
PROGRAM
Name;
BEGIN
Write("XYZ");
END.

Abhilfe
:
BEGIN
einfügen.

≡≡Fehler-Hilfe:57

Fehlerursache:

Zu
einem
BEGIN
gibt
es
kein
passendes
END.
Die
Ursache
könnte
in
fehlerhaften
Schachtelungen
liegen.

Beispiel
:
falsch:
FOR
n
:=
1
TO
100
DO
BEGIN
REPEAT
Anweisungen;
END;falsche
Schachtelung
der
Schleifen
UNTIL
wahre
Bedingung;

≡

richtig
:
FOR
n
:=
1
TO
100
DO
BEGIN
REPEAT
Anweisungen;
UNTIL
wahre
Bedingung;
END;

Abhilfe
:
END
verwenden.
Gegebenenfalls
sind
die
Programmstrukturen
zu
überprüfen.

≡≡Fehler-Hilfe:58

Fehlerursache:

Statt
eines
Zahlenwertes
oder
einer
Variablen
wurde
etwas
anderes
verwendet.

Beispiel
:VAR
r
:
REAL;
falsch:
r
:=
5
*
Write(1.3);Write
ist
eine
Prozedur
und
darf
in
    einem
Produkt
nicht
verwendet
werden
richtig
:
r
:=
5
*
r;neuer
Wert
von
r
ist
5
*
alter
Wert
    von
r

Abhilfe
:
Zahlenwert
oder
Variable
verwenden.

≡≡Fehler-Hilfe:59

Fehlerursache:

Zwei
Parameter
eine
Prozedur
/
Funktion
wurden
durch
etwas
anderes
als
ein
Komma
getrennt.

Beispiel
:
falsch:Punkt(x;
y);Die
Prozedur
Punkt
benötigt
x-
und
y-Koor-
dinate.
Die
Trennung
erfolgt
durch
ein
Komma.
richtig
:Punkt(x,
y);

Abhilfe
:
Komma
verwenden.

≡≡Fehler-Hilfe:60

Fehlerursache:

Es
wurde
versucht,
einen
einzelnen
Buchstaben
eines
STRINGS
direkt
einzulesen.

Beispiel
:VAR
s
:
STRING[20];
c
:
CHAR;
falsch:
Read(s[5]);STRINGS
können
nur
vollständig
gelesen
werden
richtig
:
Read(s);STRING
vollständig
lesen
oder
:
Read(c);CHAR
lesen
und
einem
Buchstaben
des
STRINGS
s[5]
:=
c;zuweisen

Abhilfe
:
Lesevorgang
wie
in
den
beiden
Beispielen
gezeigt
je
nach
Anwendungsfall
programmieren.

≡≡Fehler-Hilfe:61

Fehlerursache:

Es
wurde
versucht,
ein
ARRAY
so
groß
zu
definieren,
daß
es
nicht
mehr
in
ein
Datensegment
paßt.

Beispiel
:
falsch:
VAR
a
:
ARRAY[1..100000]
OF
INTEGER;Die
Anzahl
der
richtig
:
VAR
a
:
ARRAY[1..5000]
OF
INTEGER;zulässigen
Feld-
elemente
ist
in
ITG-PASCAL
stark
eingeschränkt.

Abhilfe
:
Anzahl
der
Feldelemente
verringern.

≡≡Fehler-Hilfe:62

Fehlerursache:

Das
Programm
wurde
nicht
durch
ein
abschließendes
"END."
beendet.

Beispiel
:
falsch:
PROGRAMM
Name;
BEGIN
Write("XYZ");hier
folgt
kein
weiterer
Programmtext
richtig
:
PROGRAMM
Name;
BEGIN
Write("XYZ");
END.

Abhilfe
:
Programm
ordnungsgemäß
beenden.

≡≡Fehler-Hilfe:63

Fehlerursache:

Das
Ende
einer
STRING-Konstanten
wurde
nicht
mehr
in
der
Zeile
gefunden,
in
der
der
Anfang
der
STRING-Konstanten
stand.

Beispiel
:
falsch:
Write("xyzDie
Anführungsstriche
müssen
in
XYZ");derselben
Zeile
geöffnet
und
geschlossen
werden.
richtig
:
Write("xyzXYZ");

Abhilfe
:
STRING-Konstante
in
der
laufenden
Zeile
durch
Anführungsstriche
beenden.

≡≡Fehler-Hilfe:64

Fehlerursache:

-
Es
steht
ein
Semikolon,
wo
keines
stehen
darf.
Abhilfe
:
Semikolon
entfernen!
Beispiele
:
    END;END
darf
kein
Semikolon
folgen,
wenn
ein
ELSE
folgt!

    VAR,
CONST,
TYPE,Diesen
Bezeichnern
darf
nie
ein
    RECORD,
BEGIN,
THEN,Semikolon
folgen!
    ELSE,
REPEAT,
    CASE
..
OF,

≡≡Fehler-Hilfe:65

Fehlerursache:

In
einer
Prozedur
/
Funktion
mit
variabler
Parameterzahl
wurde
die
Parameterliste
weder
nach
Trennung
der
Parameter
durch
ein
Komma
fortgesetzt
noch
durch
")"
abgeschlossen.

Beispiel
:
falsch:
Write(x;
y);Parameter
werden
nicht
durch
eine
Komma

getrennt
richtig
:
Write(x,
y);richtige
Trennung
mit
einem
Komma

Abhilfe
:
Komma
oder
")"
einfügen.

≡≡Fehler-Hilfe:66

Fehlerursache:

Eine
Typ-Deklaration
wurde
fehlerhaft
fortgesetzt.

Beispiel
:
falsch:
x
=
RECORD
a,
b
:
INTEGER,Unterschiedliche
Typen
werden
durch
r
:
REAL;ein
Semikolon
getrennt.
END;
richtig
:
x
=
RECORD
a,
b
:
INTEGER;
r
:
REAL;
END;

Abhilfe
:
Deklaration
ordnungsgemäß
fortsetzen.

≡≡Fehler-Hilfe:67

Fehlerursache:

Eine
Prozedur-
/
Funktions-Deklarartion
wurde
fehlerhaft
beendet.

Beispiel
:
falsch:
PROCEDURE
p(x
:
REAL),Abschließend
wird
ein
richtig
:
PROCEDURE
p(x
:
REAL);Semikolon
erwartet.

falsch:
FUNCTION
f(x
:
REAL);    Funktionsergebnissen
muß
richtig
:
FUNCTION
f(x
:
REAL)
:
REAL;ein
einfacher
Datentyp
zugeordnet
werden.

Abhilfe
:
":"
oder
";"
einfügen.

≡≡Fehler-Hilfe:68

Fehlerursache:

Bei
einer
Read-
/
Write-Anweisung
mit
einer
Dateivariablen
wurde
die
Dateivariable
nicht
als
erster
Parameter
übergeben.

Beispiel
:VAR
a
:
ARRAY[1..10]
OF
INTEGER;
f
:
FILE;
falsch:
Write(a,
f);Dateivariable
muß
erster
Parameter
sein.
richtig
:
Write(f,
a);

Abhilfe
:
Dateivariable
als
ersten
Parameter
übergeben.

≡≡Fehler-Hilfe:69

Fehlerursache:

Eine
Dateivariable
soll
mit
einem
Variablentyp
verknüpft
werden.
Dabei
wurde
die
Verknüpfung
nicht
mit
OF
durchgeführt.

Beispiel
:

falsch:
VAR
f
:
FILE
IrgendeinVariablentyp;

richtig
:
VAR
f
:
FILE
OF
IrgendeinVariablentyp;

Abhilfe
:
OF
und
Variablentyp
hinter
FILE
einfügen.

≡≡Fehler-Hilfe:70

Fehlerursache:

UNTIL
wurde
verwendet,
1)
obwohl
keine
REPEAT-UNTIL-Schleife
geöffnet
wurde.
2)
wo
ein
END
erwartet
wird.
In
diesem
Fall
kann
eine
falsche
    Schachtelung
von
Programm-Blöcken
vorliegen.

Beispiel
:

≡

falsch:
FOR
n
:=
1
TO
100
DO
BEGIN
Anweisungen;
UNTIL
n
=
100;
richtig
:
n
:=
1;
REPEAT
Anweisungen;
n
:=
n
+
1;
UNTIL
n
>
100;

Abhilfe
:
REPEAT-UNTIL-Schleife
öffnen
oder
Block-Struktur
überprüfen.

≡≡Fehler-Hilfe:71

Fehlerursache:

Nach
einer
WITH-Anweisung
wurde
keine
RECORD-Variable
verwendet.

Beispiel
:TYPE
EinPunkt
=
RECORD
x,
y
:
REAL;
END;
VAR
x
:
REAL;
Punkt
:
EinPunkt;
falsch:
WITH
x
DO
BEGINx
ist
keine
RECORD-Variable.
richtig
:
WITH
Punkt
DO
BEGINPunkt
ist
eine
RECORD-Variable.

Abhilfe
:
RECORD-Variable
verwenden.

≡≡Fehler-Hilfe:72

Fehlerursache:

Es
sind
zwei
RECORD-Variablen
gleichzeitig
mit
WITH-Anweisungen
geöffnet
worden.

Beispiel
:TYPE
EinPunkt
=
RECORD
x,
y
:
REAL;
END;
VAR
Punkt
:
ARRAY[1..2]
OF
EinPunkt;

≡

falsch:
WITH
Punkt[1]
DO
BEGIN
WITH
Punkt[2]
DO
BEGINIst
Punkt[1].x
:=
Punkt[2].x
x
:=
x;oder
Punkt[2].x
:=
Punkt[1].x
END;gemeint?
Wegen
der
Doppeldeutig-
END;keit
ist
eine
Schachtelung
nicht
erlaubt.
richtig
:
WITH
Punkt[1]
DO
BEGIN
Punkt[2].x
:=
x;eindeutige
Anweisung
END;

Abhilfe
:
Nur
eine
WITH-Anweisung
öffnen
und
die
andere
RECORD-
Variable
vollständig
ausschreiben.

≡≡Fehler-Hilfe:73

Fehlerursache:

In
einer
Dateibearbeitungs-Anweisung
wurde
ein
anderer
Variablentyp
verwendet.

Beispiel
:VAR
f
:
FILE;
r
:
REAL;
falsch:
Rename(r);Nur
Dateien
können
umbenannt
werden.
richtig
:
Rename(f);

Abhilfe
:
Datei-Variable
verwenden.

≡≡Fehler-Hilfe:74

Fehlerursache:

In
der
Prozedur
EingabeFeld
können
keine
ARRAY-,
RECORD-
und
Datei-
Variablen
zum
Lesen
in
einer
Eingabemaske
übergeben
werden.

Beispiel
:VAR
a
:
ARRAY[1..10]
OF
INTEGER;
falsch:
EingabeFeld(x,
y,
Text,
a);Statt
eines
kompletten
richtig
:
EingabeFeld(x,
y,
Text,
a[1]);ARRAYS
können
nur
einzelne
Elemente
über
Eingabe-
masken
eingelesen
werden.

Abhilfe
:
Einfachen
Datentyp
verwenden.

≡≡Fehler-Hilfe:75

Fehlerursache:

Statt
einer
CHAR-Variablen
wurde
ein
anderer
Typ
verwendet.

Beispiel
:VAR
s
:
STRING;
Wahl
:
CHAR;
falsch:
Menü(x,
y,
MenüPunkte,
s);Hier
ist
als
vierter
Para-
richtig
:
Menü(x,
y,
MenüPunkte,
Wahl);
meter
nur
eine
CHAR-Variable
erlaubt.

Abhilfe
:
CHAR-Variable
verwenden.

≡≡Fehler-Hilfe:76

Fehlerursache:

Statt
eines
Zahlenwertes
(REAL-
oder
INTEGER-Konstante
/
Variable)
wurde
etwas
anderes
verwendet.

Beispiel
:
falsch:
WeltPunkt("x",
"y");Hier
werden
Zahlenwerte
für
die
richtig
:
WeltPunkt(1.3,
4);Koordinaten
erwartet.

Abhilfe
:
REAL-
oder
INTEGER-Konstante
/
Variable
verwenden.

≡≡Fehler-Hilfe:77

Fehlerursache:

Nach
der
Anweisung
Write
/
WriteLn
wurde
weder
eine
Klammer
geöffnet
noch
ein
Semikolon
gesetzt.

Beispiel
:
falsch:
Write
"XYZ";Parameter
gehören
in
Klammern
richtig
:
Write("XYZ");

Abhilfe
:
Wenn
etwas
mit
Write
ausgegeben
werden
soll,
muß
eine
Klammer
geöffnet
werden,
sonst
ist
ein
Semikolon
zu
setzen.

≡≡Fehler-Hilfe:78

Fehlerursache:

Die
Parameterliste
in
eine
Prozedur-
/
Funktions-Deklaration
wurde
falsch
fortgesetzt.

Beispiel
:
falsch:
PROCEDURE
W(x
:
INTEGER,Die
Trennung
verschiedener
r
:
REAL);Parametertypen
muß
durch
ein
richtig
:
PROCEDURE
W(x
:
INTEGER;Semikolon
erfolgen.
r
:
REAL);

Abhilfe
:
Semikolon
verwenden
oder
weiteren
Variablennamen
einfügen.

≡≡Fehler-Hilfe:79

Fehlerursache:

In
einer
CASE-
oder
...
IN
[...]-Anweisung
wurden
Konstanten
falschen
Types
oder
unzulässigen
Wertebereichs
verwendet.
Es
dürfen
nur
CHAR-
Konstanten
oder
INTEGER-Konstanten
des
Bereichs
0..255
verwendet
werden.

Beispiel
:
falsch:
UNTIL
Zahl
IN
[1000..2000];unzulässiger
Bereich
richtig
:
UNTIL
Zahl
IN
[100..255];

Abhilfe
:
Konstante
innerhalb
des
erlaubten
Bereichs
verwenden.

≡≡Fehler-Hilfe:80

Fehlerursache:

Zum
Lesen
oder
Schreiben
einer
Dateivariablen
des
Typs
FILE
wurden
READLN
oder
WRITELN
verwendet.
Es
sind
nur
READ
oder
WRITE
erlaubt.

Beispiel
:VAR
Rec
:
IrgendEinRecord;
falsch:
WriteLn(FileVariable,
Rec);
richtig
:
Write(FileVariable,
Rec);

Abhilfe
:
READ
oder
WRITE
verwenden.

≡≡Fehler-Hilfe:81

Fehlerursache:

Zum
Lesen
oder
Schreiben
einer
Dateivariablen
des
Typs
 TEXT
wurden
READ
oder
WRITE
verwendet.
Es
sind
nur
READLN
oder
WRITELN
erlaubt.

Beispiel
:VAR
s
:
STRING;
falsch:
Write(TextDatei,
s);
richtig
:
WriteLn(TextDatei,
s);

Abhilfe
:
READLN
oder
WRITELN
verwenden.

≡≡Fehler-Hilfe:82

Fehlerursache:

Die
Rahmenprozedur
eines
Prozesses
wurde
fehlerhaft
deklariert.

Beispiel
:
falsch:
PROCEDURE
Prozeß1(n
:
INTEGER);
FUNCTION
Prozeß2(x
:
REAL)
:
REAL;
richtig
:
PROCEDURE
Prozeß1;
.
.
NeuerProzeß(1,
100,
3,
Prozeß1);

Abhilfe
:
Prozedur
ohne
Parameter
verwenden.

≡≡Fehler-Hilfe:83

Fehlerursache:

Zur
Synchronisation
von
Prozessen
wurde
eine
Variable
eines
anderen
Typs
als
des
Typs
SIGNAL
verwendet.

Beispiel
:
falsch:
VAR
b
:
BOOLEAN;
SendeSignal(b);
richtig
:
VAR
s
:
SIGNAL;
SendeSignal(s);

Abhilfe
:
Variable
des
Typs
SIGNAL
verwenden.

≡≡Fehler-Hilfe:84

Fehlerursache:

Für
die
Zählvariable
einer
FOR-TO-Schleife
wurde
ein
anderer
Typ
als
INTEGER,
CHAR
oder
BOOLEAN
verwendet.

Beispiel
:
falsch:
VAR
r
:
REAL;
FOR
r
:=
1
TO
10
DO
Write(r);
richtig
:
VAR
n
:
INTEGER;
FOR
n
:=
1
TO
10
DO
Write(n);

Abhilfe
:
Variable
der
Typen
INTEGER,
CHAR
oder
BOOLEAN
verwenden.

≡≡Fehler-Hilfe:85

Fehlerursache:

Die
automatische
Variablen-Deklaration
kann
nur
bei
Wertzuweisungen
und
bei
Prozeduren
mit
Parametern
durchgeführt
werden,
bei
denen
Wertzuweisungen
erfolgen.

Beispiel
:
falsch:
IF
r
=
1.5
THEN
....
Write(s);
richtig
:
r
:=
2.3;
Read(s);

Abhilfe
:
JEDE
Variable
sollte
vor
ihrer
ersten
Verwendung
mit
einem
Wert
belegt
werden!

≡≡Fehler-Hilfe:86

Fehlerursache:

Ein
Prozedur-/Funktionskopf
wurde
mit
FORWARD
deklariert,
die
endgültige
Deklaration
fehlt
aber.

Beispiel
:
falsch:
PROCEDURE
p(x
:
INTEGER);
FORWARD;
Es
wird
keine
Prozedur
p
deklariert.
richtig
:
PROCEDURE
p(x
:
INTEGER);
FORWARD;
..
PROCEDURE
p(x
:
INTEGER);
BEGIN
..
END;

Abhilfe
:
Prozedur
im
Anschluß
noch
einmal
vollständig
deklarieren.

≡≡Fehler-Hilfe:87

Fehlerursache:

Die
Prozedur-/Funktionsköpfe
einer
FORWARD-deklarierten
Prozedur/
Funktion
und
ihrer
endgültigen
Deklaration
stimmen
nicht
vollständig
überein.

Beispiel
:
falsch:
PROCEDURE
p(x
:
INTEGER);
FORWARD;
PROCEDURE
p(y
:
INTEGER);y
in
x
umbenennen
PROCEDURE
p(x,
y
:
INTEGER);Parameterzahl
stimmt
nicht
überein
PROCEDURE
p(x
:
REAL);Parametertyp
stimmt
nicht
überein
richtig
:
PROCEDURE
p(x
:
INTEGER);
FORWARD;
PROCEDURE
p(x
:
INTEGER);

Abhilfe
:
Einen
der
beiden
Prozedur-/Funktionsköpfe
korrigieren.

≡≡Fehler-Hilfe:88

Fehlerursache:

Bei
einer
Forward-Deklaration
wurde
ein
Zeiger
auf
einen
anderen
Typ
als
auf
einen
RECORD
deklariert.

Beispiel
:TYPE
KnotenZeiger
=
^EinKnoten;
falsch:EinKnoten
=
ARRAY[1.100]
OF
STRING;kein
RECORD

richtig
:EinKnoten
=
RECORD
Inhalt
:
STRING;
Next
:
KnotenZeiger;
END;

Abhilfe
:
RECORD-Typ
deklarieren.

≡≡Fehler-Hilfe:89

Fehlerursache:

Einer
Forward-Deklaration
eines
Zeiger
MUSS
als
NÄCHSTES
der
RECORD
folgen,
auf
den
der
Zeiger
deklariert
wurde.

Beispiel
:TYPE
KnotenZeiger
=
^EinKnoten;
falsch:Zahlenliste
=
RECORDEinKnoten
MUSS
deklariert
Zahl
:
REAL;werden
Next
:
KnotenZeiger;
END;

≡

richtig
:EinKnoten
=
RECORD
Inhalt
:
STRING;
Next
:
KnotenZeiger;
END;

Abhilfe
:
Hier
RECORD
mit
Bezeichner
des
Zeigertyps
deklarieren.

≡≡Fehler-Hilfe:90

Fehlerursache:

In
ITG-PASCAL
können
nur
3
INCLUDE-Dateien
gleichzeitig
geöffnet
sein.
Innerhalb
einer
INCLUDE-Datei
wurde
eine
weitere
INCLUDE-Datei
verwendet,
usw.
Auf
diese
Weise
wurde
die
Schachtelungstiefe
von
3
überschritten.

Abhilfe
:
Schachtelungstiefe
von
INCLUDE-Dateien
auf
3
begrenzen.

≡≡Fehler-Hilfe:91

Fehlerursache:

Es
wurde
eine
INCLUDE-Datei
angegeben,
die
nicht
im
aktuellen
Verzeichnis
/
in
dem
angegebenen
Verzeichnis
vorhanden
ist.

Abhilfe
:
Richtigen
Dateinamen
mit
richtigem
Verzeichnis
verwenden.

≡≡Fehler-Hilfe:92

Fehlerursache:

Für
den
Zugriff
auf
den
Inhalt
einer
Zeigervariablen
muß
"^"
hinter
dem
Variablennamen
verwendet
werden.

Beispiel
:TYPE
EinePerson
=
RECORD
Vorname,
Name
:
STRING[20];
END;
VAR
Person
:
^EinePerson;

falsch:Person.Name
:=
"XYZ";^
fehlt
nach
Person

richtig
:Person^.Name
:=
"XYZ";

Abhilfe
:
^
einfügen.

≡≡Fehler-Hilfe:93

Fehlerursache:

Es
wurde
versucht,
NEW
oder
DISPOSE
mit
einer
statischen
Variablen
aufzurufen.

Beispiel
:TYPE
EinePerson
=
RECORD
Vorname,
Name
:
STRING[20];
END;
VAR
dynPerson
:
^EinePerson;dynamische
Variable
/
Zeigervariable
statPerson
:
EinePerson;statische
Variable

≡

falsch:NEW(statPerson);keine
dynamische
Variable

richtig
:NEW(dynPerson);

Abhilfe
:
NEW
oder
DISPOSE
nur
mit
dynamischen
Variablen
aufrufen.

≡≡Fehler-Hilfe:94

Fehlerursache:

In
ITG-PASCAL
sind
nur
Zeigervariablen
auf
Arrays
und
Records
implementiert.
Es
wurde
versucht,
eine
Zeigervariable
auf
einen
anderen
Datentyp
zu
deklarieren.

Beispiel
:
falsch:VAR
Zeiger
:
^REAL;kein
ARRAY
oder
RECORD

richtig
:TYPE
RealArray
=
ARRAY[0..10]
OF
REAL;
VAR
Zeiger
:
^RealArray;Zeiger
auf
ein
ARRAY

Abhilfe
:
Geeignetes
ARRAY
oder
geeigneten
RECORD
mit
Zeigervariablen
darauf
deklarieren.

≡≡Fehler-Hilfe:99

Fehlerursache:

Die
Anweisung
ist
in
ITG-PASCAL
(noch)
nicht
implementiert.

Abhilfe
:
Verwenden
Sie
andere
Anweisungen.

≡≡Fehler-Hilfe:101

Fehlerursache:
Die
Tabelle
für
Bezeichner
(Konstanten-,
Variablen-,
Typ-,
Prozedur-
und
Funktions-Deklarationen)
ist
voll.

Abhilfe
:
Versuchen
Sie,
die
Anzahl
der
Bezeichner
zu
verringern.

≡≡Fehler-Hilfe:102

Fehlerursache:

Die
Tabelle
für
die
Parameterlisten
der
Prozeduren/Funktionen
ist
voll.

Abhilfe
:
Versuchen
Sie,
einige
der
deklarierten
Prozeduren/Funktionen
zu
streichen.

≡≡Fehler-Hilfe:103

Fehlerursache:

Die
Tabelle
für
die
Deklaration
von
Real-Konstanten
ist
voll.

Abhilfe
:
Ersetzen
Sie
einige
der
Real-Konstanten
durch
Variablen,
denen
Sie
beim
Programm-Start
Werte
zuweisen.

≡≡Fehler-Hilfe:104

Fehlerursache:

Die
Tabelle
für
Array-Deklarationen
ist
voll.

Abhilfe
:
Versuchen
Sie,
einige
der
deklarierten
Arrays
zu
streichen.

≡≡Fehler-Hilfe:105

Fehlerursache:

Es
sind
zu
viele
Prozedur-/Funktions-Deklarationen
ineinander
geschachtelt.

Abhilfe
:
Ändern
Sie
die
(inneren)
Deklarationen
wie
folgt
ab:


PROCEDURE
a;
PROCEDURE
b;
BEGIN
END;

BEGIN

END;

ersetzen
durch

≡


PROCEDURE
b;

BEGIN

END;

PROCEDURE
a;

BEGIN

END;

≡≡Fehler-Hilfe:106

Fehlerursache:

Die
Tabelle
für
den
Programm-Code
ist
voll.

Abhilfe
:
Versuchen
Sie,
den
Programmumfang
durch
Streichen
nicht
benötigter
Programmteile
zu
verringern.

≡≡Fehler-Hilfe:107

Fehlerursache:

Die
Tabelle
für
String-Einträge
ist
voll.

Abhilfe
:
Versuchen
Sie,
mit
weniger
String-Deklarationen
auszukommen.

≡≡Fehler-Hilfe:108

Fehlerursache:

Die
Tabelle
für
Eingabefelder
ist
voll.

Abhilfe
:
Teilen
Sie
die
Eingabe
der
Variablen
auf
und
verwenden
Sie
zwischendurch
die
Prozedur
LiesEingaben.

≡≡Fehler-Hilfe:152

Fehlerursache:

Mengen
sind
in
ITG-PASCAL
(noch)
nicht
implementiert.

Abhilfe
:
Versuchen
Sie,
SET
durch
andere
Anweisungen
zu
ersetzen.

≡≡Fehler-Hilfe:153

Fehlerursache:

Zeiger
(Pointer)
sind
in
ITG-PASCAL
(noch)
nicht
implementiert.

Abhilfe
:
Versuchen
Sie,
statische
Variablen
zu
benutzen.

≡≡Fehler-Hilfe:154

Fehlerursache:

LABEL
wird
in
ITG-PASCAL
nicht
implementiert.

Abhilfe
:
Verwenden
Sie
strukturierte
Schleifen.

≡≡Fehler-Hilfe:155

Fehlerursache:

GOTO
wird
in
ITG-PASCAL
nicht
implementiert.

Abhilfe
:
Verwenden
Sie
strukturierte
Schleifen.

≡≡ITG-PASCAL-Hilfe-Ende