ALGOL 68 - ALGOL 68

ALGOL 68
Algol68RevisedReportCover.jpg
Revised Report on the Algorithmic Language – Algol 68 Pod redakcją: A. van Wijngaarden et al, wrzesień 1973
Paradygmaty Wieloparadygmat : współbieżny , imperatyw
Rodzina ALGOL
Zaprojektowany przez A. van Wijngaarden , BJ Mailloux , JEL Peck i CHA Koster , et al.
Po raz pierwszy pojawiły się Raport końcowy: 1968 ; 53 lata temu r0 ( 1968 )
Wersja stabilna
Algol 68/RR / poprawione sprawozdanie: 1973 ; 48 lat temu r1 ( 1973 )
Dyscyplina pisania statyczny , mocny , bezpieczny , strukturalny
Zakres Leksykalny
Główne wdrożenia
ALGOL 68C , Algol 68 Genie (ostatni) ALGOL 68-R , ALGOL 68RS , Algol 68S , FLACC , Алгол 68 Ленинград / Leningrad jednostki , Odra ALGOL 68
Dialekty
ALGOL 68/FR (Raport końcowy r0 )
Wpływem
ALGOL 60 , ALGOL Y
Pod wpływem
C , C++ , powłoka Bourne'a , KornShell , Bash , Steelman , Ada , Python , Seed7 , Mary , S3

ALGOL 68 (skrót od Algorithmic Language 1968 ) to imperatywny język programowania, który został pomyślany jako następca języka programowania ALGOL 60 , zaprojektowany z myślą o znacznie szerszym zakresie zastosowań i bardziej rygorystycznie zdefiniowanej składni i semantyce.

Złożoność definicji języka, która zajmuje kilkaset stron wypełnionych niestandardową terminologią, utrudniała implementację kompilatora i mówiono, że nie ma on implementacji i użytkowników. Było to tylko częściowo prawdziwe; ALGOL 68 znalazł zastosowanie na kilku niszowych rynkach, zwłaszcza w Wielkiej Brytanii, gdzie był popularny na maszynach International Computers Limited (ICL) oraz w nauczaniu. Poza tymi polami zastosowanie było stosunkowo ograniczone.

Niemniej jednak wkład ALGOL 68 w dziedzinę informatyki był głęboki, szeroki i trwały, chociaż wiele z tych wkładów zostało publicznie zidentyfikowanych dopiero, gdy pojawiły się ponownie w później rozwijanych językach programowania. Wiele języków zostało opracowanych specjalnie w odpowiedzi na postrzeganą złożoność języka, najbardziej godnym uwagi jest Pascal , lub były reimplementacjami dla określonych ról, takich jak Ada .

Wiele języków lat siedemdziesiątych sprowadza swój projekt konkretnie do ALGOL 68, wybierając niektóre funkcje, porzucając inne, które uważano za zbyt złożone lub wykraczające poza zakres danych ról. Wśród nich znajduje się język C , na który bezpośredni wpływ miał ALGOL 68, zwłaszcza jego silna typografia i struktury. Większość współczesnych języków śledzi przynajmniej część swojej składni w C lub Pascalu, a zatem bezpośrednio lub pośrednio w ALGOL 68.

Przegląd

Funkcje ALGOL 68 obejmują składnię opartą na wyrażeniach, typy i struktury zadeklarowane przez użytkownika/związki ze znacznikami, model referencyjny zmiennych i parametrów referencyjnych, wycinanie łańcuchów, tablic i macierzy oraz współbieżność.

ALGOL 68 został zaprojektowany przez Międzynarodową Federację Przetwarzania Informacji (IFIP) IFIP Working Group 2.1 ds. Algorytmicznych Języków i Rachunków. 20 grudnia 1968 język został formalnie przyjęty przez grupę, a następnie zatwierdzony do publikacji przez Zgromadzenie Ogólne IFIP.

ALGOL 68 został zdefiniowany przy użyciu formalizmu , dwupoziomowej gramatyki formalnej , wymyślonej przez Adriaana van Wijngaardena . Gramatyki Van Wijngaardena używają gramatyki bezkontekstowej do generowania nieskończonego zestawu produkcji, które rozpoznają konkretny program ALGOL 68; Warto zauważyć, że są one w stanie wyrazić tego rodzaju wymagań, które w wielu innych językach programowania normy techniczne są oznakowane semantykę i musi być wyrażona w wieloznaczności podatne języka naturalnego prozy, a następnie realizowane w kompilatorów jak ad hoc kod dołączony do formalnego języka parsera .

ALGOL 68 był pierwszym (i prawdopodobnie jednym z ostatnich) głównych języków, dla których przed wdrożeniem została sporządzona pełna formalna definicja.

CHA Koster

Główne cele i zasady projektowania ALGOL 68:

  1. Kompletność i jasność opisu
  2. Ortogonalność projektu
  3. Bezpieczeństwo
  4. Efektywność:
    • Sprawdzanie trybu statycznego
    • Parsowanie niezależne od trybu
    • Niezależna kompilacja
    • Optymalizacja pętli
    • Reprezentacje – w minimalnych i większych zestawach znaków

ALGOL 68 został skrytykowany, w szczególności przez niektórych członków komitetu projektowego, takich jak CAR Hoare i Edsger Dijkstra , za porzucenie prostoty ALGOL 60 , stanie się wehikułem dla złożonych lub zbyt ogólnych pomysłów i niewiele robi, aby uczynić kompilator za zadanie łatwiej, w przeciwieństwie do celowo prostych współczesnych (i konkurentów), takich jak C , S-algol i Pascal .

W 1970 roku ALGOL 68-R stał się pierwszym działającym kompilatorem dla ALGOL 68.

W rewizji z 1973 r . pominięto pewne cechy – takie jak procedura , gommy i ograniczenia formalne . Por . Język niezweryfikowanego raportu. r0

Chociaż europejskie agencje obronne (w Wielkiej Brytanii Royal Signals and Radar Establishment (RSRE)) promowały użycie ALGOL 68 ze względu na oczekiwane korzyści w zakresie bezpieczeństwa, amerykańska strona sojuszu NATO zdecydowała się na opracowanie innego projektu, języka Ada , czyniąc jego użycie obowiązkowym dla kontraktów obronnych USA.

ALGOL 68 miał również znaczący wpływ w Związku Radzieckim , o czym szczegóły można znaleźć w artykule Andrieja Erszowa z 2014 r.: „ALGOL 68 i jego wpływ na ZSRR i rosyjskie programowanie” oraz „Алгол 68 и его влияние на программирование в СССР i России".

Steve Bourne , który był członkiem komisji rewizyjnej ALGOL 68, przeniósł niektóre z pomysłów do swojej powłoki Bourne'a (a tym samym do potomnych powłok Uniksa, takich jak Bash ) i do C (a tym samym do potomków, takich jak C++ ).

Pełna historia projektu można znaleźć w CH Lindsey „s Historii Algol 68 .

Aby zapoznać się z pełnym opisem języka, zobacz „Programming ALGOL 68 Made Easy” autorstwa dr Sian Mountbatten lub „Learning ALGOL 68 Genie” autorstwa Marcela van der Veera, który zawiera poprawiony raport.

Historia

Początki

ALGOL 68, jak sama nazwa wskazuje, jest kontynuacją języka ALGOL , który został po raz pierwszy sformalizowany w 1960 roku. W tym samym roku utworzyła się Międzynarodowa Federacja Przetwarzania Informacji (IFIP) i uruchomiła Grupę Roboczą ds. ALGOL, czyli WG2.1. Grupa ta opublikowała zaktualizowaną specyfikację ALGOL 60 w Rzymie w kwietniu 1962. Na kolejnym spotkaniu w marcu 1964 uzgodniono, że grupa powinna rozpocząć prace nad dwoma kolejnymi standardami, ALGOL X, który byłby redefinicją języka z pewnymi dodatkami oraz ALGOL Y , który miałby możliwość modyfikowania własnych programów w stylu języka LISP .

Proces definicji

Pierwsze spotkanie grupy ALGOL X odbyło się na Uniwersytecie Princeton w maju 1965 roku. W sprawozdaniu ze spotkania odnotowano dwa szeroko popierane tematy, wprowadzenie silnego typowania i zainteresowanie koncepcjami Eulera „drzewami” lub „listami” do obsługi kolekcji.

Na drugim spotkaniu w październiku we Francji, trzy formalne propozycje zostały przedstawione, Niklaus Wirth „s ALGOL W wraz z komentarzem na temat rekordowych struktur przez samochód (Tony) Hoare , podobna językowych Gerhard Seegmuller i papieru przez Adriaan van Wijngaarden na" Układ ortogonalny i opis języka formalnego”. Ta ostatnia, napisana niemal nieczytelną „W-Gramatyką”, okazała się decydującą zmianą w ewolucji języka. Spotkanie zakończyło się porozumieniem, że van Wijngaarden przepisze zgłoszenie Wirtha/Hoare'a, używając swojej gramatyki W.

To pozornie proste zadanie ostatecznie okazało się trudniejsze niż oczekiwano, a kolejne spotkanie musiało zostać opóźnione o sześć miesięcy. Kiedy spotkał się w kwietniu 1966 w Kootwijk , projekt van Wijngaardena pozostał niekompletny, a Wirth i Hoare przedstawili wersję wykorzystującą bardziej tradycyjne opisy. Powszechnie uważano, że ich praca jest „właściwym językiem w złym formalizmie”. Po zbadaniu tych podejść stało się jasne, że istnieje różnica w sposobie opisu parametrów, która miałaby skutki w świecie rzeczywistym, i chociaż Wirth i Hoare protestowali, że dalsze opóźnienia mogą stać się nieskończone, komisja postanowiła poczekać na wersję van Wijngaardena. Wirth następnie zaimplementował swoją obecną definicję jako ALGOL W.

Na następnym spotkaniu w Warszawie w październiku 1966 r. pojawił się wstępny raport z Podkomisji I/O, która spotkała się w Oak Ridge National Laboratory i na Uniwersytecie Illinois, ale nie poczyniła jeszcze większych postępów. Dwie propozycje z poprzedniego spotkania zostały ponownie zbadane i tym razem pojawiła się nowa debata na temat użycia wskaźników ; ALGOL W używał ich tylko w odniesieniu do zapisów, podczas gdy wersja van Wijngaardena mogła wskazywać na dowolny obiekt. Aby dodać zamieszania, John McCarthy przedstawił nową propozycję przeciążania operatorów i możliwości łączenia w łańcuchy i/ lub konstrukcji, a Klaus Samelson chciał zezwolić na funkcje anonimowe . W powstałym zamieszaniu doszło do dyskusji o zaniechaniu całego wysiłku. Zamieszanie trwało przez to, co miało być spotkaniem ALGOL Y w Zandvoort w maju 1967 roku.

Publikacja

Projekt raportu został ostatecznie opublikowany w lutym 1968 roku. Spotkało się to ze „szokem, przerażeniem i niezgodą”, głównie z powodu setek stron nieczytelnej gramatyki i dziwnej terminologii. Charles H. Lindsey próbował dowiedzieć się, jaki „język się w nim kryje”, co wymagało sześciu osobo-tygodni wysiłku. Powstały artykuł „ALGOL 68 z mniejszą ilością łez” był szeroko rozpowszechniany. Na szerszym spotkaniu dotyczącym przetwarzania informacji w Zurychu w maju 1968, uczestnicy skarżyli się, że język jest im narzucany i że IFIP jest „prawdziwym złoczyńcą tej nierozsądnej sytuacji”, ponieważ spotkania były w większości zamknięte i nie było formalnego mechanizmu informacji zwrotnej. Wirth i Peter Naur w tym czasie formalnie zrezygnowali ze swoich pozycji autorskich w WG2.1.

Następne spotkanie WG2.1 odbyło się w Tirrenii w czerwcu 1968. Miało omówić wypuszczenie kompilatorów i inne kwestie, ale zamiast tego przekształciło się w dyskusję na temat języka. van Wijngaarden odpowiedział, mówiąc (lub grożąc), że wyda jeszcze tylko jedną wersję raportu. W tym momencie Naur, Hoare i Wirth zrezygnowali z wysiłku, a kilku innych groziło, że to zrobi. Następnie odbyło się kilka kolejnych spotkań, North Berwick w sierpniu 1968 r., Monachium w grudniu, w wyniku którego opublikowano oficjalny Raport w styczniu 1969 r., ale także sporządzono kontrowersyjny Raport Mniejszości. Wreszcie, w Banff, Alberta, we wrześniu 1969 roku, projekt uznano za ukończony, a dyskusja dotyczyła głównie erraty i znacznie rozszerzonego Wstępu do Raportu.

Wysiłek ten trwał pięć lat, wypalił wiele z największych nazwisk w dziedzinie informatyki , a kilkakrotnie utknął w martwym punkcie zarówno w definicji, jak i w grupie jako całości. Hoare niemal natychmiast wydał „Critique of ALGOL 68”, do którego w wielu pracach często się odwołuje. Wirth dalej rozwijał koncepcję ALGOL W i wydał ją jako Pascal w 1970 roku.

Realizacje

ALGOL 68-R

Pierwsza implementacja standardu, oparta na projekcie raportu z końca 1968 roku, została wprowadzona przez Royal Radar Establishment w Wielkiej Brytanii jako ALGOL 68-R w lipcu 1970 roku. Był to jednak podzbiór pełnego języka, a Barry Mailloux , ostatni redaktor Raportu, żartował, że "To kwestia moralności. Mamy Biblię, a ty grzeszysz!" Mimo to wersja ta stała się bardzo popularna na maszynach ICL i stała się powszechnie używanym językiem w kodowaniu wojskowym, zwłaszcza w Wielkiej Brytanii.

Wśród zmian w 68-R był wymóg zadeklarowania wszystkich zmiennych przed ich pierwszym użyciem. Miało to znaczną zaletę, że pozwalało kompilatorowi na jednoprzebiegowe, ponieważ miejsce na zmienne w rekordzie aktywacji zostało zarezerwowane przed użyciem. Jednak ta zmiana miała również efekt uboczny polegający na dwukrotnym zadeklarowaniu proc s, raz jako deklaracja typów, a następnie ponownie jako treść kodu. Kolejną zmianą było wyeliminowanie zakładanego trybu void , wyrażenia, które nie zwraca żadnej wartości (nazywanego stwierdzeniem w innych językach) i żądanie dodania słowa void w miejscu, w którym zostałoby to przyjęte. Ponadto 68-R wyeliminował jawne polecenia przetwarzania równoległego oparte na par .

Inni

Pierwsza pełna implementacja języka została wprowadzona w 1974 roku przez CDC Netherlands dla serii komputerów mainframe Control Data . Spowodowało to ograniczone zastosowanie, głównie w nauczaniu w Niemczech i Holandii.

Wersja podobna do 68-R została wprowadzona z Carnegie Mellon University w 1976 roku jako 68S i ponownie była kompilatorem jednoprzebiegowym opartym na różnych uproszczeniach oryginału i przeznaczonym do użytku na mniejszych maszynach, takich jak DEC PDP-11 . On też był używany głównie do celów dydaktycznych.

Wersja dla komputerów mainframe IBM została udostępniona dopiero w 1978 roku, kiedy została wydana na Uniwersytecie Cambridge . To było „prawie kompletne”. Lindsey wydała wersję dla małych maszyn, w tym IBM PC w 1984 roku.

Znane są trzy implementacje open source Algol 68:

Oś czasu

Rok Wydarzenie Współpracownik
Marzec 1959 ALGOL Biuletyn Wydanie 1 (pierwszy) Piotr Naur / ACM
Luty 1968 Opublikowany projekt raportu (DR) Grupa Robocza IFIP 2.1
Marzec 1968 Algol 68 Raport końcowy r0 przedstawiony na spotkaniu w Monachium Grupa Robocza IFIP 2.1
Czerwiec 1968 Spotkanie w Tirrenii we Włoszech Grupa Robocza IFIP 2.1
Sierpień 1968 Spotkanie w North Berwick w Szkocji Grupa Robocza IFIP 2.1
grudzień 1968 ALGOL 68 Raport końcowy r0 przedstawiony na spotkaniu w Monachium Grupa Robocza IFIP 2.1
Kwiecień 1970 ALGOL 68-R (R) pod GEORGE 3 na ICL 1907F Sygnały królewskie i Radar Est.
wrzesień 1973 Algol 68 Poprawiony raport r1 opublikowany Grupa Robocza IFIP 2.1
1975 ALGOL 68C (C) – przenośny kompilator (zcode VM ) S. Bourne , Andrew Birrell i Michael Guy
Czerwiec 1975 GE Hedrick i Alan Robertson. Kompilator podzbiorów ALGOL 68 stanu Oklahoma. 1975 Międzynarodowa konferencja na temat ALGOL 68.
Czerwiec 1977 Konferencja Strathclyde ALGOL 68, Szkocja ACM
maj 1978 Propozycje dla ALGOL H – Superjęzyk ALGOL 68 AP Czarny, VJ Rayward-Smith
1984 Pełny kompilator ALGOL 68S (S) dla Sun, SPARC i komputerów PC CH Lindsey i in., Manchester
Sierpień 1988 ALGOL Biuletyn Wydanie 52 (ostatni) Wyd. CH Lindsey / ACM
maj 1997 Algol68 S (S) opublikowany w Internecie Charles H. Lindsey
Listopad 2001 Algol 68 Genie (G) opublikowany w Internecie (licencja GNU GPL open source) Marcel van der Veer

Język algorytmiczny ALGOL 68 Raporty i członkowie Grupy Roboczej

„Van Wijngaarden scharakteryzował kiedyś czterech autorów, nieco żartobliwie, jako: Koster: transputter , Peck: syntaksator, Mailloux: realizator, Van Wijngaarden: ideolog partii”. – Koster.

Kalendarium normalizacji

1968: W dniu 20 grudnia 1968 roku „Final Report” (MR 101) został przyjęty przez Grupę Roboczą, następnie następnie zatwierdzony przez Zgromadzenie Ogólne UNESCO „s IFIP do publikacji. Tłumaczenia normy zostały wykonane na język rosyjski , niemiecki , francuski i bułgarski , a następnie japoński i chiński . Standard został również udostępniony w alfabecie Braille'a .

1984: TC97 uznała ALGOL 68 do standaryzacji za „Nowy przedmiot pracy” TC97/N1642 [2] [3] . Zachodnie Niemcy, Belgia, Holandia, ZSRR i Czechosłowacja chciały uczestniczyć w przygotowaniu normy, ale ZSRR i Czechosłowacja „nie były właściwym rodzajem członków właściwych komitetów ISO” [4], a normalizacja ISO Algola 68 utknęła w martwym punkcie. [5]

1988: Następnie ALGOL 68 stał się jednym ze standardów GOST w Rosji.

  • GOST 27974-88 Język programowania ALGOL 68 – Язык программирования АЛГОЛ 68
  • GOST 27975-88 Język programowania ALGOL 68 rozszerzony – Язык программирования АЛГОЛ 68 расширенный

Wybitne elementy językowe

Pogrubione symbole i zastrzeżone słowa

Standardowy język zawiera około sześćdziesięciu zastrzeżonych słów, zwykle pogrubionych w druku, a niektóre z odpowiednikami „krótkiego symbolu”:

mode, op, prio, proc,
flex, heap, loc, long, ref, short,
bits, bool, bytes, char, compl, int, real, sema, string, void,
channel, file, format, struct, union,
at "@", eitherr0, is ":=:", isnt  is notr0 ":/=:" ":≠:", of "→"r0, true, false, empty, nil "○", skip "~",
co "¢", comment "¢", pr, pragmat,
case ~ in ~ ouse ~ in ~ out ~ esac "( ~ | ~ |: ~ | ~ | ~ )",
for ~ from ~ to ~ by ~ while ~ do ~ od,
if ~ then ~ elif ~ then ~ else ~ fi "( ~ | ~ |: ~ | ~ | ~ )",
par begin ~ end "( ~ )", go to, goto, exit "."r0.

Jednostki: wyrażenia

Podstawową konstrukcją języka jest jednostka . Jednostką może być formuła , zamknięta klauzula , rutynowy tekst lub jedna z kilku technicznie potrzebnych konstrukcji (przypisanie, skok, pominięcie, nihil). Termin techniczny załączony klauzula ujednolica niektóre z nieodłącznie konstrukcji nawiasów znanych jako instrukcja blok , instrukcja do , instrukcja switch w innych współczesnych językach. Gdy używane są słowa kluczowe, zazwyczaj odwrócona sekwencja znaków słowa kluczowego wprowadzającego jest używana do zakończenia załącznika, np. ( if ~ then ~ else ~ fi , case ~ in ~ out ~ esac , dla ~ while ~ do ~ od ). Ta składnia Guarded Command została ponownie wykorzystana przez Stephena Bourne'a we wspólnej powłoce Unix Bourne . Wyrażenie może również dawać wartość wielokrotną , która jest konstruowana z innych wartości przez klauzulę zabezpieczającą . Ta konstrukcja wygląda jak pakiet parametrów wywołania procedury.

tryb: Deklaracje

Podstawowe typy danych (zwane modes w żargonie Algol 68) to real, int, compl( liczba zespolona ), bool, char, bitsi bytes. Na przykład:

int n = 2;
co n is fixed as a constant of 2. co
int m := 3;
co m is a newly created local variable whose value is initially set to 3. co
co    This is short for ref int m = loc int := 3; co
real avogadro = 6.0221415⏨23; co Avogadro's number co
long long real long long pi = 3.14159 26535 89793 23846 26433 83279 50288 41971 69399 37510;
compl square root of minus one = 0 ⊥ 1;

Jednak deklaracja real x;to tylko cukier składniowy dla . Oznacza to, że jest naprawdę stały identyfikator dla odniesienie do nowo wytworzonej lokalnym rzeczywistym zmiennej. ref real x = loc real;x

Ponadto, zamiast definiowania floati double, lub inti i longi short, itd., ALGOL 68 dostarcza modyfikatory , tak że na przykład obecnie wspólne doublebędzie zapisane jako long real lub long long real . Na stałe Prelude max real i min long intsłużą do dostosowania programów do różnych implementacjach.

Wszystkie zmienne muszą być zadeklarowane, ale deklaracja nie musi poprzedzać pierwszego użycia.

primitive-declarer: int , real , compl , complex G , bool , char , string , bits , bytes , format , file , pipe G , channel , sema

  • bits – „upakowany wektor” bool .
  • bytes – „wektor upakowany” char .
  • stringelastyczna tablica char .
  • Sema - Sema Phore które mogą być zainicjowane z op Erator poziomie .

Typy złożone można tworzyć z prostszych za pomocą różnych konstruktorów typów:

  • ref mode – odwołanie do wartości typu mode , podobne do & w C/C++ i ref w Pascalu
  • struct – służy do budowania struktur, takich jak struct w C/C++ i rekord w Pascal
  • union – używane do budowania unii, jak w C/C++ i Pascal
  • proc – służy do określania procedur, takich jak funkcje w C/C++ i procedury/funkcje w Pascal

Aby zapoznać się z niektórymi przykładami, zobacz Porównanie ALGOL 68 i C++ .

Inne symbole deklaracji to: flex , heap , loc , ref , long , short , event S

  • flex – deklaruj, że tablica jest elastyczna, tzn. może rosnąć na żądanie.
  • sterta – przydziela zmiennej trochę wolnego miejsca ze sterty globalnej.
  • loc – przydziela zmiennej trochę wolnego miejsca na stosie lokalnym.
  • długo - zadeklarować int , prawdziwe lub compl się z długim wielkości er.
  • Krótko mówiąc - zadeklarować int , prawdziwe lub compl się z krótkim wielkości er.

Nazwę trybu (typu) można zadeklarować za pomocą deklaracji trybu , która jest podobna do typedef w C/C++ i typu w Pascalu:

 int max=99;
 mode newmode = [0:9][0:max]struct (
     long real a, b, c, short int i, j, k, ref real r
 );

Jest to podobne do następującego kodu C:

  const int max=99;
  typedef struct {
      double a, b, c; short i, j, k; float *r;
  } newmode[9+1][max+1];

W przypadku ALGOL 68 tylko wskazanie trybu nowego trybu pojawia się po lewej stronie symbolu równości, a przede wszystkim konstrukcja jest wykonana i może być odczytana od lewej do prawej bez względu na priorytety. Również dolna granica tablic Algol 68 to domyślnie jeden, ale może to być dowolna liczba całkowita od -max int do max int .

Deklaracje trybu pozwalają na to, aby typy były rekurencyjne : definiowane bezpośrednio lub pośrednio w kategoriach samych siebie. Podlega to pewnym ograniczeniom – np. te deklaracje są niezgodne z prawem:

 mode A = ref A
 mode A = struct (A a, B b)
 mode A = proc (A a) A

dopóki obowiązują:

 mode A = struct (ref A a, B b)
 mode A = proc (ref A a) ref A

Przymusy: odlewanie

W coercions produkować coercee z coercend według trzech kryteriów: a priori trybu pracy coercend przed zastosowaniem jakiegokolwiek przymusu, trybie a posteriori z coercee wymaganego po tych coercions oraz składniowej pozycji lub „sort” z coercee . Przymusy mogą być kaskadowane.

Sześć możliwych przymusów jest określanych jako wycofywanie się , wyłuskiwanie , łączenie , poszerzanie , wiosłowanie i opróżnianie . Każdy przymus, z wyjątkiem jednoczenia , nakazuje odpowiedni dynamiczny wpływ na związane z nim wartości. Stąd wiele prymitywnych działań może być zaprogramowanych pośrednio przez przymus.

Siła kontekstu – dozwolone przymusy:

  • miękkie – wycofywanie
  • słaby – dereferencja lub deproceding, dające nazwę
  • łagodny – dereferencja lub deproceduring
  • stanowczy – łagodny, a następnie jednoczący
  • mocna – twarda, po której następuje poszerzenie, wiosłowanie lub opróżnianie

Hierarchia przymusu z przykładami

ALGOL 68 posiada hierarchię kontekstów, które określają rodzaj przymusu dostępnego w danym punkcie programu. Te konteksty to:

Kontekst
Lokalizacja kontekstowa Dostępne przymusy Przykłady przymusu w kontekście
Miękki
Słaby
Cichy
Solidny
Silny
Silny
Prawa strona:
  • Deklaracje tożsamości, jak „~” w: REAL x = ~
  • Inicjalizacje, jak "~" w: REAL x := ~

Także:

  • Rzeczywiste parametry połączeń, jako "~" w:PROC: sin(~)
  • Załączone klauzule rzutowania, jak "~" w: REAL(~)
  • Jednostki tekstów rutynowych
  • Oświadczenia dające VOID
  • Wszystkie części (oprócz jednej) klauzuli zrównoważonej
  • Jedna strona relacji tożsamościowej, jak „~” w: ~ IS ~
deproc​edur​ing
Wszystkie miękkie, a potem słabe dereferencingowanie (dereferencjonowanie lub deprocedowanie, dające nazwę)
Wszystkie słabe, a potem dereferencujące
Wszyscy potulni, a potem jednoczący się
Cała twarda następnie rozszerza się, wiosłuje lub opróżnia

Poszerzenie występuje, gdy nie ma utraty precyzji. Na przykład: INT zostanie przekształcona w REAL, a REAL zostanie przekształcona w LONG REAL. Ale nie odwrotnie. Przykłady:

INT to LONG INT
INT to REAL
REAL to COMPL
BITS to []BOOL
BYTES to STRING

Zmienna może być również wymuszona (w wierszu) do tablicy o długości 1.

Na przykład:

INT to [1]INT
REAL to [1]REAL
itp.
Solidny
  • Argumenty formuł jako „~” w:OP: ~ * ~
  • Parametry połączeń transmisyjnych
Przykład:

UNION(INT,REAL) var := 1

Cichy
  • Trimscripts (uzysk INT)
  • Zapytania: np. jako "~" w następujących

IF ~ THEN ... FI oraz FROM ~ BY ~ TO ~ WHILE ~ DO ... OD etc

  • Podstawowe wezwania (np. sin in sin(x))
Przykłady:
REF REF BOOL to BOOL
REF REF REF INT to INT
Słaby
  • Podstawowe plastry, jak w „~” w: ~[1:99]
  • Drugorzędne selekcje, jak "~" w: value OF ~
Przykłady:
REF BOOL to REF BOOL
REF REF INT to REF INT
REF REF REF REAL to REF REAL
REF REF REF REF STRUCT to REF STRUCT
Miękki
LHS przydziałów, jako „~” w: ~ := ... Przykład:
  • wycofywanie: PROC REAL random: e.g. random

Aby uzyskać więcej informacji na temat podstawowych, drugorzędnych, trzeciorzędnych i czwartorzędowych, zobacz Pierwszeństwo operatorów .

pr & co: Pragmaty i komentarze

Pragmaty to dyrektywy w programie, zazwyczaj wskazówki dla kompilatora; w nowszych językach nazywa się je „pragmami” (bez „t”). np

pragmat heap=32 pragmat
pr heap=32 pr

Komentarze można wstawiać na różne sposoby:

¢ The original way of adding your 2 cents worth to a program ¢
comment "bold" comment comment
co Style i comment co
# Style ii comment #
£ This is a hash/pound comment for a UK keyboard £

Zwykle komentarze nie mogą być zagnieżdżane w ALGOL 68. Ograniczenie to można ominąć, stosując różne ograniczniki komentarzy (np. używaj skrótu tylko do tymczasowego usuwania kodu).

Wyrażenia i zdania złożone

ALGOL 68 jest językiem programowania zorientowanym na wyrażenia , wartość zwracana przez instrukcję przypisania jest odniesieniem do miejsca docelowego. Zatem poprawny kod ALGOL 68 jest następujący:

 real half pi, one pi; one pi := 2 * ( half pi := 2 * arc tan(1) )

Pojęcie to jest obecne m.in. w C i Perlu . Zauważ, że tak jak we wcześniejszych językach, takich jak Algol 60 i FORTRAN , spacje są dozwolone w identyfikatorach, więc half pijest to pojedynczy identyfikator (w ten sposób unika się podkreśleń w porównaniu z wielbłądami w porównaniu ze wszystkimi problemami z małymi literami ).

W innym przykładzie, wyrażenie matematyczne ideę sumy z f(i)od i = 1 do n, w następujących Algol 68 całkowite ekspresji jest wystarczająca:

 (int sum := 0; for i to n do sum +:= f(i) od; sum)

Należy zauważyć, że będąc wyrażeniem całkowitym, poprzedni blok kodu może być używany w dowolnym kontekście, w którym można użyć wartości całkowitej . Blok kodu zwraca wartość ostatniego wyrażenia, które zostało ocenione; ta idea jest obecna w Lisp , między innymi w innych językach.

Wszystkie instrukcje złożone są zakończone wyróżniającymi się nawiasami zamykającymi:

  • jeśli klauzule wyboru:
 if condition then statements [ else statements ] fi
 "brief" form:  ( condition | statements | statements )
 if condition1 then statements elif condition2 then statements [ else statements ] fi
 "brief" form:  ( condition1 | statements |: condition2 | statements | statements )

Ten schemat nie tylko pozwala uniknąć nieaktualnego problemu, ale także pozwala uniknąć konieczności używania begini endosadzonych sekwencji instrukcji .

  • klauzule wyboru przypadku :
 case switch in statements, statements,... [ out statements ] esac
 "brief" form:  ( switch | statements,statements,... | statements )
 case switch1 in statements, statements,... ouse switch2 in statements, statements,... [ out statements ] esac
 "brief" form of case statement:  ( switch1 | statements,statements,... |: switch2 | statements,statements,... | statements )

Przykład klauzuli wyboru z krótkimi symbolami:

proc days in month = (int year, month)int:
  (month|
    31,
    (year÷×4=0 ∧ year÷×100≠0  ∨  year÷×400=0 | 29 | 28 ),
    31, 30, 31, 30, 31, 31, 30, 31, 30, 31
  );

Przykład klauzuli wyboru z symbolami Bold :

proc days in month = (int year, month)int:
  case month in
    31,
    if year mod 4 eq 0 and year mod 100 ne 0  or  year mod 400 eq 0 then 29 else 28 fi,
    31, 30, 31, 30, 31, 31, 30, 31, 30, 31
  esac;

Przykład klauzuli wyboru mieszający symbole Bold i Brief :

proc days in month = (int year, month)int:
  case month in
¢Jan¢ 31,
¢Feb¢ ( year mod 4 = 0 and year mod 100 ≠ 0  or  year mod 400 = 0 | 29 | 28 ),
¢Mar¢ 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ¢ to Dec. ¢
  esac;

Algol68 pozwolił, aby przełącznik był typu int lub (wyjątkowo) union . Ta ostatnia pozwala na wymuszanie silnego typowania na zmiennych typu union . cf związek poniżej na przykład.

 [ for index ] [ from first ] [ by increment ] [ to last ] [ while condition ] do statements od
 The minimum form of a "loop clause" is thus: do statements od

Uznano „uniwersalne” pętla, pełna składnia jest następująca:

for i from 1 by -22 to -333 while i×i≠4444 do ~ od

Konstrukt ma kilka nietypowych aspektów:

  • tylko część do ~ od była obowiązkowa, w takim przypadku pętla będzie iterować w nieskończoność.
  • zatem klauzula do 100 ma ~ od będzie iteracyjne tylko 100 razy.
  • natomiast „składniowym elementem” dozwolone programista przerwy od A do obiegu wcześniej. np
int sum sq:=0;
for i
while
  print(("So far:",i,newline));
  sum sq≠70↑2
do
  sum sq+:=i↑2
od

Kolejne „rozszerzenia” do standardowego Algol68 pozwoliło na składniowej elementu być zastąpione września i downto osiągnąć niewielką optymalizacji. Te same kompilatory zawierały również:

  • do (C) – dla późnego zakończenia pętli.
  • foreach (S) – do równoległej pracy na tablicach .

Dalsze przykłady można znaleźć w przykładach kodu poniżej.

struct, union & [:]: Struktury, unii i tablice

ALGOL 68 obsługuje tablice o dowolnej liczbie wymiarów i umożliwia cięcie całych lub częściowych wierszy lub kolumn.

 mode vector = [1:3]    real;   # vector mode declaration (typedef)  #
 mode matrix = [1:3,1:3]real;   # matrix mode declaration (typedef)  #
 vector v1  := (1,2,3);         # array variable initially (1,2,3)   #
 []real v2   = (4,5,6);         # constant array, type equivalent to vector, bounds are implied  #
 op + = (vector a,b) vector:    # binary operator definition         #
   (vector out; for i from ⌊a to ⌈a do out[i] := a[i]+b[i] od; out);
 matrix m := (v1, v2, v1+v2);
 print ((m[,2:]));              # a slice of the 2nd and 3rd columns #

Matryce można ciąć w dowolny sposób, np.:

 ref vector row = m[2,];  # define a ref (pointer) to the 2nd row #
 ref vector col = m[,2];  # define a ref (pointer) to the 2nd column #

ALGOL 68 obsługuje wiele struktur pola ( struct ) i trybów zjednoczonych . Zmienne referencyjne mogą wskazywać na dowolny tryb, w tym na wycinki tablicy i pola struktury.

Przykładem tego wszystkiego jest tradycyjna deklaracja listy połączonej:

 mode node = union (void, real, int, compl, string),
      list = struct (node val, ref list next);

Przykład użycia dla związków przypadku w węźle :

Algol68 r0 jak w Raporcie Końcowym z 1968 r.
 node n := "1234";
 real r; int i; compl c; string s
 case r,i,c,s::=n in
   print(("real:", r)),
   print(("int:", i)),
   print(("compl:", c)),
   print(("string:", s))
   out print(("?:", n))
 esac
Algol68 r1 jak w poprawionym raporcie z 1973 r.
 node n := "1234";
 # or n := EMPTY; #
  case n in
   (void):     print(("void:", "EMPTY")),
   (real r):   print(("real:", r)),
   (int i):    print(("int:", i)),
   (compl c):  print(("compl:", c)),
   (string s): print(("string:", s))
   out         print(("?:", n))
 esac

proc: Procedury

Deklaracje procedury ( proc ) wymagają specyfikacji typu zarówno dla parametrów, jak i wyniku ( nieważne, jeśli brak):

 proc max of real = (real a, b) real:
    if a > b then a else b fi;

lub używając „krótkiej” formy oświadczenia warunkowego:

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

Zwracana wartość a procjest wartością ostatniego wyrażenia ocenionego w procedurze. Dozwolone są również odniesienia do procedur ( ref proc ). Parametry wywołania przez odwołanie są dostarczane przez określenie odwołań (takich jak ref real) na formalnej liście argumentów. Poniższy przykład definiuje procedurę, która stosuje funkcję (określoną jako parametr) do każdego elementu tablicy:

 proc apply = (ref [] real a, proc (real) real f):
  
    for i from lwb a to upb a do a[i] := f(a[i]) od

Ta prostota kodu była nieosiągalna w poprzedniku ALGOL 68, ALGOL 60 .

op: Operatorzy

Programista może zdefiniować nowe operatory i zarówno te, jak i te predefiniowane mogą być przeciążone, a ich priorytety mogą zostać zmienione przez kodera. W poniższym przykładzie zdefiniowano operator maxz wersjami dyadycznymi i monadycznymi (skanowanie elementów tablicy).

 prio max = 9;
  
 op max = (int a,b) int: ( a>b | a | b );
 op max = (real a,b) real: ( a>b | a | b );
 op max = (compl a,b) compl: ( abs a > abs b | a | b );
  
 op max = ([]real a) real:
    (real out := a[lwb a];
     for i from lwb a + 1 to upb a do ( a[i]>out | out:=a[i] ) od;
     out)

Operacje tablic, procedur, dereferencji i przymusu

prio czeństwa Operacja r0 i r1 +Algol68 r0 +Algol68 G
Skutecznie 12
(główny)
wyłuskiwanie, deproceduring(~,~), indeksowanie[~], wierszowanie[~,], slicing[~:~], oznaczenia rozmiaru długie i krótkie postępowanie currying(~,,,), diag , trnsp , wiersz , col
Skutecznie 11
(wtórny)
z (wybór), loc i sterty (generatory) → (wybór) nowe (generatory)

Z technicznego punktu widzenia nie są to operatory, raczej są uważane za „ jednostki powiązane z nazwami

Operatorzy monadyczni

prio czeństwa
(trzeciorzędowy)
Algol68 „Przyzwoite postacie” r0 i r1 +Algol68 r0 i r1 +Algol68 C,G +Algol68 r0
10 nie ~, w górę , w dół , lwb , upb ,

-, abs , arg , bin , entier , leng , level , odd , repr , round , shorten

¬, ↑, ↓, ⌊, ⌈ norma , ślad , t , det , inv lws , ups , ⎩, ⎧, btb , ctb

Operatory dwudniowe z powiązanymi priorytetami

prio czeństwa
(trzeciorzędowy)
Algol68 „Przyzwoite postacie” r0 i r1 +Algol68 r0 i r1 +Algol68 C,G +Algol68 r0
9 +*, ja +×, ⊥ !
8 shl , shr , **, góra , dół , lwb , upb , ↓, , ××, ^, lws , ups , ⎩, ⎧
7 *, /, %, ponad , %*, mod , elem ×, ÷, ÷×, ÷*, %×, □ ÷:
6 -, +
5 <, lt , <=, le , >=, ge , >, gt ≤, ≥
4 równ =, ne ~= /= ≠, ¬=
3 &, i /\
2 lub \/
1 minusab , plusab , timesab , divab , overab , modab , plusto ,

-:=, +:=, *:=, /:=, %:=, %*:=, +=:

×:=, ÷:=, ÷×:=, ÷*:=, %×:= minus , plus , div , overb , modb , ÷::=, prus

Szczegółowe informacje:

  • Trzeciorzędne obejmują nazwy nil i ○.
  • lws : W Algol68 r0 operatory lws i ⎩ ... zwracają prawdę, jeśli dolny stan wymiaru tablicy jest ustalony.
  • Operatory ups i ⎧ są podobne w górnym stanie .
  • W LWB i UPB operatorzy są automatycznie dostępne na zjednoczenie s różnych zamówień (i tryb s) tablic. np. upb of union([]int, [,]real, flex[,,,]char)

Relacje przypisania i tożsamości itp

Z technicznego punktu widzenia nie są to operatory, raczej są uważane za „ jednostki powiązane z nazwami

prio czeństwa
(czwartorzędowe)
Algol68 „Przyzwoite postacie” r0 i r1 +Algol68 r0 i r1 +Algol68 C,G,R +Algol68 r0
Skutecznie 0 :=, is  :=:, isnt  :/=: :~=:, at @, ":", ";" :≠: :¬=: :=:= C , =:= R ..=, .=, ct , ::, ctab , ::=, .., nie jest , "..", ".,"

Uwaga: Czwartorzędy obejmują nazwy pomiń i ~.

":=:" (alternatywnie " is ") sprawdza, czy dwa wskaźniki są równe; ":/=:" (alternatywnie " isnt ") sprawdza, czy są nierówne.

Dlaczego potrzebne są :=: i :/=:: Rozważ próbę porównania dwóch wartości wskaźników, takich jak następujące zmienne, zadeklarowanych jako wskaźniki do liczby całkowitej:

ref int ip, jp

Teraz zastanów się, jak zdecydować, czy te dwa wskazują na tę samą lokalizację, czy też jeden z nich wskazuje na nil . Następujące wyrażenie

ip = jp

wyłuska oba wskaźniki do wartości typu int i porówna je, ponieważ operator "=" jest zdefiniowany dla int , ale nie ref int . Jest to nie prawną do określenia „=” dla argumentów typu ref int i int w tym samym czasie, bo wtedy rozmowy stają się dwuznaczne, z powodu ukrytych coercions, które mogą być zastosowane: należy operandy być pozostawiony jako ref int i tej wersji zadzwonił operator? A może powinny być wyłuskane dalej do int i zamiast tego użyć tej wersji? Dlatego następujące wyrażenie nigdy nie może być legalne:

ip = nil

Stąd potrzeba oddzielnych konstrukcji niepodlegających normalnym regułom przymusu dla operandów do operatorów. Ale jest pewien kłopot. Następujące wyrażenia:

ip :=: jp
ip :=: nil

choć legalne, prawdopodobnie nie zrobi tego, czego można się spodziewać. Zawsze zwrócą false , ponieważ porównują rzeczywiste adresy zmiennych ipi jp, a nie to , na co wskazują . Aby osiągnąć odpowiedni efekt, należałoby napisać

ip :=: ref int(jp)
ip :=: ref int(nil)

Znaki specjalne

Klawiatura IBM 2741 z symbolami APL

Większość „specjalnych” znaków Algola (⊂, ≡, ␣, ×, ÷, ≤, ≥, ≠, ¬, ⊃, ≡, ∨, ∧, →, ↓, ↑, ⌊, ⌈, ⎩, ⎧, ⊥, ⏨, ¢, ○ i □) można znaleźć na klawiaturze IBM 2741 z włożoną głowicą drukującą „piłka golfowa” APL ; stały się one dostępne w połowie lat 60., gdy opracowywano ALGOL 68. Znaki te są również częścią standardu Unicode i większość z nich jest dostępna w kilku popularnych czcionkach .

transput: wejście i wyjście

Transput jest terminem używanym w odniesieniu do urządzeń wejściowych i wyjściowych ALGOL 68. Zawiera predefiniowane procedury dla translacji niesformatowanej, sformatowanej i binarnej. Pliki i inne urządzenia transmisyjne są obsługiwane w sposób spójny i niezależny od maszyny. Poniższy przykład wyświetla niektóre niesformatowane dane wyjściowe na standardowe urządzenie wyjściowe :

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

Zwróć uwagę na wstępnie zdefiniowane procedury newpagei newlineprzekazane jako argumenty.

Książki, kanały i pliki

Za transputację uważa się książki , kanały i pliki :

  • Książki składają się ze stron, wierszy i znaków, a ich kopie zapasowe mogą być tworzone w plikach.
    • Konkretną książkę można znaleźć według nazwy za pomocą wywołania match.
  • kanały odpowiadają urządzeniom fizycznym. np. dziurkacze do kart i drukarki.
    • Wyróżnia się trzy standardowe kanały: kanał stand-in, kanał stand out, kanał stand back .
  • Plik jest środkiem komunikacji między programem a książki, które zostały otwarte przez jakiegoś kanału.
    • Nastrój pliku można czytać, pisać, char, bin, i otworzył.
    • procedury transmisyjne obejmują: establish, create, open, associate, lock, close, scratch.
    • stanowisko wymaga: char number, line number, page number.
    • Procedury układu obejmują:
      • space, backspace, newline, newpage.
      • get good line, get good page, get good book, oraz proc set=(ref file f, int page,line,char)void:
    • Plik zawiera procedury zdarzeń . np on logical file end, on physical file end, on page end, on line end, on format end, on value error, on char error. .

sformatowany transput

"Sformatowany transput" w transput ALGOL 68 ma swoją własną składnię i wzorce (funkcje), z formatem s osadzonym między dwoma znakami $.

Przykłady:

 printf (($2l"The sum is:"x, g(0)$, m + n)); ¢ prints the same as: ¢
 print ((new line, new line, "The sum is:", space, whole (m + n, 0))

par: Przetwarzanie równoległe

ALGOL 68 wspiera programowanie przetwarzania równoległego. Przy użyciu parametru par , A zabezpieczenia punkt przekształca się w równoległej klauzulą , jeżeli synchronizacja jest regulowana za pomocą działania semaforów . W A68G akcje równoległe są mapowane na wątki, jeśli są dostępne w systemie operacyjnym hostingu . W A68S zaimplementowano inny paradygmat przetwarzania równoległego (patrz poniżej).

int initial foot width = 5;
mode foot = struct(
   string name,
   sema width,
   bits toe ¢ packed vector of BOOL ¢
);
 
foot left foot:= foot("Left", level initial foot width, 2r11111),
     right foot:= foot("Right", level initial foot width, 2r11111);
 
¢ 10 round clip in a 1968 Colt Python .357 Magnum ¢
sema rounds = level 10;
 
¢ the Magnum needs more barrels to take full advantage of parallelism ¢
sema acquire target = level 1;
 
prio ∧:= = 1;
op ∧:= = (ref bits lhs, bits rhs)ref bits: lhs := lhs ∧ rhs;
 
proc shoot = (ref foot foot)void: (
  ↓acquire target;
  ↓rounds;
  print("BANG! ");
  ↓width → foot;
  toe → foot ∧:= ¬(bin 1 shl level 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 ¢
par (
  for toe to initial foot width do
    shoot (left foot)
  od, ¢ <= a comma is required ¢
  for toe to initial foot width do
    shoot(right foot)
  od
)

Przykłady użycia

Próbka kodu

Ten przykładowy program implementuje Sito Eratostenesa, aby znaleźć wszystkie liczby pierwsze mniejsze niż 100. nil jest odpowiednikiem wskaźnika zerowego w ALGOL 68 w innych językach. Oznaczenie x z y dostęp do członu X o struct y .

begin # Algol-68 prime number sieve, functional style #
  
  proc error = (string s) void:
     (print(( newline, " error: ", s, newline)); goto stop);
  proc one to = (int n) list:
     (proc f = (int m,n) list: (m>n | nil | cons(m, f(m+1,n))); f(1,n));
  
  mode list = ref node;
  mode node = struct (int h, list t);
  proc cons = (int n, list l) list: heap node := (n,l);
  proc hd   = (list l) int: ( l is nil | error("hd nil"); skip | h of l );
  proc tl   = (list l) list: ( l is nil | error("tl nil"); skip | t of l );
  proc show = (list l) void: ( l isnt nil | print((" ",whole(hd(l),0))); show(tl(l)));
  
  proc filter = (proc (int) bool p, list l) list:
     if l is nil then nil
     elif p(hd(l)) then cons(hd(l), filter(p,tl(l)))
     else filter(p, tl(l))
     fi;
  
  proc sieve = (list l) list:
     if l is nil then nil
     else
        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) list: sieve( tl( one to(n) ));
  
  show( primes(100) )
end

Systemy operacyjne napisane w ALGOL 68

  • Komputer Cambridge CAP – Wszystkie procedury wchodzące w skład systemu operacyjnego zostały napisane w ALGOL 68C , chociaż kilka innych ściśle powiązanych procedur chronionych, takich jak paginator, jest napisanych w BCPL .
  • Eldon 3 – Opracowany na Uniwersytecie w Leeds dla ICL 1900 został napisany w ALGOL 68-R .
  • Maszyna Flex – Sprzęt był niestandardowy i mikroprogramowalny, z systemem operacyjnym, (modułowym) kompilatorem, edytorem, odśmiecaczem i systemem plików, wszystko napisane w ALGOL 68RS . Powłoka poleceń Curt została zaprojektowana tak, aby uzyskać dostęp do wpisanych danych, podobnie jak w trybach Algol-68.
  • VMES3 był językiem implementacji systemu operacyjnego VME. S3 został oparty na ALGOL 68, ale z typami danych i operatorami dostosowanymi do tych oferowanych przez ICL 2900 Series .

Uwaga: Komputery z ery radzieckiej Эльбрус-1 (Elbrus-1) i Эльбрус-2 zostały stworzone przy użyciu języka wysokiego poziomu Эль-76 (AL-76), a nie tradycyjnego asemblera. Эль-76 przypomina Algol-68. Główną różnicą są typy dynamicznego wiązania w Эль-76 obsługiwane na poziomie sprzętowym. Эль-76 służy do aplikacji, kontroli zadań, programowania systemu.

Aplikacje

Zarówno ALGOL 68C, jak i ALGOL 68-R są napisane w ALGOL 68, skutecznie czyniąc ALGOL 68 aplikacją samą w sobie. Inne zastosowania obejmują:

Biblioteki i API

Reprezentacja programu

Cechą ALGOL 68, odziedziczoną po tradycji ALGOL , są różne jego reprezentacje. Istnieje język reprezentacji używany do opisu algorytmów w pracach drukowanych, język ścisły (rygorystycznie zdefiniowany w Raporcie) oraz oficjalny język odniesienia przeznaczony do użycia w danych wejściowych kompilatora. Przykłady zawierają pogrubione słowa kroju pisma, jest to ścisły język. Zastrzeżone słowa ALGOL 68 są faktycznie w innej przestrzeni nazw niż identyfikatory, a spacje są dozwolone w identyfikatorach, więc następny fragment jest dozwolony:

 int a real int = 3 ;

Programista piszący kod wykonywalny nie zawsze ma możliwość pogrubienia lub podkreślenia w kodzie, ponieważ może to zależeć od problemów sprzętowych i kulturowych. Opracowano różne metody oznaczania tych identyfikatorów. To się nazywa wyrównywania reżim . Na przykład wszystkie lub niektóre z poniższych mogą być dostępnymi reprezentacjami programistycznymi :

 int a real int = 3; # the strict 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 #

Wszystkie implementacje muszą uwzględniać co najmniej POINT, UPPER i RES wewnątrz sekcji PRAGMAT. Spośród nich ograniczanie POINT i UPPER są dość powszechne, podczas gdy ograniczanie RES jest sprzecznością ze specyfikacją (ponieważ nie ma słów zastrzeżonych). Cytat z pojedynczego apostrofu był pierwotnym zaleceniem, podczas gdy dopasowane cytowanie apostrofu, powszechne w ALGOL 60, nie jest często stosowane w ALGOL 68.

Następujące znaki były zalecane ze względu na przenośność i określane jako „godne znaki” w Raporcie dotyczącym standardowej reprezentacji sprzętowej Algol 68 zarchiwizowanej 2014-01-02 w Wayback Machine :

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

Odzwierciedlało to problem z lat sześćdziesiątych, kiedy niektóre urządzenia nie obsługiwały małych liter, ani niektórych innych znaków spoza ASCII , rzeczywiście w raporcie z 1973 r. napisano: „Cztery wartościowe znaki — „|”, „_”, „[ " i "]" — często są kodowane inaczej, nawet w instalacjach, które nominalnie używają tego samego zestawu znaków."

  • Znaki podstawowe: „Znaki godne” to podzbiór „znaków podstawowych”.

Przykład różnych reprezentacji programu

Reprezentacja Kod
Algol68 „ścisły”
jak zwykle publikowany
¢ podkreślenie lub
   pogrubiony krój pisma ¢
 tryb  xint = int ;
 xint suma sq:=0;
 dla í chwilę
   suma kw≠70×70
 robić
   suma sq+:=i↑2
 od
Obcinanie cytatów
(jak wikitekst )
'pr' quote 'pr'
'mode' 'xint' = 'int';
'xint' sum sq:=0;
'for' i 'while'
  sum sq≠70×70
'do'
  sum sq+:=i↑2
'od'
Dla 7-bitowego kompilatora kodu znaków
.PR UPPER .PR
MODE XINT = INT;
XINT sum sq:=0;
FOR i WHILE
  sum sq/=70*70
DO
  sum sq+:=i**2
OD
Dla 6-bitowego kompilatora kodu znaków
.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
Algol68 użyciu res wyrównywania
(zarezerwowane słowo)
.PR RES .PR
mode .xint = int;
.xint sum sq:=0;
for i while
  sum sq≠70×70
do
  sum sq+:=i↑2
od

ALGOL 68 pozwala każdemu językowi naturalnemu na zdefiniowanie własnego zestawu słów kluczowych Algol-68. Dzięki temu programiści są w stanie pisać programy przy użyciu słów kluczowych z ich ojczystego języka. Poniżej znajduje się przykład prostej procedury obliczającej „następny dzień”, kod jest w dwóch językach: angielskim i niemieckim.

 # Next day date - English variant #
 mode date = struct(int day, string month, int year);
 proc the day following = (date x) date:
      if day of  x < length of month (month of x, year of x)
      then (day of x + 1, month of x, year of x)
      elif month of x = "December"
      then (1, "January", year of x + 1)
      else (1, successor of month (month of x), year of x)
      fi;
 # Nachfolgetag - Deutsche Variante #
 menge datum = tupel(ganz tag, wort 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;

Rosyjski/sowiecki przykład: W języku angielskim instrukcja case Algol68 brzmi case ~ in ~ out ~ esac , w cyrylicy to выб ~ в ~ либо ~ быв .

Niektóre Vanitas

Ze względu na zawiłości techniczne ALGOL 68 potrzebuje obfitości metod, aby zaprzeczyć istnieniu czegoś:

skip, "~" or "?"C – an undefined value always syntactically valid,
empty – the only value admissible to void, needed for selecting void in a union,
void – syntactically like a mode, but not one,
nil or "○" – a name not denoting anything, of an unspecified reference mode,
() or specifically [1:0]int – a vacuum is an empty array (here specifically of mode []int).
undefined – a standards reports procedure raising an exception in the runtime system.
ℵ – Used in the standards report to inhibit introspection of certain types. e.g. sema

por. poniżej dla innych przykładów ℵ.

Termin nil to var zawsze obliczana jako true dla dowolnej zmiennej (ale zobacz powyżej, jak poprawnie użyć is  :/=:), podczas gdy nie wiadomo, do której wartości x < skip zwraca wartość dla dowolnej liczby całkowitej x .

ALGOL 68 celowo pozostawia niezdefiniowane, co dzieje się w przypadku przepełnienia liczb całkowitych, reprezentacji bitowej i stopnia dokładności liczbowej dla liczb zmiennoprzecinkowych. W przeciwieństwie do tego, język Java został skrytykowany za nadmierną specyfikację tego ostatniego.

Oba oficjalne raporty zawierały pewne zaawansowane funkcje, które nie były częścią standardowego języka. Zostały one oznaczone ℵ i uznane za faktycznie prywatne. Przykłady obejmują „≮” i „≯” za wzorcowe, outtype / intype ropy kaczka wpisywanie i straightout i straightin operatorów dla „prostowanie” zagnieżdżonych tablic i struktur.

Wyciąg z raportu z 1973 r.:

§10.3.2.2. Transput modes
a) modesimplout = union (≮ℒ int≯, ≮ℒ real≯, ≮ℒ compl≯, bool, ≮ℒ bits≯,
           char, [ ] char);
b) modeouttype = ¢ 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) modesimplin = union (≮ref ℒ int≯, ≮ref ℒ real≯, ≮refcompl≯, ref bool,
           ≮ref ℒ bits≯, ref char, ref [ ] char, ref string);
d) modeintype = ¢ ... ¢;
 
§10.3.2.3. Straightening
a) opstraightout = (outtype x) [ ] simplout: ¢ the result of "straightening" 'x' ¢;
b) opstraightin = (intype x) [ ] simplin: ¢ the result of straightening 'x' ¢;

Porównania z innymi językami

Rewizje

O ile nie zaznaczono inaczej (z indeksem górnym ), językiem opisanym powyżej jest język „Raportu poprawionego (r1) ”.

Język niezweryfikowanego raportu

Język oryginalny (zgodnie z „Raportem końcowym” r0 ) różni się składnią trybu rzutowania i posiadał cechę proceduralną , czyli wymuszającą wartość terminu na procedurę oceniającą ten termin. Procedury miałyby doprowadzić do lenistwa ocen . Najbardziej użyteczną aplikacją mogłaby być skrócona ocena operatorów logicznych. W:

op andf = (bool a,proc bool b)bool:(a | b | false);
op orf = (bool a,proc bool b)bool:(a | true | b);

b jest oceniane tylko wtedy, gdy a jest prawdziwe.

Zgodnie z definicją w ALGOL 68 nie działała zgodnie z oczekiwaniami, na przykład w kodzie:

if false andf co proc bool: co ( print ("Should not be executed"); true)
then ...

przeciwko programistów naiwnych oczekiwań wydruk będzie realizowane, ponieważ jest to tylko wartość z opracowanego zamkniętym-klauzuli po andf który został procedured. Tekstowe wstawienie zakomentowanego proc bool : sprawia, że ​​działa.

Niektóre implementacje emulują oczekiwane zachowanie w tym szczególnym przypadku przez rozszerzenie języka.

Przed zmianą programista mógł zdecydować, aby argumenty procedury były oceniane seryjnie zamiast pobocznie, używając średników zamiast przecinków ( gomma ).

Na przykład w:

proc test = (real a; real b) :...
...
test (x plus 1, x);

Pierwszy argument do przetestowania na pewno zostanie oceniony przed drugim, ale w zwykły sposób:

proc test = (real a, b) :...
...
test (x plus 1, x);

wtedy kompilator mógł ocenić argumenty w dowolnej kolejności.

Propozycje rozszerzeń od IFIP WG 2.1

Po rewizji raportu zaproponowano pewne rozszerzenia języka w celu poszerzenia zakresu zastosowania:

  • częściowa parametryzacja (aka Currying ): tworzenie funkcji (z mniejszą liczbą parametrów) przez określenie niektórych, ale nie wszystkich parametrów dla wywołania, np. logarytm funkcji dwóch parametrów, podstawy i argumentu, może być specjalizowany do logu naturalnego, binarnego lub dziesiętnego ,
  • rozszerzenie modułu : do obsługi powiązania zewnętrznego zaproponowano dwa mechanizmy, moduły definicji bottom-up , mocniejszą wersję ułatwień z ALGOL 68-R oraz otwory top-down , podobne do klauzul ENVIRONi USINGz ALGOL 68C
  • parametry trybu : do implementacji ograniczonego polimorfizmu parametrycznego (większość operacji na strukturach danych, takich jak listy, drzewa lub inne kontenery danych, można określić bez dotykania ładunku).

Do tej pory zaimplementowano tylko częściową parametryzację w Algolu 68 Genie.

Prawdziwa specyfikacja i harmonogram wdrożenia ALGOL 68s

Nazwa Rok Cel, powód Stan Opis Docelowy procesor Koncesjonowanie Język implementacji
Uogólniony ALGOL 1962 Naukowy Holandia ALGOL dla gramatyk uogólnionych
ALGOL Y Y 1966 Projekt wniosku Międzynarodowy Pierwsza wersja Algola 68 Specyfikacja ACM
ALGOL 68 DR 1968 Projekt wniosku Międzynarodowy Projekt raportu IFIP WG 2.1 Specyfikacja – marzec ACM
ALGOL 68 r0 1968 Standard Międzynarodowy Raport końcowy IFIP WG 2.1 Specyfikacja – sierpień ACM
ALGOL 68-R R 1970 Wojskowy Wielka Brytania MLK 1900 ALGOL 60
EPOS ALGOL E 1971 Naukowy
ALGOL 68RS RS 1972 Wojskowy Wielka Brytania Przenośny system kompilatora ICL 2900/Seria 39, Multics, VMS i generator C (1993) Korona praw autorskich ALGOL 68RS
Algol 68 z obszarami 1972 Eksperymentalne i inne Wielka Brytania Dodanie obszarów do Algolu 68
Mini ALGOL 68 1973 Badania Holandia "Interpreter prostych programów Algol 68" Tłumacz przenośny Centrum Matematyczne ALGOL 60
OREGANO 1973 Badania nas „Znaczenie modeli wdrożeniowych”. UCLA
ALGOL 68C C 1975 Naukowy Wielka Brytania Algol Cambridge 68 ICL , IBM 360, PDP 10 i Unix, Telefunken , Tesla i Z80 (1980) Cambridge ALGOL 68C
ALGOL 68 poprawiony raport r1 1975 Standard Międzynarodowy Poprawiony raport IFIP WG 2.1 Specyfikacja ACM
Algol H H 1975 Eksperymentalne i inne Wielka Brytania Proponowane rozszerzenia systemu trybów Algola 68 Specyfikacja ALGOL W
Algol Odry 68 1976 praktyczne zastosowania ZSRR/Polska Odra 1204/IL radziecki ALGOL 60
Oklahoma ALGOL 68 1976 instrukcja programowania USA Wdrożenie Uniwersytetu Stanowego Oklahoma IBM 1130 i System/370 /158 Nieznany ANSI Fortran 66 .
Berlin ALGOL 68 1977 Badania DE "Wdrożenie Berlin ALGOL 68" & Streszczenie ALGOL 68 Machine – niezależny od maszyny kompilator Politechnika Berlińska CDL 2
FLACC F 1977 Różnego przeznaczenia CA Poprawiony raport o pełnej implementacji z funkcjami debugowania System/370 dzierżawa, Chion Corporation Monter
ALGOL 68-RT RT 1979 Naukowy Wielka Brytania Równoległy ALGOL 68-R
RS Algol rs 1979 Naukowy Wielka Brytania
ALGOL 68+ 1980 Naukowy Holandia Proponowany superjęzyk ALGOL 68
M-220 ALGOL 68 ZSRR M-220 radziecki EPSILON
Leningrad ALGOL 68 L 1980 Telekomunikacja ZSRR Pełny język + moduły IBM, DEC, CAMCOH, PS 1001 i PC radziecki
Interaktywny ALGOL 68 I 1983 Wielka Brytania Kompilacja przyrostowa PC Niekomercyjne oprogramowanie typu shareware
ALGOL 68S S 1985 Naukowy Międzynarodowy Wersja słoneczna ALGOL 68 Sun-3 , Sun SPARC (pod SunOS 4.1 i Solaris 2), Atari ST (pod GEMDOS ), Acorn Archimedes (pod RISC OS ), VAX-11 pod Ultrix-32
Algol68toC (ctrans) 1985 Elektronika Wielka Brytania ctrans od ELLA ALGOL 68RS Przenośny generator C  Oprogramowanie open source 1995 ALGOL 68RS
MK2 Interaktywny ALGOL 68 1992 Wielka Brytania Kompilacja przyrostowa PC Niekomercyjne oprogramowanie typu shareware
Algol 68 Genie G 2001 Pełny język Holandia Zawiera standardową klauzulę zabezpieczenia Tłumacz przenośny GPL C
Algol 68 Genie w wersji 2.0.0 2010 Pełny język Holandia Tłumacz przenośny; opcjonalna kompilacja wybranych jednostek GPL C

Język S3, który został użyty do napisania systemu operacyjnego ICL VME i wielu innych programów systemowych w serii ICL 2900, był bezpośrednią pochodną Algola 68. Pominął jednak wiele bardziej złożonych funkcji i zastąpił podstawowe tryby zestawem typów danych mapowanych bezpośrednio do architektury sprzętowej serii 2900.

Rozszerzenia specyficzne dla wdrożenia

ALGOL 68R (R) firmy RRE był pierwszą implementacją podzbioru ALGOL 68 działającą na ICL 1900 . Bazując na języku oryginalnym, głównymi ograniczeniami podzbioru były definicje przed użyciem i brak przetwarzania równoległego. Ten kompilator był popularny na brytyjskich uniwersytetach w latach 70., gdzie wielu studentów informatyki nauczyło się ALGOL 68 jako pierwszego języka programowania; kompilator był znany z dobrych komunikatów o błędach.

ALGOL 68RS (RS) firmy RSRE był przenośnym systemem kompilatora napisanym w ALGOL 68RS (bootstrapped z ALGOL 68R) i zaimplementowany w różnych systemach, w tym ICL 2900 / Series 39 , Multics i DEC VAX/VMS . Język został oparty na poprawionym raporcie, ale z podobnymi ograniczeniami podzbioru do ALGOL 68R. Ten kompilator przetrwa w postaci kompilatora Algol68-to-C.

W ALGOL 68S (S) z Carnegie Mellon University moc przetwarzania równoległego została poprawiona poprzez dodanie ortogonalnego rozszerzenia, Eventing . Każda deklaracja zmiennej zawierająca słowo kluczowe zdarzenie dokonywała przyporządkowania do tej zmiennej kwalifikującej się do oceny równoległej, tzn. prawa strona została przeniesiona do procedury, która została przeniesiona do jednego z procesorów systemu wieloprocesorowego C.mmp . Dostęp do takich zmiennych był opóźniony po zakończeniu zadania.

Cambridge ALGOL 68C (C) był przenośnym kompilatorem, który zaimplementował podzbiór ALGOL 68, ograniczając definicje operatorów i pomijając zbieranie śmieci, elastyczne wiersze i sformatowaną transmisję.

Algol 68 Genie (G) autorstwa M. van der Veer to implementacja ALGOL 68 dla współczesnych komputerów i systemów operacyjnych.

„Mimo dobrych intencji programista może naruszyć przenośność, nieumyślnie stosując lokalne rozszerzenie. Aby temu zapobiec, każda implementacja powinna zapewniać opcję pragmatu PORTCHECK. Gdy ta opcja obowiązuje, kompilator drukuje komunikat dla każdej konstrukcji, którą rozpoznaje jako narusza niektóre ograniczenia dotyczące przenośności”.

cytaty

  • ... Przyjęty przez C schemat składu krojów ma znaczny dług wobec Algola 68, choć być może nie wyłonił się on w formie, którą zaakceptowaliby zwolennicy Algola. Centralnym pojęciem, które przechwyciłem z Algola, była struktura typów oparta na typach atomowych (w tym strukturach), złożona w tablice, wskaźniki (referencje) i funkcje (procedury). Koncepcja związków i odlewów Algola 68 miała również wpływ, który pojawił się później. Dennis Ritchie, kwiecień 1993.
  • ... C nie wywodzi się z Algolu 68, to prawda, ale był wpływ, w większości tak subtelny, że trudno go odzyskać, nawet jeśli ciężko myślę. W szczególności typ unii (późny dodatek do C) zawdzięcza A68 nie w szczegółach, ale w idei posiadania takiego typu w ogóle. Głębiej, struktura typów w ogóle, a nawet, w jakiś dziwny sposób, składnia deklaracji (część konstruktora typu) została zainspirowana przez A68. I tak, oczywiście „długi”. Dennis Ritchie , 18 czerwca 1988
  • „Gratulacje, twój Mistrz to zrobił” – Niklaus Wirth
  • Im więcej tego widzę, tym bardziej jestem nieszczęśliwy – EW Dijkstra, 1968
  • [...] mówiono, że popularność A68 była odwrotnie proporcjonalna do [...] odległości od AmsterdamuGuido van Rossum
  • [...] Najlepsze, co mogliśmy zrobić, to wysłać wraz z nim raport mniejszości, w którym wyrażamy nasz przemyślany pogląd, że „… jako narzędzie niezawodnego tworzenia wyrafinowanych programów język okazał się porażką”. [...]CAR Hoare w swoim wykładzie o nagrodzie Turinga w październiku 1980
  • „[...] Bardziej niż kiedykolwiek od odpowiedniego narzędzia programistycznego będzie się wymagać, aby strukturalnie wspomagało programistę w najtrudniejszych aspektach jego pracy, a mianowicie w niezawodnym tworzeniu wyrafinowanych programów. nie dostrzegają, jak język proponowany tutaj jest znaczącym krokiem naprzód: wręcz przeciwnie, uważamy, że jego ukryty pogląd na zadanie programisty jest bardzo podobny do, powiedzmy, dziesięć lat temu. jako narzędzie programowania język należy uznać za przestarzały. [...]” Raport grupy roboczej z 1968 r. z dnia 23 grudnia 1968 r.

Zobacz też

Bibliografia

Cytaty

Prace cytowane

  • Brailsford, DF i Walker, AN, Wstępne programowanie ALGOL 68 , Ellis Horwood/Wiley, 1979
  • Lindsey, CH i van der Meulen, SG, Nieformalne wprowadzenie do ALGOL 68 , Północna Holandia, 1971
  • Lindsey, CH (1993-03-02). „Historia ALGOL 68”. ACM SIGPLAN Uwagi . 28 (3): 97–132. doi : 10.1145/155360.155365 .
  • McGettrick, AD, ALGOL 68, Pierwszy i Drugi Kurs , Cambridge Univ. Prasa, 1978
  • Peck, JEL, towarzysz ALGOL 68 , Univ. Kolumbii Brytyjskiej, październik 1971
  • Tanenbaum, AS, A Tutorial on ALGOL 68 , Computing Surveys 8 , 155-190, czerwiec 1976 i 9 , 255-256, wrzesień 1977, [9]
  • Woodward, PM and Bond, SG, ALGOL 68-R Users sic Guide , Londyn, Her Majesty's Stationery Office, 1972

Zewnętrzne linki