ALGOL 68 - ALGOL 68

ALGOL 68

Revidovaná zpráva o algoritmickém jazyce - Algol 68 Upravil: A. van Wijngaarden a kol., Září 1973[1]
Paradigmata	Multi-paradigma: souběžně, rozkazovací způsob
Rodina	ALGOL
Navrhl	A. van Wijngaarden, B. J. Mailloux, J. E. L. Peck a C. H. A. Koster, et al.
Poprvé se objevil	Závěrečná zpráva: 1968; Před 52 lety (1968)r0
Stabilní uvolnění	Algol 68 / RR / Revidovaná zpráva: 1973; Před 47 lety (1973)R1
Psací disciplína	statický, silný, bezpečný, strukturální
Rozsah	Lexikální
Hlavní, důležitý implementace
ALGOL 68C, Algol 68 Genie (nedávný), ALGOL 68-R, ALGOL 68RS, ALGOL 68S, FLACC, Алгол 68 Ленинград / Leningrad Unit, Odra ALGOL 68
Dialekty
ALGOL 68 / FR (závěrečná zprávar0)
Ovlivněno
ALGOL 60, ALGOL Y
Ovlivněno
C,[3][5] C ++,[6] Bourneova skořápka, KornShell, Bash, Ocelový muž, Ada, Krajta,[7] 7. semeno, Mary, S3

ALGOL 68 (zkratka pro Algoritmický jazyk 1968) je rozkazovací způsob programovací jazyk který byl koncipován jako nástupce ALGOL 60 programovací jazyk, navržený s cílem mnohem širšího rozsahu aplikace a přesněji definovaný syntax a sémantika.

Složitost definice jazyka, která sahá až k několika stovkám stránek naplněných nestandardní terminologií, byla vytvořena překladač implementace obtížná a bylo řečeno, že nemá „žádné implementace a žádní uživatelé“. To byla jen částečně pravda; ALGOL 68 našel uplatnění na několika specializovaných trzích, zejména na Spojené království kde to bylo populární na International Computers Limited (ICL) stroje a ve vyučovacích rolích. Mimo tato pole bylo použití relativně omezené.

Příspěvky ALGOL 68 do oblasti počítačová věda byly hluboké, rozsáhlé a trvalé, ačkoli mnoho z těchto příspěvků bylo veřejně identifikováno, až když se znovu objevily v následně vyvinutých programovacích jazycích. Mnoho jazyků bylo vyvinuto konkrétně jako reakce na vnímanou složitost jazyka, nejpozoruhodnější bytost Pascal, nebo byly reimplementace pro konkrétní role, jako Ada.

Mnoho jazyků sedmdesátých let sleduje svůj design konkrétně na ALGOL 68, přičemž vybírá některé funkce, zatímco upustí od jiných, které byly pro dané role považovány za příliš složité nebo mimo rozsah. Mezi nimi je i jazyk C, který byl přímo ovlivněn ALGOLem 68, zejména jeho silné psaní a struktur. Většina moderních jazyků vystopuje alespoň část své syntaxe buď k C nebo Pascal, a tedy přímo nebo nepřímo k ALGOL 68.

Přehled

Mezi funkce ALGOL 68 patří syntaxe založená na výrazech, uživatelem deklarované typy a struktury / tagované odbory, referenční model proměnných a referenčních parametrů, řezání řetězců, polí a matic a souběžnost.

ALGOL 68 navrhl Mezinárodní federace pro zpracování informací (IFIP) Pracovní skupina IFIP 2.1 o algoritmických jazycích a kalkulích. 20. prosince 1968 byl jazyk formálně přijat skupinou a poté schválen ke zveřejnění Valným shromážděním IFIP.

ALGOL 68 byl definován pomocí a formalismus, dvouúrovňový formální gramatika, vynalezl Adriaan van Wijngaarden. Van Wijngaarden gramatiky použijte a bezkontextová gramatika generovat nekonečný soubor inscenací, které rozpoznají konkrétní program ALGOL 68; zejména jsou schopni vyjádřit druh požadavků, které mají v mnoha jiných programovacích jazycích technické normy jsou označeny sémantika, a musí být vyjádřeny v próze přirozeného jazyka náchylného k nejednoznačnosti a poté implementovány v kompilátorech jako ad hoc kód připojený k analyzátoru formálního jazyka.

Hlavní cíle a principy návrhu ALGOL 68:

1. Úplnost a jasnost popisu^[9]
2. Ortogonalita designu^[10]
3. Bezpečnostní^[11]
4. Účinnost:^[12]
   • Kontrola statického režimu
   • Analýza nezávislá na režimu
   • Nezávislé kompilace
   • Optimalizace smyčky
   • Zastoupení - minimální a větší znakové sady

ALGOL 68 byl kritizován, nejvýrazněji některými členy jeho návrhové komise, jako je C. A. R. Hoare a Edsger Dijkstra, za upuštění od jednoduchosti ALGOL 60, stát se prostředkem pro složité nebo příliš obecné myšlenky a dělat málo pro to, aby překladač spisovatelův úkol jednodušší, na rozdíl od záměrně jednoduchých současníků (a konkurentů) jako např C, S-algol a Pascal.

V roce 1970 ALGOL 68-R se stal prvním fungujícím překladačem pro ALGOL 68.

V revizi z roku 1973 byly některé funkce - jako např postupovat, gommas^[13] a formální hranice - byly vynechány.^[14] Srov. Jazyk neočekávané zprávy.^r0

Ačkoli evropské obranné agentury (v Británii Královské signály a založení radaru (RSRE)) podporoval využití ALGOL 68 pro jeho očekávané bezpečnostní výhody, americká strana aliance NATO se rozhodla vyvinout jiný projekt, jazyk Ada, čímž je jeho použití povinné pro smlouvy o obraně USA.

ALGOL 68 měl také značný vliv v EU Sovětský svaz, podrobnosti o kterém najdete v Andrey Ershov příspěvek z roku 2014: „ALGOL 68 a jeho dopad na programování SSSR a Ruska“,^[15] a „Алгол 68 и его влияние на программирование в СССР и России“.^[16]

Steve Bourne, který byl v revizním výboru ALGOL 68, vzal některé z jeho nápadů na své Bourneova skořápka (a tedy potomkovi Unix skořápky jako Bash ) a do C (a tedy potomkům, jako je C ++ ).

Kompletní historii projektu najdete v C. H. Lindsey je Historie ALGOL 68.^[17][18]

Úplné zpracování jazyka naleznete v části „Programování ALGOL 68 Made Easy“^[19] Dr. Sian Mountbatten nebo „Learning ALGOL 68 Genie“^[20] autor Marcel van der Veer, který obsahuje revidovanou zprávu.

Dějiny

Počátky

ALGOL 68, jak název napovídá, navazuje na ALGOL jazyk, který byl poprvé formován v roce 1960. Téhož roku Mezinárodní federace pro zpracování informací (IFIP) vytvořila a zahájila pracovní skupinu pro ALGOL neboli WG2.1. Tato skupina vydala aktualizovanou specifikaci ALGOL 60 v Římě v dubnu 1962. Na následné schůzce v březnu 1964 bylo dohodnuto, že skupina by měla začít pracovat na dvou následných normách, ALGOL X což by bylo předefinování jazyka s některými dodatky, a ALGOL Y, který by měl schopnost upravovat své vlastní programy ve stylu jazyka LISP.^[21]

Proces definice

V roce se konalo první zasedání skupiny ALGOL X. Univerzita Princeton v květnu 1965. Zpráva ze zasedání zaznamenala dvě široce podporovaná témata, představení silné psaní a zájem o Euler pojmy „stromů“ nebo „seznamů“ pro zpracování sbírek.^[22]

Na druhém říjnovém zasedání ve Francii byly předloženy tři formální návrhy, Niklaus Wirth je ALGOL W spolu s komentáři o strukturách záznamů podle AUTO. (Tony) Hoare, podobný jazyk od Gerharda Seegmüllera a příspěvek od Adriaan van Wijngaarden k "Ortogonálnímu designu a popisu formálního jazyka". Ta druhá, napsaná téměř nerozluštitelnou „W-gramatikou“, se ukázala jako rozhodující posun ve vývoji jazyka. Setkání skončilo dohodou, že van Wijngaarden přepíše Wirth / Hoare podání pomocí své W-gramatiky.^[22]

Tento zdánlivě jednoduchý úkol se nakonec ukázal jako obtížnější, než se očekávalo, a následná schůzka se musela odložit o šest měsíců. Když se sešel v dubnu 1966 v Kootwijk, van Wijngaardenův návrh zůstal neúplný a Wirth a Hoare představili verzi s tradičnějšími popisy. Obecně bylo dohodnuto, že jejich práce byla „správným jazykem ve špatném formalismu“.^[23] Když byly tyto přístupy prozkoumány, ukázalo se, že existuje rozdíl ve způsobu, jakým byly popsány parametry, které by měly účinky na reálný svět, a zatímco Wirth a Hoare protestovali, že další zpoždění mohou být nekonečná, výbor se rozhodl počkat na verzi van Wijngaardena. Wirth poté implementoval jejich současnou definici jako ALGOL W.^[24]

Na další schůzce v Varšava v říjnu 1966,^[25] došlo k počáteční zprávě podvýboru I / O, který se sešel na Národní laboratoř v Oak Ridge a University of Illinois ale ještě nedosáhla velkého pokroku. Oba návrhy z předchozí schůze byly znovu prozkoumány a tentokrát se objevila nová debata o použití ukazatele; ALGOL W je používal pouze k odkazování na záznamy, zatímco verze van Wijngaardena mohla ukazovat na jakýkoli objekt. Chcete-li přidat zmatek, John McCarthy představil nový návrh pro přetížení operátora a schopnost spojovat dohromady a nebo konstrukty a Klaus Samelson chtěl dovolit anonymní funkce. Ve výsledném zmatku došlo k nějaké diskusi o opuštění celého úsilí.^[24] Zmatek pokračoval tím, co mělo být schůzkou ALGOL Y. Zandvoort v květnu 1967.^[22]

Vydání

Návrh zprávy byl konečně zveřejněn v únoru 1968. Setkal se s ním „šok, hrůza a nesouhlas“,^[22] většinou kvůli stovkám stránek nečitelné gramatiky a liché terminologie. Charles H. Lindsey pokusil se přijít na to, jaký „jazyk se v něm skrýval“,^[26] proces, který si vyžadoval úsilí šest týdnů člověka. Výsledný papír „ALGOL 68 s méně slzami“ byl široce šířen. Na širší schůzce o zpracování informací v Curych v květnu 1968 si účastníci stěžovali, že jim byl jazyk vnucován a že IFIP je „skutečným darebákem této nerozumné situace“, protože schůzky byly většinou uzavřeny a neexistoval žádný formální mechanismus zpětné vazby. Wirth a Peter Naur v té době formálně rezignovali na své autorské pozice ve WG2.1.^[26]

Příští schůze WG2.1 se konala v roce Tirrenia v červnu 1968. Mělo se jednat o vydání překladačů a dalších otázkách, ale místo toho se to změnilo na diskusi o jazyce. van Wijngaarden reagoval slovy (nebo výhružkou), že vydá pouze jednu další verzi zprávy. V tomto okamžiku Naur, Hoare a Wirth opustili úsilí a několik dalších se vyhrožovalo, že tak učiní.^[27] Následovalo několik dalších schůzek, North Berwick v srpnu 1968 v Mnichově v prosinci, který vydal oficiální zprávu v lednu 1969, ale vyústil také ve vytvoření sporné zprávy o menšině. Nakonec v Banff, Alberta v září 1969 byl projekt obecně považován za dokončený a diskuse se primárně týkala errata a výrazně rozšířeného Úvodu ke zprávě.^[28]

Úsilí trvalo pět let a spálilo mnoho z největších jmen v počítačová věda a při několika příležitostech uvázly na mrtvém bodě kvůli problémům jak v definici, tak ve skupině jako celku. Hoare téměř okamžitě vydal „Kritiku ALGOL 68“,^[29] který byl široce odkazován v mnoha pracích. Wirth pokračoval v dalším vývoji konceptu ALGOL W a v roce 1970 jej vydal jako Pascal.

Implementace

ALGOL 68-R

První implementaci standardu, založenou na návrhu zprávy z konce roku 1968, zavedlo Royal Radar Establishment ve Velké Británii jako ALGOL 68-R v červenci 1970. Jednalo se však o podmnožinu plného jazyka a Barry Mailloux, poslední redaktor Zprávy, žertoval, že „Je to otázka morálky. Máme Bibli a hřešíte!“^[30] Tato verze se přesto stala velmi populární na internetu ICL strojů a stal se široce používaným jazykem ve vojenském kódování, zejména ve Velké Británii.^[31]

Mezi změnami v 68-R byl požadavek na deklaraci všech proměnných před jejich prvním použitím. To mělo významnou výhodu v tom, že to umožnilo kompilátoru být jedním průchodem, jako prostor pro proměnné v aktivační záznam byl vyčleněn před tím, než byl použit. Tato změna však měla také vedlejší účinek vyžadující procs být deklarováno dvakrát, jednou jako deklarace typů a poté znovu jako tělo kódu. Další změnou bylo vyloučit předpokládané prázdnota mode, výraz, který nevrací žádnou hodnotu (pojmenovaný a prohlášení v jiných jazycích) a náročné slovo prázdnota doplní se tam, kde by se to předpokládalo. Dále 68-R vyloučil explicitní paralelní zpracování příkazy založené na odst.^[30]

Ostatní

První úplná implementace jazyka byla zavedena v roce 1974 společností CDC Nizozemsko pro Kontrolní data řada sálových počítačů. Toto vidělo omezené použití, většinou výuka v Německu a Nizozemsku.^[31]

Verze podobná 68-R byla představena od Univerzita Carnegie Mellon v roce 1976 jako 68S, a byl opět jednoprůchodový překladač založený na různých zjednodušeních originálu a určený pro použití na menších strojích, jako je DEC PDP-11. Také to bylo používáno hlavně pro výukové účely.^[31]

Verze pro IBM mainframes byly k dispozici až v roce 1978, kdy byl jeden propuštěn z Cambridge University. To bylo „téměř kompletní“. Lindsey vydala verzi pro malé stroje včetně IBM PC v roce 1984.^[31]

Jsou známy dvě implementace open source Algol 68:^[32]

• a68g, GPLv3, napsal Marcel van der Veer;
• algol68toc, an open-source software přístav ALGOL 68RS.

Časová osa

• „Kratší historie Algolu 68“
• ALGOL 68 - 3. generace ALGOL

Zprávy ALGOL 68 v algoritmickém jazyce

• Březen 1968: Návrh zprávy o algoritmickém jazyce ALGOL 68^[38] - Upravil: A. van Wijngaarden, B. J. Mailloux, J. E. L. Peck a C. H. A. Koster.

„Van Wijngaarden kdysi charakterizoval čtyři autory, trochu jazykem, jako: Koster: transportér „Peck: syntaxer, Mailloux: implementátor, Van Wijngaarden: stranický ideolog.“ - Koster.

• Říjen 1968: Předposlední návrh zprávy o algoritmickém jazyce ALGOL 68 - kapitoly 1-9^[39] Kapitoly 10-12^[40] - Redakce: A. van Wijngaarden, B.J. Mailloux, J. E. L. Peck a C. H. A. Koster.
• Prosinec 1968: Zpráva o algoritmickém jazyce ALGOL 68 - Offprint od Numerische Mathematik, 14, 79-218 (1969); Springer-Verlag.^[41] - Redakce: A. van Wijngaarden, B. J. Mailloux, J. E. L. Peck a C. H. A. Koster.
  • Členové WG 2.1 aktivní v původním designu ALGOL 68:^[18] Friedrich L. Bauer • Hans Bekic • Edsger Dijkstra ※ • Fraser Duncan ※ • Jan Garwick ※ • Gerhard Goos • Tony Hoare ※ • Peter Zilahy Ingerman • Kees Koster • Peter Landin • Charles Lindsey • Barry Mailloux • John McCarthy • Jack Merner • Peter Naur ‡ • Manfred Paul • John Peck • Willem van der Poel • Brian Randell ※ • Doug Ross • Klaus Samelson • Gerhard Seegmüller ※ • Michel Sintzoff • Wlad Turski A • Aad van Wijngaarden • Niklaus Wirth ‡ • Mike Woodger ※ • Nobuo Yoneda; Klíč: ※ Signatáři zprávy o menšinách. ‡ Odstoupil po [MR 93].
• Září 1973: Revidovaná zpráva o algoritmickém jazyce Algol 68 - Springer-Verlag 1976^[42] - Redakce: A. van Wijngaarden, B. J. Mailloux, J. E. L. Peck, C.H.A. Koster, M. Sintzoff, C. H. Lindsey, L. G. L. T. Meertens a R. G. Fisker.

Časová osa standardizace

1968: Dne 20. prosince 1968 byla pracovní skupinou přijata „závěrečná zpráva“ (MR 101), poté následně schválena Valným shromážděním UNESCO je IFIP ke zveřejnění. Překlady normy byly vytvořeny pro ruština, Němec, francouzština a bulharský a poté později japonský a čínština.^[43] Standard byl také k dispozici v Braillovo písmo.

1984: TC97 považován za ALGOL 68 pro standardizaci jako „Nová pracovní položka“ TC97 / N1642 [2][3]^{[trvalý mrtvý odkaz ]}. Západní Německo, Belgie, Nizozemsko, SSSR a Československo ochotné podílet se na přípravě normy, ale SSSR a Československo „nebyli správnými druhy členů správných výborů ISO“[4] a standardizace ISO Algol 68 se zastavila.[5]

1988: Následně se ALGOL 68 stal jedním z GOST standardy v Rusku.

• GOST 27974-88 Programovací jazyk ALGOL 68 - Язык программирования АЛГОЛ 68^[44]
• GOST 27975-88 Programovací jazyk ALGOL 68 rozšířen - Язык программирования АЛГОЛ 68 расширенный^[45]

Pozoruhodné jazykové prvky

Tučné symboly a vyhrazená slova

Standardní jazyk obsahuje asi šedesát vyhrazených slov, obvykle tučně tištěných, a některá s ekvivalenty „krátkých symbolů“:

režimu, op, prio, proc,flex, halda, loc, dlouho, ref, krátký,bity, bool, bajtů, char, kompl, int, nemovitý, sema, tětiva, prázdnota,kanál, soubor, formát, struktur, svaz,na "@", buďr0, je ":=:", není  nenír0 ":/=:" ":≠:", z "→"r0, skutečný, Nepravdivé, prázdný, nula "○", přeskočit "~",co "¢", komentář "¢", pr, pragmat,případ ~ v ~ ouse ~ v ~ ven ~ esac "( ~ | ~ |: ~ | ~ | ~ )",pro ~ z ~ na ~ podle ~ zatímco ~ dělat ~ od,-li ~ pak ~ elif ~ pak ~ jiný ~ fi "( ~ | ~ |: ~ | ~ | ~ )",odst začít ~ konec "( ~ )", jít do, jít do, výstup "."r0.

Jednotky: Výrazy

Základním jazykovým konstruktem je jednotka. Jednotkou může být a vzorec, an přiložená klauzule, a rutinní text nebo jeden z několika technicky potřebných konstruktů (přiřazení, skok, přeskočení, nihil). Odborný termín přiložená klauzule sjednocuje některé ze své podstaty bracketingové konstrukce známé jako blok, dělat prohlášení, příkaz switch v jiných současných jazycích. Pokud se používají klíčová slova, obvykle se pro ukončení přílohy používá obrácená posloupnost úvodních klíčových slov. ( -li ~ pak ~ jiný ~ fi, případ ~ v ~ ven ~ esac, pro ~ zatímco ~ dělat ~ od ). Tento Hlídané velení syntaxe byla znovu použita uživatelem Stephen Bourne ve společném Unix Bourneova skořápka. Výraz může také poskytnout a vícenásobná hodnota, který je sestaven z jiných hodnot pomocí a vedlejší doložka. Tato konstrukce vypadá jen jako balíček parametrů volání procedury.

režim: Deklarace

Základní typy dat (volala režimus v jazyce Algol 68) jsou nemovitý, int, kompl (komplexní číslo ), bool, char, bity a bajtů. Například:

int n = 2;co n je fixováno jako konstanta 2. coint m: = 3;co m je nově vytvořený místní proměnná jehož hodnota je původně nastavena na 3. coco    Toto je zkratka pro ref int m = loc int: = 3; conemovitý avogadro = 6,0221415⏨23; co Avogadro číslo codlouho dlouho skutečné long long pi = 3.14159 26535 89793 23846 26433 83279 50288 41971 69399 37510;kompl druhá odmocnina mínus jedna = 0 ⊥ 1;

Nicméně prohlášení nemovitý X; je jen syntaktický cukr pro ref nemovitý x = loc nemovitý;. To znamená X je opravdu konstantní identifikátor pro odkaz na nově vygenerovaný místní nemovitý proměnná.

Kromě toho místo definování obou plovák a dvojnásobeknebo int a dlouho a krátkýatd., poskytuje ALGOL 68 modifikátory, takže v současné době běžné dvojnásobek bude psáno jako dlouho nemovitý nebo dlouho dlouho nemovitý místo toho například. The konstanty předehry max. skutečný a min. dlouhá int jsou poskytovány za účelem přizpůsobení programů různým implementacím.

Je třeba deklarovat všechny proměnné, deklarace se nemusí objevit před prvním použitím.

primitivní deklarant: int, nemovitý, kompl, komplex^G, bool, char, tětiva, bity, bajtů, formát, soubor, trubka^G, kanál, sema

• bity - "zabalený vektor" z bool.
• bajtů - "zabalený vektor" z char.
• tětiva - a flexible pole char.
• sema - a semaphore které lze inicializovat pomocí operátor úroveň.

Složité typy lze vytvořit z jednodušších pomocí různých konstruktorů typů:

• ref režimu - odkaz na hodnotu typu režimu, podobný & v C / C ++ a ref v Pascalu
• struktur - používá se k stavbě struktur, jako struktur v C / C ++ a záznam v Pascalu
• svaz - slouží k vytváření unií, jako v C / C ++ a Pascal
• proc - slouží k určení postupů, jako jsou funkce v C / C ++ a postupy / funkce v Pascalu

Některé příklady viz Porovnání ALGOL 68 a C ++.

Mezi další symboly prohlášení patří: flex, halda, loc, ref, dlouho, krátký, událost^S

• flex - deklarovat pole jako flexibilní, tj. Může podle potřeby růst do délky.
• halda - přidělit proměnné nějaký volný prostor z globální hromady.
• loc - přidělit proměnné nějaké volné místo v místním zásobníku.
• dlouho - prohlásit int, nemovitý nebo kompl být z dlouhoer velikost.
• krátký - prohlásit int, nemovitý nebo kompl být z krátkýer velikost.

Název režimu (typu) lze deklarovat pomocí a režimu prohlášení, které je podobné typedef v C / C ++ a typ v Pascalu:

 int max = 99; režimu newmode = [0: 9] [0: max]struktur (     dlouho nemovitý a, b, c, krátký int i, j, k, ref nemovitý r);

Je to podobné jako v následujícím kódu C:

  konst int max=99;  typedef struktur {      dvojnásobek A, b, C; krátký i, j, k; plovák *r;  } nový režim[9+1][max+1];

U ALGOL 68 pouze nový režim indikace režimu se objeví nalevo od symbolu rovnosti a především je konstrukce provedena a lze ji číst zleva doprava bez ohledu na priority. Také dolní mez pole Algol 68 je ve výchozím nastavení jedno, ale může to být celé číslo od -max. int na max. int.

Deklarace režimů umožňují rekurzivní typy: definované přímo nebo nepřímo samy o sobě. To podléhá určitým omezením - například tato prohlášení jsou nezákonná:

 režimu A = ref A režimu A = struktur (A a, B b) režimu A = proc (A a) A

zatímco tyto jsou platné:

 režimu A = struktur (ref A a, B b) režimu A = proc (ref A a) ref A

Donucování: casting

The nátlak vytvořit coercee z coercendu podle tří kritérií: apriorní režim coercend před použitím jakéhokoli nátlaku, a posteriori režim coercee požadovaný po těchto donuceních, a syntaktická poloha nebo „druh“ coercee. Donucování může být kaskádové.

Šest možných donucení se jmenuje odsouzení, dereferencování, sjednocující, rozšiřování, veslování, a močení. Každý nátlak, kromě sjednocující, předepíše odpovídající dynamický účinek na přidružené hodnoty. Mnoho primitivních akcí lze proto implicitně naprogramovat nátlakem.

Síla kontextu - povolené nátlaky:

• měkký - deproceduring
• slabý - dereferenční nebo deprocedurní, přinášející jméno
• pokorný - dereferenční nebo deproceduring
• pevný - pokorný, následovaný spojením
• silný - pevný, následovaný rozšířením, veslováním nebo vyprázdněním

Donucovací hierarchie s příklady

ALGOL 68 má hierarchii kontextů, které určují druh nátlaku dostupného v určitém bodě programu. Tyto kontexty jsou:

INT k DLOUHÉMU INTINTU k SKUTEČNÉMU KOMPLETU k [] BOOLBYTŮM k STRINGU

INT až [1] INTREÁL až [1] SKUTEČNÉ

REF REF BOOL to BOOLREF REF REF INT na INT

REF BOOL to REF BOOLREF REF INT do REF INTREF REF REF REAL do REF REALREF REF REF REF STRUKT do REF STRUKT

Další podrobnosti o primárkách, sekundářích, terciářích a kvartérech najdete na Priorita operátora.

pr & co: Pragmaty a komentáře

Pragmati jsou směrnice v programu obvykle naráží na kompilátor; v novějších jazycích se tomu říká „pragmas“ (ne „t“). např.

pragmat halda = 32 pragmatpr halda = 32 pr

Komentáře lze vkládat různými způsoby:

¢ Původní způsob přidání 2 centů v hodnotě do programu ¢komentář "tučný" komentář komentářco Styl komentuji co# Komentář stylu ii # £ Toto je komentář hash / libra pro britskou klávesnici £

Za normálních okolností nelze komentáře vnořit do ALGOL 68. Toto omezení lze obejít použitím různých oddělovačů komentářů (např. Použít hash pouze pro dočasné odstranění kódu).

Výrazy a složené příkazy

ALGOL 68 je výrazově orientovaný programovací jazyk, hodnota vrácená znakem úkol prohlášení je odkaz na cíl. Platný kód ALGOL 68 je tedy následující:

 nemovitý poloviční pí, jedna pí; jedna pí: = 2 * (poloviční pí: = 2 * obloukové opálení (1))

Tato představa je přítomna v C a Perl, mezi ostatními. Všimněte si, že stejně jako v dřívějších jazycích, jako je Algol 60 a FORTRAN, v identifikátorech jsou povoleny mezery, takže napůl pi je singl identifikátor (čímž se zabrání podtržítka proti velbloudí pouzdro proti všechny malá písmena problémy).

Jako další příklad lze vyjádřit matematickou myšlenku a součet z f (i) od i = 1 do n, následující ALGOL 68 celočíselný výraz stačí:

 (int součet: = 0; pro i na n dělat součet +: = f (i) od; součet)

Všimněte si, že jako celočíselný výraz lze použít dřívější blok kódu v jakýkoli kontext, kde lze použít celočíselnou hodnotu. Blok kódu vrací hodnotu posledního výrazu, který vyhodnotil; tato myšlenka je přítomna v Lisp, mimo jiné jazyky.

Složené výroky jsou ukončeny rozlišovacími závorkami:

• -li klauzule volby:

 -li stav pak prohlášení [ jiný prohlášení] fi "krátký" formulář: (podmínka | prohlášení | prohlášení)

 -li podmínka1 pak prohlášení elif podmínka2 pak prohlášení [ jiný prohlášení] fi "krátký" formulář: (podmínka1 | příkazy |: podmínka2 | příkazy | příkazy)

Tento režim se nejen vyhne houpající se jinde problém, ale také se vyhýbá nutnosti používat začít a konec ve vloženém prohlášení sekvence.

• případ klauzule volby:

 případ přepínač v prohlášení, prohlášení, ... [ ven prohlášení] esac "krátký" formulář: (přepnout | výpisy, výpisy, ... | výpisy)

 případ switch1 v prohlášení, prohlášení, ... ouse switch2 v prohlášení, prohlášení, ... [ ven prohlášení] esac "krátká" forma případ výpis: (switch1 | příkazy, výpisy, ... |: switch2 | výpisy, výpisy, ... | výpisy)

Příklad klauzule volby s Stručný symboly:

proc dny v měsíci = (int rok, měsíc)int: (měsíc | 31, (rok ÷ × 4 = 0 ∧ rok ÷ × 100 ≠ 0 ∨ rok ÷ × 400 = 0 | 29 | 28), 31, 30, 31, 30, 31, 31, 30, 31, 30 31);

Příklad klauzule volby s tučně symboly:

proc dny v měsíci = (int rok, měsíc)int:  případ Měsíc v    31,    -li rok mod 4 ekv 0 a rok mod 100 ne 0  nebo  rok mod 400 ekv 0 pak 29 jiný 28 fi,    31, 30, 31, 30, 31, 31, 30, 31, 30, 31  esac;

Příklad klauzule volby míchání tučně a Stručný symboly:

proc dny v měsíci = (int rok, měsíc)int:  případ Měsíc v¢ led ¢ 31, ¢ únor ¢ (rok mod 4 = 0 a rok mod 100 ≠ 0  nebo  rok mod 400 = 0 | 29 | 28), ¢ Mar ¢ 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ¢ do prosince ¢ esac;

Algol68 povolil, aby byl přepínač libovolného typu int nebo (jedinečně) svaz. Ten umožňuje vymáhání silné psaní na svaz proměnné. srov. svaz například níže.

• dělat klauzule smyčky:

 [ pro index] [ z za prvé ] [ podle přírůstek] [ na poslední] [ zatímco stav] dělat prohlášení od Minimální forma „smyčkové klauzule“ je tedy: dělat prohlášení od

To bylo zváženo the „univerzální“ smyčka, úplná syntaxe je:

pro i z 1 podle -22 na -333 zatímco i × i ≠ 4444 dělat ~ od

Konstrukt má několik neobvyklých aspektů:

• pouze dělat ~ od část byla povinná, v takovém případě bude smyčka iterovat neurčitě.
• tedy doložka na 100 dělat ~ od, bude iterovat pouze 100krát.
• the zatímco "syntaktický prvek" umožnil programátorovi vymanit se z a pro smyčka brzy. např.

int součet sq: = 0;pro izatímco  print (("Zatím:", ​​i, nový řádek)); součet sq ≠ 70 ↑ 2dělat  součet sq +: = i ↑ 2od

Následné "rozšíření" standardního Algol68 umožnilo na syntaktický prvek, který má být nahrazen až do a dolů k dosažení malé optimalizace. Stejní překladači také zahrnovali:

• dokud^(C) - pro pozdní ukončení smyčky.
• pro každého^(S) - pro práci na polích ve Windows paralelní.

Další příklady najdete v příkladech kódu níže.

struct, union & [:]: Struktury, odbory a pole

ALGOL 68 podporuje pole s libovolným počtem rozměrů a umožňuje krájení celých nebo částečných řádků nebo sloupců.

 režimu vektor = [1:3]    nemovitý;   # vektor režimu prohlášení (typedef) # režimu matice = [1:3,1:3]nemovitý;   # matice režimu prohlášení (typedef) # vektor vl: = (1,2,3); # proměnná pole zpočátku (1,2,3) # []nemovitý v2 = (4,5,6); # konstantní pole, typ ekvivalentní vektor, hranice jsou naznačeny # op + = (vektor a, b) vektor:    # binární opdefinice erátora #   (vektor ven; pro i z ⌊A na ⌈A dělat out [i]: = a [i] + b [i] od; ven); matice m: = (v1, v2, v1 + v2); tisk ((m [, 2:])); # plátek 2. a 3. sloupce #

Matice mohou být krájeny oběma směry, např .:

 ref vektor řádek = m [2,]; # definovat a ref (ukazatel) na 2. řádek # ref vektor col = m [, 2]; # definovat a ref (ukazatel) na 2. sloupec #

ALGOL 68 podporuje více struktur pole (struktur) a sjednocené režimy. Referenční proměnné mohou ukazovat na libovolné režimu včetně řezů pole a strukturních polí.

Příklad toho všeho je tradiční deklarace propojeného seznamu:

 režimu uzel = svaz (nemovitý, int, kompl, tětiva),      seznam = struktur (uzel val, ref seznam další);

Příklad použití pro svaz případ z uzel:

 uzel n: = "1234"; nemovitý r; int i; kompl C; tětiva s případ r, i, c, s :: = n v   print (("real:", r)), print (("int:", i)), print (("compl:", c)), print (("string:", s)) ven print (("?:", n)) esac

 uzel n: = "1234"; případ n v   (nemovitý r): print (("real:", r)), (int i): print (("int:", i)), (kompl c): print (("compl:", c)), (tětiva s): print (("string:", s)) ven         print (("?:", n)) esac

proc: Procedury

Postup (proc) Deklarace vyžadují specifikace typu pro parametry i pro výsledek (prázdnota pokud žádný):

 proc max real = (nemovitý a, b) nemovitý:    -li a> b pak A jiný b fi;

nebo pomocí „stručného“ formuláře podmíněného prohlášení:

 proc max real = (nemovitý a, b) nemovitý: (a> b | a | b);

Návratová hodnota a proc je hodnota posledního výrazu vyhodnoceného v proceduře. Odkazy na postupy (ref proc) jsou také povoleny. Call-by-reference parametry jsou poskytovány specifikací odkazů (např ref real) ve formálním seznamu argumentů. Následující příklad definuje proceduru, která použije funkci (zadanou jako parametr) na každý prvek pole:

 proc použít = (ref [] nemovitý A, proc (nemovitý) nemovitý F): pro i z lwb A na upb A dělat a [i]: = f (a [i]) od

Tato jednoduchost kódu byla v předchůdci ALGOL 68 nedosažitelná ALGOL 60.

op: Operátoři

Programátor může definovat nový operátory a oba tyto a předdefinované mohou být přetížený a jejich priority může kodér změnit. Následující příklad definuje operátor max s dyadickou i monadickou verzí (skenování napříč prvky pole).

 prio max = 9;   op max = (int a, b) int: (a> b | a | b); op max = (nemovitý a, b) nemovitý: (a> b | a | b); op max = (kompl a, b) kompl: ( břišní svaly a> břišní svaly b | a | b); op max = ([]nemovitý A) nemovitý:    (nemovitý out: = a [lwb A]; pro i z lwb a + 1 na upb A dělat (a [i]> out | out: = a [i]) od; ven)

Pole, procedura, dereference a donucovací operace

Technicky to nejsou operátoři, spíše jsou považováni za “jednotky spojené se jmény "

Monadic operátoři

Dyadičtí operátoři s přidruženými prioritami

Poznámka: Terciární organizace zahrnují jména nula a ○.

Přiřazení a vztahy identity atd

Technicky to nejsou operátoři, spíše jsou považováni za “jednotky spojené se jmény "

Poznámka: Čtvrtletí zahrnují jména přeskočit a ~.

": =:" (alternativně)je") testuje, zda jsou dva ukazatele stejné;": / =: "(alternativně)není") testuje, zda jsou nerovné.

Proč: =: a: / =: jsou potřeba: Zvažte pokus o porovnání dvou hodnot ukazatelů, například následujících proměnných, deklarovaných jako ukazatele na celé číslo:

ref int ip, jp

Nyní zvažte, jak se rozhodnout, zda tito dva směřují na stejné místo, nebo zda jeden z nich ukazuje na nula. Následující výraz

ip = jp

bude dereference obou ukazatelů dolů na hodnoty typu int, a porovnat je, protože operátor "=" je definován pro int, ale ne ref int. to je není legální definovat "=" pro operandy typu ref int a int zároveň, protože pak se volání stanou dvojznačnými, kvůli implicitnímu nátlaku, který lze použít: měly by být operandy ponechány jako ref int a ta verze operátora volala? Nebo by měli být dále odkázáni na int a ta verze místo toho použita? Následující výraz proto nikdy nemůže být legální:

ip = nula

Proto je potřeba samostatných konstruktů nepodléhajících normálním donucovacím pravidlům pro operandy operátorům. Ale je tu gotcha. Následující výrazy:

ip: =: jp

ip: =: nula

i když je legální, pravděpodobně neudělá to, co by se dalo očekávat. Vždy se vrátí Nepravdivé, protože porovnávají skutečné adresy proměnných ip a jp, spíše než to, na co poukazují. Abychom dosáhli správného efektu, museli bychom psát

ip: =: ref int(jp)

ip: =: ref int(nula)

Přihláška patentu: Dne 14. května 2003 softwarový patent přihláška č. 20040230959^[46] byl podán pro NENÍ provozovatel zaměstnanci společnosti Microsoft. Tento patent byl udělen dne 18. listopadu 2004.

Speciální znaky

IBM 2741 klávesnice se symboly APL

Většina „speciálních“ znaků Algolu (⊂, ≡, ␣, ×, ÷, ≤, ≥, ≠, ¬, ⊃, ≡, ∨, ∧, →, ↓, ↑, ⌊, ⌈, ⎩, ⎧, ⊥, ⏨, ¢, ○ a □) najdete na IBM 2741 klávesnice s APL vložena tisková hlava „golfový míček“; tyto byly k dispozici v polovině 60. let, když se připravoval ALGOL 68. Tyto postavy jsou také součástí Unicode standardní a většina z nich je k dispozici v několika populárních písma.

transput: Vstup a výstup

Transput je termín používaný k označení vstupních a výstupních zařízení ALGOL 68. Zahrnuje předdefinované postupy pro neformátovaný, formátovaný a binární přenos. Se soubory a dalšími transportními zařízeními se zachází konzistentně a nezávisle na stroji. Následující příklad vytiskne nějaký neformátovaný výstup do standardní výstup přístroj:

  print ((newpage, "Title", newline, "Value of i is", i, "and x [i] is", x [i], newline))

Všimněte si předdefinovaných postupů nová stránka a nový řádek předán jako argumenty.

Knihy, kanály a soubory

The transput je považován za z knihy, kanály a soubory:

• Knihy jsou tvořeny stránkami, řádky a znaky a mohou být zálohovány soubory.
  • Konkrétní knihu lze vyhledat podle jména s voláním na zápas.
• kanálodpovídají fyzickým zařízením. např. děrovače karet a tiskárny.
  • Rozlišují se tři standardní kanály: stát uvnitř kanál, vyčnívat kanál, odstoupit kanál.
• A soubor je prostředek komunikace mezi programem a knihou, která byla otevřena prostřednictvím nějakého kanálu.
  • The nálada souboru lze číst, zapisovat, char, bin a otevírat.
  • postupy transput zahrnují: vytvořit, vytvořit, otevřít, přidružit, zamknout, zavřít, škrábat.
  • dotaz na pozici: číslo znaku, číslo řádku, číslo stránky.
  • rozvržení obsahuje:
    • prostor, backspace, nový řádek, nová stránka.
    • získejte dobrou linii, získejte dobrou stránku, získejte dobrou knihu, a proc sada = (ref soubor F, int stránka, řádek, znak)prázdnota:
  • Soubor má rutiny událostí. např. na konci logického souboru, na konci fyzického souboru, na konci stránky, na konci řádku, na konci formátu, na chybě hodnoty, na chybě char.

formátovaný transput

„Formátovaný transput“ v transputátu ALGOL 68 má svou vlastní syntaxi a vzory (funkce) s formáts vložené mezi dva znaky $.^[47]

Příklady:

 printf (($ 2l "Součet je:" x, g (0) $, m + n)); ¢ tiskne stejně jako: ¢ tisk ((nový řádek, nový řádek, „Součet je:“, mezera, celý (m + n, 0))

par: Paralelní zpracování

ALGOL 68 podporuje programování paralelního zpracování. Pomocí klíčového slova odst, a vedlejší doložka je převeden na a paralelní klauzule, kde je synchronizace akcí řízena pomocí semafory. V A68G jsou paralelní akce mapovány na vlákna, pokud jsou k dispozici na hostování operační systém. V A68S bylo implementováno jiné paradigma paralelního zpracování (viz níže).

int počáteční šířka chodidla = 5;režimu chodidlo = struktur(   tětiva název, sema šířka, bity prst ¢ zabalený vektor BOOL ¢);chodidlo levá noha: = chodidlo("Vlevo, odjet", úroveň počáteční šířka chodidla, 2r11111), pravá noha: = chodidlo("Že jo", úroveň počáteční šířka chodidla, 2r11111); ¢ 10 round clip in a 1968 Colt Python .357 Magnum ¢sema rounds = úroveň 10; ¢ the Magnum needs more barrels to take full advantage of parallelism ¢sema acquire target = úroveň 1; prio ∧:= = 1;op ∧:= = (ref bity lhs, bity rhs)ref bity: lhs := lhs ∧ rhs; proc shoot = (ref chodidlo foot)prázdnota: (  ↓acquire target;  ↓rounds;  print("BANG! ");  ↓width → foot;  toe → foot ∧:= ¬(zásobník 1 shl úroveň width → foot);  printf(($g": Ouch!! – "5(g)l$, name → foot, []bool(toe → foot)[bits width – initial foot width + 1:]));  ↑acquire target); ¢ do shooting in parallel to cater for someone hoping to stand on just one foot ¢odst (  pro prst na initial foot width dělat    shoot (left foot)  od, ¢ <= a comma is required ¢  pro prst na initial foot width dělat    shoot(right foot)  od)

Příklady použití

Ukázka kódu

This sample program implements the Síto Eratosthenes to find all the prvočísla that are less than 100. nil is the ALGOL 68 analogue of the nulový ukazatel in other languages. Zápis X z y accesses a member X a struktur y.

začít # Algol-68 prime number sieve, functional style #    proc error = (tětiva s) prázdnota:     (print(( newline, " error: ", s, newline)); jít do stop);  proc one to = (int n) seznam:     (proc f = (int m,n) seznam: (m>n | nil | cons(m, f(m+1,n))); f(1,n)); režimu seznam = ref uzel;  režimu uzel = struktur (int h, seznam t);  proc cons = (int n, seznam l) seznam: halda uzel := (n,l);  proc hd   = (seznam l) int: ( l je nil | error("hd nil"); přeskočit | h z l );  proc tl   = (seznam l) seznam: ( l je nil | error("tl nil"); přeskočit | t z l );  proc show = (seznam l) prázdnota: ( l isnt nil | tisk((" ",whole(hd(l),0))); show(tl(l)));    proc filter = (proc (int) bool p, seznam l) seznam:     -li l je nil pak nil     elif p(hd(l)) pak cons(hd(l), filter(p,tl(l)))     jiný filter(p, tl(l))     fi;    proc sieve = (seznam l) seznam:     -li l je nil pak nil     jiný        proc not multiple = (int n) bool: n mod hd(l) ≠ 0;        cons(hd(l), sieve( filter( not multiple, tl(l) )))     fi;    proc primes = (int n) seznam: sieve( tl( one to(n) ));    show( primes(100) )konec

Operating systems written in ALGOL 68

• Počítač Cambridge CAP – All procedures constituting the operating system were written in ALGOL 68C, although several other closely associated protected procedures, such as a paginator, are written in BCPL.^[48]
• Eldon 3 – Developed at Leeds University pro ICL 1900 byl napsán v ALGOL 68-R.^[49]
• Flex stroj – The hardware was custom and microprogrammable, with an operating system, (modular) compiler, editor, garbage collector and filing system all written in ALGOL 68RS. The command shell Curt^[50] was designed to access typed data similar to Algol-68 modes.
• VME – S3 was the implementation language of the operační systém VME. S3 was based on ALGOL 68 but with data types and operators aligned to those offered by the Řada ICL 2900.

Note: The Soviet Era computers Эльбрус-1 (Elbrus-1) and Эльбрус-2 were created using high-level language Эль-76 (AL-76), rather than the traditional assembly. Эль-76 resembles Algol-68, The main difference is the dynamic binding types in Эль-76 supported at the hardware level. Эль-76 is used for application, job control, system programming.^[51]

Aplikace

Oba ALGOL 68C a ALGOL 68-R are written in ALGOL 68, effectively making ALGOL 68 an application of itself. Other applications include:

• ELLA – a hardware description language and support toolset. Vyvinutý společností Královské signály a založení radaru během 80. a 90. let.
• RAF Strike Command System – "... 400K of error-free ALGOL 68-RT code was produced with three man-years of work. ... “^[52]

Libraries and APIs

• Číselné knihovny NAG - a softwarová knihovna z numerická analýza rutiny. Supplied in ALGOL 68 during the 1980s.
• TORRIX – a programming system for operations on vectors and matrices over arbitrary fields and of variable size by S. G. van der Meulen and M. Veldhorst.^[53]

Program representation

A feature of ALGOL 68, inherited from the ALGOL tradition, is its different representations. Tady je representation language used to describe algorithms in printed work, a strict language (rigorously defined in the Report), and an official referenční jazyk intended to be used in compiler input. The examples contain tučně typeface words, this is the přísný Jazyk. ALGOL 68's reserved words are effectively in a different jmenný prostor from identifiers, and spaces are allowed in identifiers, so this next fragment is legal:

 int a real int = 3 ;

The programmer who writes executable code does not always have an option of tučně typeface or podtržení in the code as this may depend on hardware and cultural issues. Different methods to denote these identifiers have been devised. Tomu se říká a stropping režim. For example, all or some of the following may be available programming representations:

 int a real int = 3; # přísný language #'INT'A REAL INT = 3; # QUOTE stropping style #.INT A REAL INT = 3; # POINT stropping style # INT a real int = 3; # UPPER stropping style # int a_real_int = 3; # RES stropping style, there are 61 accepted reserved words #

All implementations must recognize at least POINT, UPPER and RES inside PRAGMAT sections. Of these, POINT and UPPER stropping are quite common, while RES stropping is a contradiction to the specification (as there are no reserved words). QUOTE (single apostrophe quoting) was the original recommendation, while matched apostrophe quoting, common in ALGOL 60, is not used much in ALGOL 68.^[54]

The following characters were recommended for portability, and termed "worthy characters" in the Report on the Standard Hardware Representation of Algol 68:

• ^ Worthy Characters: ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 "#$%'()*+,-./:;<=>@[ ]_|

This reflected a problem in the 1960s where some hardware didn't support lower-case, nor some other non-ASCII characters, indeed in the 1973 report it was written: "Four worthy characters — "|", "_", "[", and "]" — are often coded differently, even at installations which nominally use the same character set."

• Base characters: "Worthy characters" are a subset of "base characters".

Example of different program representations

¢ underline or   bold typeface ¢ režimu xint = int; xint sum sq:=0; pro i zatímco   sum sq≠70×70 dělat   sum sq+:=i↑2 od

'pr' quote 'pr''mode' 'xint' = 'int';'xint' sum sq:=0;'for' i 'while'  sum sq≠70×70'do'  sum sq+:=i↑2'od'

.PR UPPER .PRMODE XINT = INT;XINT sum sq:=0;FOR i WHILE  sum sq/=70*70DO  sum sq+:=i**2OD

.PR POINT .PR.MODE .XINT = .INT;.XINT SUM SQ:=0;.FOR I .WHILE  SUM SQ .NE 70*70.DO  SUM SQ .PLUSAB I .UP 2.OD

.PR RES .PRmode .xint = int;.xint sum sq:=0;for i while  sum sq≠70×70do  sum sq+:=i↑2od

ALGOL 68 allows for every natural language to define its own set of keywords Algol-68. As a result, programmers are able to write programs using keywords from their native language. Below is an example of a simple procedure that calculates "the day following", the code is in two languages: English and German.^{[Citace je zapotřebí ]}

 # Next day date - English variant # režimu datum = struktur(int den, tětiva Měsíc, int year); proc the day following = (datum X) datum:      -li den z  x < length of month (month z x, year z X) pak (day z x + 1, month z x, year z X) elif Měsíc z x = "December"      pak (1, "January", year z x + 1)      jiný (1, successor of month (month z x), year z X) fi;

 # Nachfolgetag - Deutsche Variante # menge datum = tupel(Ganz tag, mladina monat, Ganz jahr); funktion naechster tag nach = (datum X) datum:          wenn tag von x < monatslaenge(monat von x, jahr von X) dann (tag von x + 1, monat von x, jahr von X) wennaber monat von x = "Dezember"          dann (1, "Januar", jahr von x + 1)          ansonsten (1, nachfolgemonat(monat von x), jahr von X) endewenn;

Russian/Soviet example:In English Algol68's case statement reads případ ~ v ~ ven ~ esac, v cyrilice this reads выб ~ в ~ либо ~ быв.

Some Vanitas

For its technical intricacies, ALGOL 68 needs a cornucopia of methods to deny the existence of something:

přeskočit, "~" or "?"C – an undefined value always syntactically valid,prázdný – the only value admissible to prázdnota, needed for selecting prázdnota v svaz,prázdnota – syntactically like a režimu, but not one,nil or "○" – a name not denoting anything, of an unspecified reference mode,() or specifically [1:0]int - a vakuum is an empty array (here specifically of režimu []int).nedefinováno – a standards reports procedure raising an exception in the runtime system.ℵ – Used in the standards report to inhibit introspekce of certain types. např. sema

srov. below for other examples of ℵ.

Termín nil je var vždy hodnotí na skutečný for any variable (but see above for correct use of je :/=:), whereas it is not known to which value a comparison X < přeskočit evaluates for any integer X.

ALGOL 68 leaves intentionally undefined what happens in case of integer overflow, the integer bit representation, and the degree of numerical accuracy for floating point. In contrast, the language Jáva has been criticized for over-specifying the latter.

Both official reports included some advanced features that were not part of the standard language. These were indicated with an ℵ and considered effectively private. Examples include "≮" and "≯" for templates, the outtype/intype for crude duck typing a straightout a straightin operators for "straightening" nested arrays and structures.

Extract from the 1973 report:

§10.3.2.2. Transput modesa) režimu ℵ simplout = svaz (≮ℒ int≯, ≮ℒ nemovitý≯, ≮ℒ compl≯, bool, ≮ℒ bits≯,           char, [ ] char);b) režimu ℵ outtype = ¢ an actual – declarer specifying a mode united   from a sufficient set of modes none of which is 'void' or contains 'flexible',   'reference to', 'procedure' or 'union of' ¢;c) režimu ℵ simplin = svaz (≮ref ℒ int≯, ≮ref ℒ nemovitý≯, ≮ref ℒ compl≯, ref bool,           ≮ref ℒ bity≯, ref char, ref [ ] char, ref tětiva);d) režimu ℵ intype = ¢ ... ¢; §10.3.2.3. Straighteninga) op ℵ straightout = (outtype x) [ ] simplout: ¢ the result of "straightening" 'x' ¢;b) op ℵ straightin = (intype x) [ ] simplin: ¢ the result of straightening 'x' ¢;

Srovnání s jinými jazyky

• 1973 – Comparative Notes on Algol 68 and PL/I – S. H. Valentine – February 1973
• 1973 – B. R. Alexander and G. E. Hedrick. A Comparison of PL/1 and ALGOL 68. International Symposium on Computers and Chinese Input/Output Systems. pp. 359–368.
• 1976 – Evaluation of ALGOL 68, ŽOVIÁLNÍ J3B, Pascal, Simula 67, and TACPOL Versus TINMAN - Požadavky na společný programovací jazyk vysoké objednávky.
• 1976 – A Language Comparison^{[trvalý mrtvý odkaz ]} – A Comparison of the Properties of the Programming Languages ALGOL 68, CAMAC-IML, Coral 66, PAS 1, PERLA, PL / 1, PROCOL, RTL / 2 in Relation to Real Time Programming – R. Roessler; K. Schenk – October 1976 [7]
• 1976 – Evaluation of ALGOL 68, JOVIAL J3B, PASCAL, SIMULA 67, and TACPOL Versus [Steelman language requirements|TINMAN] Requirements for a Common High Order Programming Language. Říjen 1976 [8]
• 1977 – Report to the High Order-Language Working Group (HOLWG) – Executive Summary – Language Evaluation Coordinating Committee – Evaluation of PL / I., Pascal, ALGOL 68, HAL / S, PERLA, SPL/I, PDL/2, LTR, CS-4, LIS, Euklid, ECL, Moral, RTL / 2, Fortran, COBOL, ALGOL 60, TACPOL, CMS-2, Simula 67, JOVIAL J3B, JOVIAL J73 & Coral 66.
• 1977 – A comparison of PASCAL and ALGOL 68^[55] – Andrew S. Tanenbaum - červen 1977.
• 1980 – A Critical Comparison of Several Programming Language Implementations – Algol 60, FORTRAN, Pascal and Algol 68.
• 1993 – Five Little Languages and How They Grew – BLAHO, Pascal, Algol 68, BCPL & C – Dennis M. Ritchie - duben 1993.
• 1999 – On Orthogonality: Algol68, Pascal and C
• 2000 – A Comparison of Arrays in ALGOL 68 and BLAHO – University of Virginia – Michael Walker – Spring 2000
• 2009 – On Go – oh, go on – How well will Google's Jít postavit se proti programovacímu jazyku Brand X? - David Given - listopad 2009
• 2010 – Algol and Pascal from "Concepts in Programming Languages – Block-structured procedural languages" – by Marcelo Fiore
• Porovnání ALGOL 68 a C ++

Revisions

Except where noted (with a ^{horní index}), the language described above is that of the "Revised Report^(r1)".

The language of the unrevised report

The original language (As per the "Final Report"^r0) differs in syntax of the mode cast, and it had the feature of proceduring, i.e. coercing the value of a term into a procedure which evaluates the term. Proceduring would be intended to make evaluations líný. The most useful application could have been the short-circuited evaluation of boolean operators. V:

op andf = (bool A,proc bool b)bool:(a | b | Nepravdivé);op orf = (bool A,proc bool b)bool:(a | skutečný | b);

b is only evaluated if A je pravda.

As defined in ALGOL 68, it did not work as expected, for example in the code:

-li Nepravdivé andf co proc bool: co ( print ("Should not be executed"); skutečný)pak ...

against the programmers naïve expectations the print bych be executed as it is only the hodnota of the elaborated enclosed-clause after andf that was procedured. Textual insertion of the commented-out proc bool: makes it work.

Some implementations emulate the expected behaviour for this special case by extension of the language.

Before revision, the programmer could decide to have the arguments of a procedure evaluated serially instead of collaterally by using semicolons instead of commas (gomma s).

Například v:

proc test = (nemovitý A; nemovitý b) :......test (x Plus 1, x);

The first argument to test is guaranteed to be evaluated before the second, but in the usual:

proc test = (nemovitý a, b) :......test (x Plus 1, x);

then the compiler could evaluate the arguments in whatever order it felt like.

Extension proposals from IFIP WG 2.1

After the revision of the report, some extensions to the language have been proposed to widen the applicability:

• partial parametrisation (aka Kari ): creation of functions (with fewer parameters) by specification of some, but not all parameters for a call, e.g. a function logarithm of two parameters, base and argument, could be specialised to natural, binary or decadic log,
• module extension: for support of external linkage, two mechanisms were proposed, bottom-up definition modules, a more powerful version of the facilities from ALGOL 68-R and top-down díry, podobně jako ŽIVOTNÍ PROSTŘEDÍ a POUŽITÍM clauses from ALGOL 68C^[56]
• mode parameters: for implementation of limited parametrical polymorphism (most operations on data structures like lists, trees or other data containers can be specified without touching the pay load).

So far, only partial parametrisation has been implemented, in Algol 68 Genie.

True ALGOL 68s specification and implementation timeline

The S3 language that was used to write the ICL VME operating system and much other system software on the Řada ICL 2900 was a direct derivative of Algol 68. However, it omitted many of the more complex features, and replaced the basic modes with a set of data types that mapped directly to the 2900 Series hardware architecture.

Implementation specific extensions

ALGOL 68R^(R) z RRE was the first ALGOL 68 subset implementation, running on the ICL 1900. Based on the original language, the main subset restrictions were definition before use and no parallel processing. This compiler was popular in Spojené království universities in the 1970s, where many počítačová věda students learnt ALGOL 68 as their first programming language; the compiler was renowned for good error messages.

ALGOL 68RS^(RS) z RSRE was a portable compiler system written in ALGOL 68RS (bootstrapped from ALGOL 68R), and implemented on a variety of systems including the ICL 2900 /Series 39, Multics a DEC VAX/VMS. The language was based on the Revised Report, but with similar subset restrictions to ALGOL 68R. This compiler survives in the form of an Algol68-to-C compiler.

In ALGOL 68S^(S) z Univerzita Carnegie Mellon the power of parallel processing was improved by adding an orthogonal extension, všestrannost. Any variable declaration containing keyword událost made assignments to this variable eligible for parallel evaluation, i.e. the right hand side was made into a procedure which was moved to one of the processors of the C.mmp multiprocessor system. Accesses to such variables were delayed after termination of the assignment.

Cambridge ALGOL 68C^(C) was a portable compiler that implemented a subset of ALGOL 68, restricting operator definitions and omitting garbage collection, flexible rows and formatted transput.

Algol 68 Genie^(G) by M. van der Veer is an ALGOL 68 implementation for today's computers and operating systems.

"Despite good intentions, a programmer may violate portability by inadvertently employing a local extension. To guard against this, each implementation should provide a PORTCHECK pragmat option. While this option is in force, the compiler prints a message for each construct that it recognizes as violating some portability constraint."^[63]

Citáty

• ... The scheme of type composition adopted by C owes considerable debt to Algol 68, although it did not, perhaps, emerge in a form that Algol's adherents would approve of. The central notion I captured from Algol was a type structure based on atomic types (including structures), composed into arrays, pointers (references), and functions (procedures). Koncept odborů a odlitků Algolu 68 měl také vliv, který se objevil později. Dennis Ritchie Dubna 1993.^[2]
• ... C nesestupuje z Algolu 68 je pravda, přesto tam byl vliv, hodně z toho tak jemný, že je těžké se vzpamatovat, i když si myslím, že je to těžké. Zejména unijní typ (pozdní přírůstek k C) dluží A68, a to ne v jakýchkoli detailech, ale v myšlence mít takový typ vůbec. Hlubší je, že typová struktura obecně a dokonce nějakým zvláštním způsobem byla syntaxe deklarace (část konstruktoru typů) inspirována A68. A ano, samozřejmě, „dlouhý“. Dennis Ritchie, 18. června 1988^[4]
• „Gratuluji, váš pán to udělal“ - Niklaus Wirth^[64]
• Čím víc toho vidím, tím více jsem nešťastný - E. W. Dijkstra, 1968^[65]
• [...] bylo řečeno, že popularita A68 byla nepřímo úměrná [...] vzdálenosti od Amsterdamu – Guido van Rossum^[66]
• [...] Nejlepší, co jsme mohli udělat, bylo zaslat s sebou zprávu menšiny, v níž jsme uvedli náš uvažovaný názor, že „... jako nástroj pro spolehlivé vytváření sofistikovaných programů byl jazyk neúspěchem.“ [...] – C. A. R. Hoare v jeho říjnu 1980 Turing Award Přednáška^[67]
  • Citát jejich zprávy o menšině z roku 1970: „[...] Více než kdy jindy bude vyžadováno adekvátní programovací nástroj, který strukturálně pomáhá programátorovi v nejobtížnějších aspektech jeho práce, tj. Ve spolehlivém vytváření sofistikovaných programů. V tomto ohledu nechápu, jak zde navrhovaný jazyk [Algol68] je významným krokem vpřed: naopak máme pocit, že jeho implicitní pohled na programátorský úkol je téměř stejný jako například před deseti lety. To nás nutí k závěru, že jazyk, který je považován za programovací nástroj, musí být považován za zastaralý. [...] " Podepsán: Dijkstra, Duncane, Hoare, Randell, Seegmueller, Turski, Woodger. S Jan V. Garwick^[68] dne 23. prosince 1968.

Viz také

Reference

Citace

Citované práce

externí odkazy

• Revidovaná zpráva o algoritmickém jazyce ALGOL 68 Oficiální reference pro uživatele a implementátory jazyka (velký soubor PDF, naskenovaný z bulletinu Algol)
• Revidovaná zpráva o algoritmickém jazyce ALGOL 68 Hypertextová verze HTML revidované zprávy
• Výukový program pro Algol 68 tím, že Andrew S. Tanenbaum, v Výpočetní průzkumy, Sv. 8, č. 2, červen 1976, s Opravy (Sv. 9, č. 3, září 1977)
• Algol 68 Genie - překladač GNU GPL Algol 68
• Otevřené implementace ALGOL 68 na SourceForge
• Standardní hardwarové zastoupení Algol68 (.pdf)
• Из истории создания компилятора с Алгол 68
• Algol 68 - 25 let v SSSR
• Система программ динамической поддержки для транслятора с Алгол 68
• Historie C s dědictvím Algol68
• McJones, Paul, „Algol 68 implementace a dialekty“, Software Preservation Group, Muzeum počítačové historie, 2011-07-05
• Webový kompilátor ALGOL 68 pro malé experimenty