imported>Algol68g: /* Weblinks */

2026-04-27T12:53:27Z

Weblinks

Neue Seite

'''Algol 68''' ist eine [[Programmiersprache]]. Ihr Entwurf beruhte auf den Anforderungen, dass sie geeignet sein soll, [[Algorithmus|Algorithmen]] darzustellen und zu verbreiten, diese effizient auf einer Vielzahl unterschiedlicher Rechenanlagen auszuführen und um zu helfen, sie Studenten zu lehren.

Die Sprache Algol 68 stellte einen neuen Anlauf dar, beruhte jedoch auf den Erfahrungen mit [[Algol 60]] und den Prinzipien dieser Sprache. Ziel war ein wesentlich breiterer Anwendungsbereich und eine stringentere Sprachdefinition. Die Definition wurde als ''Report on the Algorithmic Language ALGOL 68'' erstmals 1968 veröffentlicht und 1976 im ''Revised Report'' grundlegend revidiert.

Der Bericht nennt als Ziele: Vollständigkeit und Klarheit der Beschreibung, [[Orthogonalität (Informatik)|Orthogonalität]] des Entwurfes, Sicherheit, Effizienz.

Im Vergleich zu Algol 60 wurden einige Konzepte vereinheitlicht; neu eingeführt wurde das Konzept eines ''Namen''s, ein Wert, der auf andere Werte ''referenziert'', die Möglichkeit zur Definition von Strukturen und anderer Datentypen. Aus der geringeren Akzeptanz von Algol 60 verglichen mit [[FORTRAN]] wurde geschlossen, dass eine Definition von Ein- und Ausgabe die Verbreitung fördern könnte.

Kritiker wandten ein, die Sprache habe nicht mehr die Einfachheit von Algol 60 und sei zu schwierig zu implementieren. Konzepte, die in praktisch erfolgreicheren Sprachen wie [[C++]] weitere Verbreitung fanden, wie Überladen von Operatoren, wurden erstmals syntaktisch definiert. Im Unterschied zu Algol 60 ist die Sprache weitestgehend [[Ausdrucksorientierte Programmiersprache|ausdrucksorientiert]], daher auch als frühes Beispiel einer [[Funktionale Programmiersprache|funktionalen Programmiersprache]] anzusehen.

In der Beschreibung der Programmiersprache wurde ein neuartiges Beschreibungsverfahren, die 2-stufige Grammatik, auch [[Van-Wijngaarden-Grammatik]] genannt, entwickelt. Diese erlaubte es, alle [[Kontextsensitive Sprache|Kontextbedingungen]] mit zu formalisieren.

Neu war auch das Konzept [[Compiler-Anweisung|PRAGMAT]], das Hinweise zur Optimierung für die Compiler erlaubte, ohne die Semantik eines Programms zu ändern, sodass die Programme trotz Optimierung portabel blieben.

Algol 68 wurde von einigen als akademisches Projekt betrachtet, weil längere Zeit brauchbare [[Compiler]] fehlten, die den gesamten Sprachstand implementierten.

== Reservierte Symbole ==
In Algol 68 gibt es folgende reservierte Symbole:
'''mode''', '''op''', '''prio''', '''proc''',
'''flex''', '''heap''', '''loc''', '''long''', '''ref''', '''short''',
'''struct''', '''union''',
'''of''', '''at''', '''is''', '''isnt''', '''true''', '''false''', '''empty''', '''nil''', '''skip''',
'''co''', '''comment''', '''pr''', '''pragmat''',
'''case''', '''in''', '''ouse''', '''out''', '''esac''',
'''for''', '''from''', '''to''', '''by''', '''while''', '''do''', '''od''',
'''if''', '''then''', '''elif''', '''else''', '''fi'''
'''par''', '''begin''', '''end''', '''go''', '''to''', '''goto''', '''exit'''.

Für einige dieser Symbole gibt es Abkürzungen:
''p'' '''is''' ''q''     ↦ ''p'' :=: ''q''
''r'' '''isnt''' '''nil''' ↦ ''r'' :/=: ∘
'''skip''' ↦ ~
'''at'''   ↦ @
'''co'''   ↦ ¢
'''case''' ''x'' '''in''' ''a'', ''b'' '''ouse''' ''y'' '''in''' ''c'', ''d'', ''e'' '''out''' ''f'' '''esac''' ↦ ( ''x'' | ''a'', ''b'' |: ''y'' | ''c'', ''d'', ''e'' | ''f'' )
'''if''' ''x'' '''then''' ''a'' '''elif''' ''y'' '''then''' ''b'' '''else''' ''c'' '''fi'''         ↦ ( ''x'' | ''a'' |: ''y'' | ''b'' | ''c'' )
'''begin''' ''a''; ''b''; ''c'' '''end'''                           ↦ ( ''a''; ''b''; ''c'' )

Die Bezeichnungen für [[#Datentypen|Modes]] und Operatoren werden mit dem gleichen Zeichensatz geschrieben wie die reservierten Symbole, sind aber nicht reserviert, sondern können mit einer anderen Bedeutung deklariert werden, die dann innerhalb eines Blocks gilt. Folgende Modes sind ohne explizite Deklaration definiert:
'''bits''', '''bool''', '''bytes''', '''char''', '''compl''', '''int''', '''real''', '''sema''', '''string''', '''void''',
'''channel''', '''file''', '''format'''

== Compiler-Anweisungen und Kommentare ==
Compiler-Anweisungen werden in das Programm eingefügt. Sie enthalten typischerweise Hinweise für den Compiler, z. B.:
'''pragmat''' heap=32 '''pragmat'''
'''pr''' heap=32 '''pr'''

Kommentare können auf verschiedene Arten eingefügt werden:
¢ Der ursprüngliche Weg einen Kommentar hinzuzufügen (analog der englischen Phrase: Adding your 2 cents) ¢
'''comment''' "bold" comment '''comment'''
'''co''' Kommentar 1. Form '''co'''
# Kommentar 2. Form #
£ Dieser Kommentar benutzt das hash/pound Zeichen einer UK Tastatur £

Normalerweise können Kommentare in Algol 68 nicht geschachtelt werden. Diese Einschränkung kann umgangen werden, indem unterschiedliche Kommentarsymbole verwendet werden (z. B. Der Hash wird nur für kurzzeitiges Löschen verwendet).

== Datentypen ==
Algol 68 bezeichnet Datentypen als ''Modes''. Die grundlegenden Modes <code>'''real'''</code>, <code>'''int'''</code>, <code>'''compl'''</code>, <code>'''bool'''</code>, <code>'''char'''</code>, <code>'''bits'''</code>, <code>'''bytes'''</code> und <code>'''void'''</code> können auf verschiedene Weise zu weiteren Modes kombiniert werden. Bezeichnungen der Modes werden u. a. zur Deklaration von Konstanten verwendet, zum Beispiel:
'''int''' n = 2; '''co''' ''n ist eine Konstante mit dem Wert 2.'' '''co'''
'''real''' avogadro = 6.0221415⏨23; '''co''' ''Avogadrozahl'' '''co'''
'''long long real''' pi = 3.14159 26535 89793 23846 26433 83279 50288 41971 69399 37510;
'''compl''' square root of minus one = 0 ⊥ 1

Der Datentyp <code>'''void'''</code> umfasst nur einen einzigen Wert, nämlich <code>'''empty'''</code>, hat also keinen Informationsgehalt. Damit werden Ausdrücke und Funktionen charakterisiert, die kein verwertbares Ergebnis liefern; so werden die Konzepte ''Ausdruck'' und ''Anweisung'' vereinheitlicht, ebenso ''Funktion'' und ''Prozedur''. Beispiele:
'''exit'''; '''¢''' Ausdruck vom Mode '''void''', entspricht der FORTRAN-Anweisung STOP '''¢'''
print(f); '''¢''' Ausdruck vom Mode '''void''', da print keinen Funktionswert liefert '''¢'''
7*"8"; '''¢''' Ausdruck vom Mode '''string''' mit dem Wert "8888888" '''¢'''
'''proc''' ('''int''')'''int''' doppelt = ('''int''' i)'''int''' : i*2; '''¢''' Funktion mit '''int'''-Ergebnis '''¢'''
'''proc''' ('''int''')'''void''' wellenlinie = ('''int''' n)'''void''': print(n*"~"); '''¢''' Prozedur (ohne Ergebnis) '''¢'''

Statt modes wie <code>DOUBLE</code>, beziehungsweise <code>LONG</code> und <code>SHORT</code>, etc. gibt es in Algol 68 ''Modifizierer''. So wird zum Beispiel <code>'''long''' '''real'''</code> oder <code>'''long''' '''long''' '''real'''</code> statt <code>DOUBLE</code> geschrieben. ''Typattribute'' wie <code>small real</code> (kleinster '''real'''-Wert, der bei Addition zu 1.0 ein Ergebnis ungleich 1.0 liefert) und <code>max long int</code> (größter darstellbarer '''long'''-'''int'''-Wert) sind Konstanten, die die Eigenschaften der jeweiligen Implementierung beschreiben; sie werden verwendet, um Programme an verschiedene Implementierungen anzupassen.

== Deklarationen ==

Alle Bezeichner, etwa für Konstanten, Namen (entspricht Variablen und Pointern in früheren Programmiersprachen) oder Funktionen, müssen vereinbart werden; die Vereinbarung muss nicht vor der ersten Verwendung gemacht werden, aber natürlich ist für deren Sichtbarkeits-Bereich die [[Blockstruktur]] zu beachten. Viele ''Standard-Bezeichner'' etwa <code>print</code> oder <code>max int</code>sind in einem fiktiven, das gesamte Programm umgebenden, Block deklariert.

Dazu dient einheitlich die sogenannte Äquivalenz-Deklaration, mit der einem Bezeichner eine Bedeutung, bestehend aus Mode und Wert, zugewiesen wird. Beispiele:
'''co''' Konstanten '''co'''
'''int''' f = 5; '''¢''' der Bezeichner ''f'' bezeichnet nun den '''int'''-Wert 5 '''¢'''
'''real''' z = f/2; '''¢''' der Bezeichner ''z'' bezeichnet nun den '''real'''-Wert 2.5 '''¢'''
'''real''' r = random; '''¢''' der Wert der Konstanten ''r'' wird erst zur Laufzeit des Programms bestimmt '''¢'''
'''co''' Variable '''co'''
'''ref''' '''int''' v = '''loc''' '''int'''; '''¢''' ''v'' bezeichnet eine neu deklarierte lokale '''int'''-Variable '''¢'''
'''ref''' '''int''' w = '''loc''' '''int''' := f; '''¢''' ''w'' bezeichnet eine lokale '''int'''-Variable mit Anfangswert 5 '''¢'''
'''co''' Funktionen '''co'''
'''proc''' ('''real''')'''real''' h = ('''real''' x)'''real''': x/2; '''¢''' ''h'' bezeichnet eine '''real'''-Funktion mit '''real'''-Parameter '''¢'''

Konstanten, Variable, Pointer und Funktionen können jedoch auch anonym, also ohne Deklaration verwendet werden. Das bietet sich an, wenn man die betreffende ''Entity'' nur an einer Stelle im Programm benötigt. Beispiel:
'''¢''' ''integral'' sei eine Funktion, die ein [[Integralrechnung|bestimmtes Integral]] über einer '''real'''-Funktion berechnet. '''¢'''
'''¢''' Die zu integrierende Funktion kann man entweder namentlich oder anonym an ''integral'' übergeben; '''¢'''
'''¢''' die zu integrierende Funktion hat offensichtlich den Mode '''proc'''('''real''')'''real''' '''¢'''
print(("Integral x/2 von 0 bis 3 =", integral (h, 0, 3 ))); '''¢''' ''h'' siehe oben '''¢'''
print(("Integral sin(x) von 0 bis π =", integral (sin, 0, pi))); '''¢''' ''sin'' und ''pi'' sind Standard-Bezeichner '''¢'''
print(("Integral (2x+1) von 0 bis 1 =", integral (('''real''' x)'''real''': 2*x+1, 0, 1))); '''¢''' Anonyme Funktion '''¢'''

Ähnlich wie Bezeichner können Modes und Operatoren deklariert werden. Beispiele:
'''mode''' '''rfun''' = '''proc'''('''real''')'''real'''; '''¢''' '''rfun''' ist der Mode einer '''real'''-Funktion mit '''real'''-Parameter '''¢'''

'''¢''' Operatoren sind Funktionen in anderer Gestalt; also werden sie wie Funktionen deklariert: '''¢'''
'''op''' ('''string''','''int''')'''string''' * = ('''string''' s, '''int''' n)'''string''': n*s;
print("/\"*17); '''¢''' im Gültigkeitsbereich der obigen '''op'''-Deklaration druckt das dasselbe wie print(17*"/\") '''¢'''

Für einige gängige Äquivalenz-Deklarationen gibt es Abkürzungen. Zum Beispiel:
'''loc''' '''int''' v; '''¢''' statt '''ref''' '''int''' v = '''loc''' '''int''' – '''int'''-Variable '''¢'''
'''loc''' '''int''' w := f; '''¢''' statt '''ref''' '''int''' w = '''loc''' '''int''' := f – '''int'''-Variable mit Anfangswert '''¢'''
'''int''' w := f; '''¢''' statt '''ref''' '''int''' w = '''loc''' '''int''' := f '''¢'''
'''proc''' h = ('''real''' x)'''real''': x/2; '''¢''' statt '''proc''' ('''real''')'''real''' h = ('''real''' x)'''real''': x/2 '''¢'''
'''op''' * = ('''string''' s, '''int''' n)'''string''': n*s; '''¢''' statt '''op''' ('''string''','''int''')'''string''' * = ('''string''' s, '''int''' n)'''string''': n*s '''¢'''

== Hardware-Darstellung ==

Die Zeichen, mit denen Algol-68-Programme (in Beschreibungen, auch im vorliegenden Wikipedia-Artikel) geschrieben werden, standen 1968 auf keinem Computer zur Verfügung; das gilt insbesondere für die fette Schrift, in der Modes, Operatoren und reservierte Symbole geschrieben werden. Fehlende Operator-Zeichen können durch Wortsymbole ersetzt werden, etwa <code><</code> durch <code>'''lt'''</code>. Aber dann muss immer noch die fette Schrift von der regulären unterschieden werden. Der Report sieht dafür eine ''Stropping Convention'' vor. Das Wort ''Stropping'' wird sonst nur im Friseur-Handwerk benutzt und bezeichnet das Schärfen des Rasiermessers am [[Streichriemen]].

Die verbreitetste Stropping-Konvention wurde zusammen mit dem ''Revised Report'' veröffentlicht.<ref>{{Literatur| Autor=Wilfred J. Hansen; Hendrik Boom| Titel=The Report on the Standard Hardware Representation for ALGOL 68| Sammelwerk=ACM SIGPLAN Notices| Band=12| Nummer=5| Datum=1977-05| Seiten=80–87| Online=[https://dl.acm.org/doi/10.1145/954652.1781178 Scan] | Abruf=2023-01-23}}</ref> Diese ''Standard-Hardware-Darstellung'' unterscheidet drei Stropping-Varianten, die jeweils durch ein [[#Compiler-Anweisungen und Kommentare|Pragmat]] angekündigt werden. In allen drei Konventionen beendet ein Leerzeichen oder ein anderes Trennzeichen das Wortsymbol.

=== Point Stropping ===

Diese Konvention ist immer aktiv, muss also nicht explizit angekündigt werden.<ref>Das Pragmat <code>.PR POINT .PR</code> schaltet gegebenenfalls andere Stropping-Varianten aus.</ref> Groß- und Kleinbuchstaben werden nicht unterschieden; Wortsymbole werden durch einen vorangestellten Punkt markiert. Das [[Hallo-Welt-Programm]] (süddeutsche Variante)
'''begin''' print(("Grüß Gott!", new line)) '''end'''
kann demnach so geschrieben werden:
.BEGIN PRINT(("Grüß Gott!", NEW LINE)) .END

=== Upper Stropping ===

Hier werden die Wortsymbole in [[Versalien]] geschrieben, Bezeichner dürfen keine Versalien enthalten. Das Hallo-Welt-Programm sieht dann so aus:
.PR UPPER .PR
BEGIN print(("Grüß Gott!", new line)) END

=== Res Stropping ===

Hier werden 61 reservierte Wörter erkannt, weitere Wortsymbole müssen per Point Stropping markiert werden. Mit Unterstrich werden Bezeichner markiert, die sonst als reserviertes Wort erkannt würden; der Unterstrich kann auch statt des Leerzeichens eingesetzt werden, um einen Bezeichner zu gliedern. Das Hallo-Welt-Programm sieht dann so aus:
.PR RES .PR
BEGIN PRINT(("Grüß Gott!", NEW_LINE)) END

== Literatur ==
* [[Adriaan van Wijngaarden]] et al.: ''Revised Report on the Algorithmic Language ALGOL 68.'' In: ''Acta Informatica.'' Vol. 5, No. 1/3, 1975, {{ISSN|0001-5903}}, S. 1–236, [http://www.fh-jena.de/~kleine/history/languages/Algol68-RevisedReport.pdf online] (PDF, 1,4 MB).
* {{Literatur| Autor=Charles H. Lindsey, Sietse G. van der Meulen| Titel=Informal Introduction to Algol 68| TitelErg=revised edition, second printing| Verlag=[[North Holland]]| Ort= Amsterdam · New York · Oxford| Datum=1981| ISBN=0720407265| Online=https://hal.inria.fr/hal-03027689/file/Lindsey_van_der_Meulen-IItA68-Revised.pdf| Format=PDF| KBytes=18319| Sprache=en| Abruf=2021-10-18}}
* [[Andrew S. Tanenbaum]]: ''A Tutorial on ALGOL 68.'' In: ''ACM Computing Surveys.'' Vol. 8, No. 2, 1976, {{ISSN|0360-0300}}, S. 155–190.

* Sian Leitch: {{Webarchiv | url=http://www.nunan.fsnet.co.uk/algol68/pame.pdf | wayback=20120208131207 | text=''Programming Algol 68. Made Easy''}}. (PDF; 1,36 MB).

== Weblinks ==
* [https://algol68-lang.org/ algol68-lang.org]
* [https://algol68genie.nl/ Algol 68 Genie, ein Algol 68 Interpreter]

== Einzelnachweise ==
<references />

{{Normdaten|TYP=s|GND=4141871-2}}

[[Kategorie:Imperative Programmiersprache]]

Algol 68 - Versionsgeschichte

imported>Algol68g: /* Weblinks */