Adele (Algorithmenbeschreibungssprache)

Adele (algorithm description language) ist eine Algorithmenbeschreibungssprache, welche sich auf essenzielle Sprachkonstrukte beschränkt. Infolgedessen ist Adele weitestgehend frei von syntaktischem Ballast und lässt dem Anwender viele Ausdrucksmöglichkeiten, wodurch das Lesen der Algorithmen erleichtert wird. Adele ist eine Pseudocode-Sprache, dessen Modellierung von Algorithmen jedoch weniger abstrakt ist. Der Adele-Syntax hat Einflüsse aus verschiedenen Programmiersprachen, lehnt sich aber hauptsächlich an Pascal und Modula-2 an. Eine andere Algorithmenbeschreibungssprache, welche sich jedoch an die Java-Syntax anlehnt, ist Jana.

Die in Adele geschriebenen Algorithmen sind nicht an eine spezifische Programmiersprache gebunden, so dass die Algorithmen lediglich als eine Art Schablone dienen und die spätere Implementierung in der gewünschten Programmiersprache erfolgen muss. Insbesondere eignet sich Adele zu Lehrzwecken, wenn man beispielsweise als Buchautor keine konkrete Programmiersprache für die Beschreibung seiner Algorithmen verwenden möchte.

Gesamtstruktur und Schreibkonvention

Funktionen

Funktionen besitzen einen Namen, einen Rückgabetyp, Ein- und Ausgabeparameter. Verschiedene Parameter werden durch Leerzeichen getrennt.

Beispiel

Mein_Algorithmus(↓param1 ↓param2 ↑param3): Integer
begin
   ANWEISUNG(EN)
   return param3
end Mein_Algorithmus

↓ steht für ein Eingabeparameter (hier: param1 und param2) und ↑ für Ausgabe- bzw. Rückgabeparameter (hier: param3). Darüber hinaus werden Übergangsparameter mit ↕ gekennzeichnet.

Zu beachten ist, dass die Typisierung der Parameter nicht in der Signatur stattfindet, sondern im Funktionsrumpf durch param.

Beispiel:

Mein_Algorithmus(↓param1 ↓param2 ↑param3): Integer
param param1: Integer;
      param2: Boolean;
begin
   ANWEISUNG(EN)
   return param3
end Mein_Algorithmus

Variablen

Die Zuweisung von Variablen ist sehr suggestiv und identisch mit den meisten Programmiersprachen. Als Konvention ist es sinnvoll, Variablen mit einem kleinen Buchstaben zu beginnen.

Die Syntax lautet:

Variable := Ausdruck

Beispiel:

meine_variable := 5;

Prozedur-/Funktionsaufrufe

Der Funktionsaufruf erfolgt wie eine gewöhnliche Anweisung. Eventuell erforderliche Übergabeparameter werden mit einem ↑ gekennzeichnet (mehrere Parameter werden mit Leerzeichen getrennt). Um Variablen besser von Funktionen unterscheiden zu können, ist es sinnvoll, den Anfangsbuchstaben groß zu schreiben.

Syntax:

Funktionsname(↑parameter_1 ↑parameter_2... ↑parameter_n)

Beispiel:

Meine_Funktion(↑param1)

Anweisungsblöcke

Anweisungsblöcke werden in aller Regel mit einem end abgeschlossen (Modula-2-Konvention). Lediglich repeat... until benötigen kein end.

Bedingungen

Syntax von if-Bedingungen:

if AUSDRUCK then ANWEISUNG(EN)
{elsif AUSDRUCK then ANWEISUNG(EN)}
[else ANWEISUNG(EN)]
end

Syntax von case-Bedingungen:

case AUSDRUCK of
| Marke: ANWEISUNG(EN)
| Marke: ANWEISUNG(EN)
...
[else ANWEISUNG(EN)]
end

Schleifen und Schleifenabbrüche

Syntax von while-Schleifen:

while AUSDRUCK do ANWEISUNG(EN) end

Syntax von repeat-Schleifen:

repeat ANWEISUNG(EN) until AUSDRUCK

Syntax von for-Schleifen:

for VARIABLE := AUSDRUCK to AUSDRUCK [by AUSDRUCK] to ANWEISUNG(EN) end

VARIABLE ist nach dem Schleifendurchlauf undefiniert.

Syntax von loop:

loop ANWEISUNG(EN) exit end

Verlassen einer inneren Loop-Anweisung mit

exit

Abbruch und Rückgabewerte von Prozeduren/Funktionen

Verlassen einer Funktion mit

return

Verlassen einer Funktion mit Rückgabewert durch

return AUSDRUCK

Beenden eines Algorithmus ohne Rückkehr zum übergeordneten Algorithmus durch

halt

Ein- und Ausgabe

Lese ein Mediem an der Position x oder dem Dateiende aus

Read(↑x ↑eof)

Schreibe x auf ein Medium

Write(↓x)

Zeilenumbruch auf dem Ausgabemedium

WriteLn

Ausdrücke

Ausdrücke bestehen aus den in anderen Programmiersprachen üblichen Operationen (+, -, |, & etc.) und Kombinationen aus Operanden und Operationen. Für boolesche Ausdrücke wird die Kurzschlussauswertung verwendet.

Deklarationen

Variablen und Konstanten können in Adele zwischen Funktionskopf und beginn deklariert werden:

Syntax für Variablen:

Variable: Typ

Syntax für Konstanten:

Konstante = Wert

Beispiel:

Meine_Funktion(↓param1 ↓param2 ↑param3): Integer
variable1: Integer;
variable2: Boolean;
konstante1 = 10;
konstante2 = 3;
...
begin
   ANWEISUNG(EN)
   return param3
end Meine_Funktion

Datentypen

Es werden die in Pascal und Modula-2 üblichen Datentypen zur Verfügung gestellt:

Integer
Real
Boolean
Char
Enumerationstypen, zum Beispiel (nord, sued, west, ost)
Array[Index: Index] of Typ -- Die Angabe einer Grenze ist nicht zwingend. Es reicht auch Array of Typ zu schreiben
Record a: Typ, b: Typ; ... end

Modifier

static

Variablen können als statisch deklariert werden, wodurch ihr Wert nach dem Funktionsende nicht verworfen wird und beim nächsten Aufruf der Funktion wieder zur Verfügung steht.

static variable: Typ

static mit Vorinitialisierung durch init

static variable: Typ init(false)

param Die Typzuweisung findet in Adele nicht in Signatur statt. Durch param können Funktionsparametern Typen zugewiesen werden. param kann auf mehrere Variablen hintereinander angewendet werden.

param parameter: Typ;

Siehe Beispiel unter Funktionen

local

Durch local können lokale Variablen wie z. B. Schleifenvariablen deklariert werden. local kann auf mehrere Variablen hintereinander angewendet werden.

local variable: Typ;

global

Durch global können globale Variablen (auch aus einer Funktion heraus) deklariert werden. global kann auf mehrere Variablen hintereinander angewendet werden.

global variable: Typ;

Kommentare

Adele benutzt für Kommentare die Ada-Schreibweise. Kommentare werden durch ein Doppel-Minus eingeleitet und gehen bis zum Ende der Zeile. Mehrzeilige Kommentare sind nicht möglich:

Beispiel:

-- Dies ist ein Kommentar

Standardfunktionen

In Adele sollten keine spezifischen Funktionen einer konkreten Programmiersprache benutzt werden, denn Adele soll so allgemein wie möglich gehalten werden. Daher ist es sinnvoll, nur Funktionen zu benutzen deren Zweck unmittelbar aus dem Funktionsnamen hervorgeht oder statt einer Funktion entsprechende Anweisungen zu benutzen.

Beispiele:

statt INC(i): i:=i+1
statt ODD(i): i mod 2 = 1

Zulässig hingegen sind:

Ord(↓ch)

Liefert den Ordinalwert eines Zeichens.

Chr(↓x)

Liefert das Zeichen für den Ordinalwert x.

Klassen, Objekte, Module und andere Konstrukte

Für alle restlichen Konstrukte gibt es keine Vorschriften. Es wird allerdings empfohlen, die Notation der Pascal-Sprache anzuwenden.

Literatur und Quellen

Rechenberg und Pomberger: Informatik-Handbuch. Carl-Hanser-Verlag, München/Wien 2002. 1189 S. ISBN 3-446-21842-4