FirstStep - Eine Ausbildungssprache

Inhalt

1. Die Struktur von FirstStep
2. Link-Definitionen
3. Schreibweise
4. Blöcke
5. Definitionen
6. Deklarationen
7. Anweisungen
8. Funktionen und Prozeduren
9. Klassen
10. Ein- und Ausgabe, Dateien und Verbindungen
11. Syntax

Anhang:

1. Beispiele
2. Module
3. Dokumentation zu FirstStep in Word 6.0
   Dokumentation zu FirstStep in Word 7.0
   Dokumentation zu FirstStep in PostScript

zurück Index vor

6 Deklarationen

6.1 Allgemeines

Deklarationen werden durch das Schlüsselwort declare (im Hauptprogramm durch DECLARE) eingeleitet. Deklarationen werden durch ";" getrennt aufgelistet:

declareDef : {deklaration ";"}** deklaration [";"] ;

Deklarationen bewirken die Deklaration bzw. Instanziierung von Objekten. Eine deklaration hat das Format:

deklaration : ["->"] ["constant"] typangabe ["array["dimension"]"] bezeichner [":=" wert] ;

Dabei ist wert von typangabe abhängig, d.h. die dort stehende Konstante bzw. der Konstantenausdruck muß einen Wert entsprechenden Typs ergeben.

6.2 Einfache Typen

FirstStep kennt die folgenden einfachen Typen, die hier in einer Beispieldeklaration aufgelistet werden:

integer Zahl; -- ganze Zahl 32 Bit Länge: 0, 1, 2, ...
real Dezimal; -- Gleitpunktzahl 64 Bit Länge: 0.1,,..., 2.5, ...
boolean IstWahr; -- logischer Wert. 8 Bit Länge: "false", "true"
bit Binaer; -- zweiwertiger Wert. 8 Bit Länge: "0", "1"
char Zeichen; -- ASCII-Zeichen, 8 Bit Länge: "A", "B",..., "Z",...
-> integer RefToZahl; -- Referenz, lokale Adreßlänge: Speicheradresse

Diese Objekte können auch konstant sein, z.B.:

costant integer Hundert := 100; -- ganze Zahl mit Wert 100
constant real Dezimal := 27.5; -- Gleitpunktzahl mit Wert 27,5

Konstante Objekte besitzen keine Adressen. Sie können also vom Compiler statt der Namen in das Programm eingesetzt werden.

Auf analoge Weise können die Werte von Variablen initialisiert werden.

integer Zahl := 2; -- ganze Zahl mit Wert zwei
real Dezimal := 2.0; -- Gleitpunktzahl mit Wert zwei
boolean IstWahr := true; -- logischer Wert wahr
bit Binaer := dual 1; -- zweiwertiger Wert 1
char Zeichen := 'A'; -- ASCII-Zeichen 'A'
-> real RefToZahl :- real object(2);-- Referenz auf Real-Objekt mit Wert zwei

Die Angabe typangabe object(wert) mit dem Schlüsselwort object erzeugt ein Objekt des angegebenen Typs und initialisiert es mit dem angegebenen Wert. Als Ergebnis liefert dieser Ausdruck die Adresse dieses Objekts zurück. Ergibt sich der Typ aus dem Kontext (im Beispiel real), so kann die Typangabe vor object entfallen.

6.3 Strukturierte Typen

An strukturierten Objekten gibt es Texte, Felder und Records sowie Klasseninstanzen.

Es gibt drei verschiedene Arten von Texten, die wir wieder in Beispien einführen:

text Name := "Meyer"; -- Text fester Länge mit 5 Zeichen
text [30] Vorname := "Hansi"; -- Text fester Länge mit 30 Zeichen
text [] Ort := "Hamburg"; -- Text variabler Länge

Texte können feste oder variable Längen haben; bei variabler Länge wird in der Regel bei jeder Kopieroperation neuer Speicherplatz alloziiert, so daß dieses sehr laufzeitaufwendig ist. Dafüer können keine Bereichsüberschreitungen auftreten, so daß dieses sehr sicher ist.

Texte haben im Prinzip alle verschiedenen Typ, sind jedoch bezüglich Kopier- und Vergleichsoperationen kompatibel, auch wenn sie sich evtl. in der Anzahl der Zeichen unterscheiden. Somit kann ein Text auf einen anderen Text fester Länge kopiert werden, wenn er nicht länger ist als dieser. Der Rest wird durch das NUL-Zeichen (0016) aufgefüllt. Zur effizienteren Verarbeitung wird hinter jedem Text das NUL-Zeichen eingefügt, so daß Texte in der Regel ein Byte mehr Speicher belegen als angegeben.

Für Texte sind die Operationen: Kopieren (mit Einfügen, Ausschneiden und Anhängen) sowie Vergleichen definiert:

Beispiel

declare
text [] Name;
do
Name := "123456789ABCDEF"; –– binde Textkonstante an Name
Name == "123456789ABCDEF"; -- ="123456789ABCDEF"
Name[3] == '3'; -- Texttyp wird zu Zeichentyp
Name[2,4] := "234"; -- Textausschnitt
Name[6,..] == "6789ABCDEF"; -- Textendstück
Name[2..4] + Name[15] + "ool" == "234Fool"; -- Konkatenation
|Name| == 16; -- Textlänge
Name := "."*10; -- Vervielfachung
Name = ".........."; -- = ".........."
done;

Ein Feld wird durch den Typ seiner Komponenten sowie durch seine Ausdehnung spezifiziert.

array integer [1..100, 2..5] ZahlFeld; -- 100x4-Feld ganzer Zahlen
array -> real [1..100] DezRefFeld; -- Feld mit 100 Zeigern auf real-Zahlen

Bei der Initialisierung eines Feldes wird zuerst der hintere Index variiert; da der erste Index bei einer Matrix den Zeilenindex angibt, werden Felder also zeilenweise initialisiert:

integer array [1..3, 2..5] ZahlFeld := 12, 13, 14, 15,
22, 23, 24, 25,
32, 33, 34, 35;

Die Punktnotation Von .. Bis ist äquivalent den Werten: Von, Von+1, Von+2, ..., Bis-1, Bis.

Datensätze oder Records werden durch Auflistung ihrer Komponenten zwischen den Schlüsselwörter record und end record spezifiziert. Für Records gilt beispielsweise:

record
integer Wert;
real Zahl;
bollean Wahr;
end record
Datensatz;

Diese Deklaration erzeugt einen Datensatz mit drei Einträgen. Auch hier ist eine Initialisierung möglich, die wahlweise explizit:

record
integer Wert := 2;
real Zahl := 3.14159;
bollean Wahr := true;
end record
Datensatz;

oder kompakt durchgeführt werden kann:

record
integer Wert;
real Zahl;
bollean Wahr;
end record,
Datensatz := (2, 3.14159, true);

Die folgenden Beispiele zeigen die Deklaration von Bitfeldern und Mengen:

bit array [1..32] BitFeld; -- Deklaration eines Bitfeldes
integer 2..100 set Menge; -- Deklaration der Menge {2,3..,100}
character set Zeichen;   -- Menge aller ASCII-Zeichen
enumeration Farben = Rot, Gelb, Gruen; -- Konstantendeklaration
Farben set SignalFarben; -- Deklaration der Menge {Rot, Gelb, Gruen}

Bitfelder und Mengen müssen als Bitfolgen implementiert werden und verlangen die folgenden speziellen Operatoren:

Bedeutung	Mengennotation	Operation auf Menge	Operation auf Bitfeld
Ist Element	Element Î Menge	Element == Menge	BitFeld[Nr] == 1;
In Menge	{Element} È Menge	Menge + Element	BitFeld[Nr] := 1;
Aus Menge	Menge | {Element}	Menge - Element	BitFeld[Nr] := 0;
Gleichheit	Menge1 = Menge2	Menge1 == Menge2	BitFeld1 == BitFeld2
Ungleichheit	Menge1 != Menge2	Menge1 <> Menge2	BitFeld1 <> BitFeld2
Teilmenge	Menge1 Ì Menge2	Menge1 < Menge2	BitFeld1 < BitFeld2
Vereinigung	Menge1 È Menge2	Menge1 + Menge2	BitFeld1 or BitFeld2
Durchschnitt	Menge1 Ç Menge2	Menge1 * Menge2	BitFeld1 and BitFeld2
Differenz	Menge1 — Menge2	Menge1 - Menge2	BitFeld1 - BitFeld2
symm. Differ.	Menge1 D Menge2	Menge1 / Menge2	BitFeld1 xor BitFeld2
schieb n rechts			BitFeld1 + Nr
schieb n links			BitFeld1 - Nr

Man beachte, daß es sich hier jeweils um eine Wertesemantik handelt,d.h. daß die Typgleichheit vorausgesetzt wird. Beispielsweise bedeutet Menge1  ==  Menge2, daß beide vom gleichen Mengentyp sind, beispieslweise Farben set. Enthalten dann beide Mengen genau die gleichen Elemente, so ist das Ergebnis "wahr", sonst falsch. Ebenso müssen zwei Bitfelder von gleichem Typ sein, also insbesondere beide den gleichen Indexbereich haben.

Mengen können explizit angegeben werden, indem ihre Werte in geschweifte Klammern aufgezählt werden:

declare
Farben set SignalFarben := {Rot, Gruen};
do
Signalfarben := Signalfarben + Gelb;

wobei auch eine Punktnotation zulässig ist:

integer 2..100 set Menge := {};
Menge := {2..5, 7..9} -- Menge == {2,3,4,5,7,8,9};

Hierbei muß die Menge in der jeweiligen Umgebung eindeutig aus dem Kontext herleitbar sein. Ähnliches gilt für Bitfelder:

bit array [1..32] BitFeld := {0,1,0..0}; -- BitFeld == 01000...00
Bitfeld [3] := 1; -- BitFeld == 01100...00
Bitfeld := Bitfeld or {1,1,1,1,1,0..0}; -- BitFeld == 111110...0

Somit wird 0..0 mit so vielen Nullen aufgefüllt, bis der Ausdruck in der Länge mit dem des Kontexts übereinstimmt; analoges gilt für 1..1.

Dateien werden mit dem Schlüsselwort file deklariert:

file DateiName;

Es handelt sich bei Dateien logisch um Textobjekte, die eine beliebige Anzahl von Zeichen aufnehmen können. Allerdings können Zeichen nur geschrieben werden, wenn die Datei zum Schreiben geöffnet wurde, und sonst nur gelesen werden. Genaueres hierzu siehe Abschnit 11.

6.4 Erweiterter Zugriff auf Objekte: disclose

Durch das Schlüsselwort disclose läßt sich ein Klassenobjekt oder ein Datensatz dereferenzieren, so daß dessen (öffentlichen) Objekte in der jeweiligen Umgebung bekannt sind.

discloseDef : { discloseObj ";" }+ discloseObj ";" ;
discloseObj : bezeichner
| bezeichner "object" ["(" parList ")"]
| bezeichner bezeichner ":-" "object" "("parList")"] ;

Dieses muß jeweils vor einer Deklaration in einer eigenen Abteilung geschehen, wobei jedoch mehrere Datenobjekte geöffnet werden können.

disclose ClassName; -- zeige alle öffentlichen Namen von ClassName
RecordName; -- zeige alle Namen von RecordName
declare
...
do
...

Ist ClassName eine Klasse (d.h. eine Typbeschreibung), so sind alle Namen aus ClassName bekannt, jedoch existiert keine Instanz dieser Klasse. Werden diese benötigt, so kann man schreiben:

disclose
ClassName object(...); -- alle öffentlichen Namen einschließlich
declare -- Instanzierung von Objekten
...

Diese Instanz wird am Ende eines Blocks automatisch wieder gelöscht, da es keine Möglichkeit gibt, auf diese darüber hinaus zuzugreifen, und da der Programmierer daher keine explizite Löschfunktion wie dispose aufrufen kann.. Ist ClassObject eine Instanz einer Klasse bzw. eine Referenz auf eine solche Instanz, so wird durch

disclose
ClassObject; -- alle öffentlichen Namen der Instanz
declare -- ClassObject
...

diese Instanz geöffnet. Ihre Werte können somit innerhalb dieses Blocks verändert werden. Natürlich ist es möglich, eine Referenz auf eine Instanz zu generieren und diese zugleich zu öffnen.

disclose ClassName ClassObject -- alle öffentlichen Namen des neu
:- object(...); -- instanziierten ClassObject declare ...

Diese Instanzen können am Ende des Blocks nicht automatisch gelöscht werden, da der Compiler nicht kontrollieren kann, ob auf diese Instanz eine weitere Referenz existiert.

disclose ist der Mechanismus, mit dem FirstStep die Vererbung durchführt, indem eine disclose-Deklaration auf eine Basisklasse innerhalb einer Klasse die Methoden und gegebenenfalls Variablen der Basisklasse einbindet.

Weitere Informationen zu FirstStep finden Sie in dem Buch "System, Model, Programm".

zurück Index vor