Category:ALGOL 68: Difference between revisions
No edit summary |
(→Coding style of samples: tweak) |
||
(58 intermediate revisions by 5 users not shown) | |||
Line 1: | Line 1: | ||
[[File:Algol68.png|64px|left|alt=Language|link=http://sourceforge.net/projects/algol68]] |
|||
{{language|ALGOL 68 |
{{language|ALGOL 68 |
||
|parampass=both |
|parampass=both |
||
|strength= |
|strength=strong |
||
|safety=safe |
|safety=safe |
||
|express=explicit |
|express=explicit |
||
|compat=structural |
|compat=structural |
||
|checking=both |
|checking=both |
||
|tags=algol68 |
|||
|LCT=yes}}ALGOL 68 (short for ALGOrithmic Language 1968) is an [[imperative programming|imperative]] computer programming language that was conceived as a successor to the ALGOL 60 programming language, designed with the goal of a much wider scope of application and more rigorously defined syntax and semantics. |
|||
|LCT=yes}} |
|||
ALGOL 68 (short for ALGOrithmic Language 1968) is an [[imperative programming|imperative]] computer programming language that was conceived as a successor to the ALGOL 60 programming language, designed with the goal of a much wider scope of application and more rigorously defined syntax and semantics. |
|||
The main aims and principles of design of ALGOL 68: |
The main aims and principles of design of ALGOL 68: |
||
Line 18: | Line 21: | ||
#* Loop optimization, |
#* Loop optimization, |
||
#* Representations - in minimal & larger character sets. |
#* Representations - in minimal & larger character sets. |
||
<br><br> |
|||
==Execute an ALGOL 68 program online== |
|||
* http://www.compileonline.com/execute_algol_online.php |
|||
* Algol 68G is available as one of the languages at https://tio.run |
|||
==Tasks not implemented in ALGOL 68== |
|||
[[Tasks not implemented in ALGOL 68]] |
|||
==Grammar== |
|||
The formal definition of Algol 68 is given by a "Two-Level" or [[wp:Van Wijngaarden grammar|"Van Wijngaarden" grammar]]. |
|||
This specifies much more than "just" the syntax and includes such semantic details as the requirement of identifiers to be declared, the necessary type checking and coercions to be applied, etc. The degree of precision allowed by the grammar came at the cost of increased complexity relative to Backus Naur Form, which was used to define [[ALGOL 60]]. It is recomended that less formal material (such as the books mentioned under "Resources" below) be consulted before delving into the Revised Report. |
|||
<br> |
|||
<br> |
|||
A syntax chart is available [http://www.softwarepreservation.org/projects/ALGOL/book/Lindsey_van_der_Meulen-IItA68-Revised-SyntaxOnly.pdf/view here] |
|||
==Resources== |
==Resources== |
||
* ALGOL BULLETIN - March 1959 to August 1988, in 52 issues |
* [http://archive.computerhistory.org/resources/text/algol/algol_bulletin ALGOL BULLETIN] - March 1959 to August 1988, in 52 issues |
||
* Algol68 mailinglist - December 2008 - algol68-user AT lists.sourceforge.net |
* [https://lists.sourceforge.net/lists/listinfo/algol68-user Algol68 mailinglist] - December 2008 - algol68-user AT lists.sourceforge.net |
||
* [http://www.linkedin.com/groups/Algol68-2333923 Algol68 group at linkedin] - includes various famous compiler composers. |
|||
<br> |
|||
'''Books available online''': |
|||
* [http://jmvdveer.home.xs4all.nl/en.algol-68-genie.html Algol 68G Manual - By Marcel van der Veer] Includes the Revised Report |
|||
* [http://www.softwarepreservation.org/projects/ALGOL/book/pame.2008.a4.pdf/view Programming Algol 68 Made Easy - by Sian Mountbatten (on softwarepreservation.org)] |
|||
* [http://www.softwarepreservation.org/projects/ALGOL/book/Lindsey_van_der_Meulen-IItA68-Revised.pdf/view Informal Introduction to Algol 68 - by C. H. Lindsey & S. V. Van der Meulen (on softwarepreservation.org)] - if you prefer (and find) a hardcopy, be sure to get the 1977 edition. Highly recomended! |
|||
<br> |
|||
'''Editor modes''': |
|||
* [http://www.jemarch.net/a68-mode.el Emacs mode] for Algol 68 supporting syntax highlighting and context-sensitive indentation. |
|||
* [http://www.vim.org/scripts/script.php?script_id=1927 Vim script] providing support for syntax highlighting. |
|||
* [http://qbnz.com/highlighter/demo.php GeSHi syntax highlighting] |
|||
* [https://marketplace.visualstudio.com/items?itemName=jlguenego.algol68 VS-Code Algol 68 syntax highlighting] |
|||
==Status== |
==Status== |
||
* 20th December 1968 - '''ALGOL 68's''' Final Report was ratified by [http://en.wikipedia.org/wiki/UNESCO UNESCO's] [http://en.wikipedia.org/wiki/IFIP IFIP] working group 2.1 in Munich. |
* 20th December 1968 - '''ALGOL 68's''' Final Report was ratified by [http://en.wikipedia.org/wiki/UNESCO UNESCO's] [http://en.wikipedia.org/wiki/IFIP IFIP] working group 2.1 in Munich. |
||
Line 30: | Line 61: | ||
* 20th December 2009 - Happy 51st/41st Birthdays with [[Hamming_numbers#ALGOL_68|Hamming numbers]] - the 200th '''ALGOL 68''' code contribution on rosettacode.org! |
* 20th December 2009 - Happy 51st/41st Birthdays with [[Hamming_numbers#ALGOL_68|Hamming numbers]] - the 200th '''ALGOL 68''' code contribution on rosettacode.org! |
||
** This time code was by [[User:Algol68g|Marcel van der Veer]], author of [http://www.xs4all.nl/~jmvdveer/algol.html Algol 68 Genie] |
** This time code was by [[User:Algol68g|Marcel van der Veer]], author of [http://www.xs4all.nl/~jmvdveer/algol.html Algol 68 Genie] |
||
* 25th October 2011 - [[User:Jejones3141|Jejones3141]] added [[Soundex#ALGOL_68|Soundex]] - the 300th '''ALGOL 68''' code specimen. |
|||
== Revisions == |
== Revisions == |
||
Line 36: | Line 68: | ||
*Dec. 1968: Report on the Algorithmic Language ALGOL 68 - Offprint from Numerische Mathematik, 14, 79-218 (1969); Springer-Verlag. - Edited by: A. van Wijngaarden, B.J. Mailloux, J.E.L. Peck and C.H.A. Koster. |
*Dec. 1968: Report on the Algorithmic Language ALGOL 68 - Offprint from Numerische Mathematik, 14, 79-218 (1969); Springer-Verlag. - Edited by: A. van Wijngaarden, B.J. Mailloux, J.E.L. Peck and C.H.A. Koster. |
||
*Sep 1973: Revised Report on the Algorithmic Language Algol 68 - Springer-Verlag 1976 - Edited by: A. van Wijngaarden, B.J. Mailloux, J.E.L. Peck, C.H.A. Koster, M. Sintzoff, C.H. Lindsey, L.G.L.T. Meertens and R.G. Fisker. |
*Sep 1973: Revised Report on the Algorithmic Language Algol 68 - Springer-Verlag 1976 - Edited by: A. van Wijngaarden, B.J. Mailloux, J.E.L. Peck, C.H.A. Koster, M. Sintzoff, C.H. Lindsey, L.G.L.T. Meertens and R.G. Fisker. |
||
== |
==Coding style of samples, alphabets and stropping== |
||
Click "Expand" for more details. |
|||
Most of the code samples provided here have a leading <code>main:(</code> and a matching <code>)</code> at the end. These are not actually required in the language, but are included so as to highlight that the code sample is complete, and works with (at least) [[ALGOL 68G]] unmodified. |
|||
<div class="mw-collapsible mw-collapsed" style="width:880px; overflow:auto; background-color:parent;"> |
|||
<div class="mw-collapsible-content" style="padding-left:2em;"> |
|||
Many of the code samples provided here have a leading <code>main:(</code> and a matching <code>)</code> at the end. These are not actually required in the language, but are included so as to highlight the main routine. |
|||
On some compilers, it may be necessary to include appropriate "job cards" |
On some compilers, it may be necessary to include appropriate "job cards" |
||
or |
or preludes in order for the programs to compile successfully. Hopefully |
||
not too much else is required. Examples: |
not too much else is required. Examples: |
||
{|border="1" style="border-collapse: collapse; border: 5px double grey;" align="center" |
{|border="1" style="border-collapse: collapse; border: 5px double grey;" align="center" |
||
Line 61: | Line 97: | ||
FINISH |
FINISH |
||
|} |
|} |
||
<br><br>'''Alphabets''' |
|||
===Example of different program representations=== |
|||
<br><br> |
|||
Notionally, Algol 68 source is written in two alphabets. The reserved words, mode indicants (type names) and operators that are non-symbolic (.e.g. '''and''', '''or''', ...) are generally referred to as "bold words" and usually shown in a bold font in literature. Words that are identifiers (used for "variable" names, procedure names, structure member names, ...) are in a separate, non-bold font.<br> |
|||
The [https://www.softwarepreservation.org/projects/ALGOL/manual/a68s.txt/view Manual for CMU ALGOL 68S (on softwarepreservation.org)] refers to the non-bold words as being in timid face. |
|||
<br><br>'''Examples of different program representations''' |
|||
<br><br> |
|||
At the time when ALGOL 68 was defined some predominant computers had |
At the time when ALGOL 68 was defined some predominant computers had |
||
36 bit words, |
24 or 36 bit words, with 6 bit character sets. Hence it was desirable that |
||
ALGOL 68 should be able to run on machines with only uppercase. |
ALGOL 68 should be able to run on machines with only uppercase. |
||
As multiple fonts were generally unavailable, a method of identifying the bold words was required.<br> |
|||
the official spec provided for different representations of the same |
|||
The official spec provided for different representations of the same |
|||
program. Example: |
|||
program. |
|||
{|border="1" style="border-collapse: collapse; border: 5px double grey;" align="center" |
|||
Quote stropping (enclosing the bold words in single quotes) |
|||
and Point stropping (preceeding the bold words with a dot) |
|||
were used.<br> |
|||
A variant of Point stropping called RES stropping was also defined. |
|||
In RES stropping some language-defined bold words are not preceded by a dot.<br> |
|||
A pragmatic comment may have been required to indicate which |
|||
stropping convention was to be used, as in some of the examples below.<br> |
|||
Upper stropping (representing the bold words by upper case and |
|||
non-bold words in lower case) was introduced by Algol 68R.<br> |
|||
Upper stropping is used by Algol 68RS and is one of the options for Algol 68G.<br> |
|||
Rutgers ALGOL 68 uses quote stropping.<br> |
|||
Most of the samples on Rosetta Code use Upper stropping.<br><br> |
|||
Examples (pragmatic comments to set the stropping regime not shown): |
|||
{|border="1" style="border-collapse: collapse; border: 2px double grey;" align="left" |
|||
|| Algol68 as typically published |
|| Algol68 as typically published |
||
¢ bold/underline typeface ¢ |
|||
'''mode''' '''xint''' = '''int'''; |
'''mode''' '''xint''' = '''int'''; |
||
'''xint''' sum sq:=0; |
'''xint''' sum sq:=0; |
||
Line 77: | Line 131: | ||
sum sq+:=i↑2 |
sum sq+:=i↑2 |
||
'''od''' |
'''od''' |
||
|| |
|| QUOTE stropping (similar to wiki) |
||
'pr' quote 'pr' |
|||
'mode' 'xint' = 'int'; |
'mode' 'xint' = 'int'; |
||
'xint' sum sq:=0; |
'xint' sum sq:=0; |
||
Line 86: | Line 139: | ||
sum sq+:=i↑2 |
sum sq+:=i↑2 |
||
'od' |
'od' |
||
|| POINT stropping |
|||
|| Code for a 7-bit/ascii compiler |
|||
.PR UPPER .PR |
|||
MODE XINT = INT; |
|||
XINT sum sq:=0; |
|||
FOR i WHILE |
|||
sum sq/=70*70 |
|||
DO |
|||
sum sq+:=i**2 |
|||
OD |
|||
|| Code for a 6-bits/byte compiler |
|||
.PR POINT .PR |
|||
.MODE .XINT = .INT; |
.MODE .XINT = .INT; |
||
.XINT SUM SQ:=0; |
.XINT SUM SQ:=0; |
||
Line 104: | Line 147: | ||
SUM SQ .PLUSAB I .UP 2 |
SUM SQ .PLUSAB I .UP 2 |
||
.OD |
.OD |
||
|| |
|| RES stropping |
||
.PR RES .PR |
|||
mode .xint = int; |
mode .xint = int; |
||
.xint sum sq:=0; |
.xint sum sq:=0; |
||
Line 113: | Line 155: | ||
sum sq+:=i↑2 |
sum sq+:=i↑2 |
||
od |
od |
||
|| Upper stropping |
|||
MODE XINT = INT; |
|||
XINT sum sq:=0; |
|||
FOR i WHILE |
|||
sum sq /= 70*70 |
|||
DO |
|||
sum sq PLUSAB i UP 2 |
|||
OD |
|||
|} |
|} |
||
</div></div> |
|||
== Coercion (casting) == |
== Coercion (casting) == |
||
ALGOL 68 has a hierarchy of contexts which determine which kind of |
ALGOL 68 has a hierarchy of contexts which determine which kind of coercions are available at a particular point in the program. |
||
<br> |
|||
coercions are available at a particular point in the program. These contexts are: |
|||
Click "Expand" for more details. |
|||
* soft - deproceduring |
|||
<div class="mw-collapsible mw-collapsed" style="width:880px; overflow:auto; background-color:parent;"> |
|||
* weak - dereferencing or deproceduring, yielding a name |
|||
<div class="mw-collapsible-content" style="padding-left:2em;"> |
|||
* meek - dereferencing or deproceduring |
|||
* firm - meek, followed by uniting |
|||
These contexts are: |
|||
* strong - firm, followed by widening, rowing or voiding |
|||
{|class="wikitable" |
|||
!rowspan=2| N<br> |
|||
a<br> |
|||
m<br> |
|||
e |
|||
!rowspan=2| Context location |
|||
!colspan=5| Coercions available in this context |
|||
!rowspan=2| Coercion examples |
|||
|- |
|||
|bgcolor=aaaaff|Soft |
|||
|bgcolor=aaeeaa|Weak |
|||
|bgcolor=ffee99|Meek |
|||
|bgcolor=ffcc99|Firm |
|||
|bgcolor=ffcccc|Strong |
|||
|- |
|||
!S<br> |
|||
t<br> |
|||
r<br> |
|||
o<br> |
|||
n<br> |
|||
g |
|||
||Right hand side of: |
|||
* Identity-declarations, as "~" in: <syntaxhighlight algol68>REAL x = ~</syntaxhighlight> |
|||
* Initialisations, as "~" in: <syntaxhighlight algol68>REAL x := ~</syntaxhighlight> |
|||
Also: |
|||
* Actual-parameters of calls, as "~" in:<syntaxhighlight algol68>PROC: sin(~)</syntaxhighlight> |
|||
* Enclosed clauses of casts, as "~" in: <syntaxhighlight algol68>REAL(~)</syntaxhighlight> |
|||
* Units of routine-texts |
|||
* Statements yielding VOID |
|||
* All parts (but one) of a balanced clause |
|||
* One side of an identity relation, as "~" in: <syntaxhighlight algol68> ~ IS ~</syntaxhighlight> |
|||
|bgcolor=aaaaff rowspan=4 width="50px"| deproc- eduring |
|||
|bgcolor=aaeeaa rowspan=3 width="50px"| all '''soft''' then weak deref- erencing |
|||
|bgcolor=ffee99 rowspan=2 width="50px"| all '''weak''' then deref- erencing |
|||
|bgcolor=ffcc99 rowspan=1 width="50px"| all '''meek''' then uniting |
|||
|bgcolor=ffcccc width="50px"| all '''firm''' then widening, rowing and voiding |
|||
|colspan=1 bgcolor=ffcccc| |
|||
Widening occurs if there is no loss of precision. For example: An INT will be coerced to a REAL, and a REAL will be coerced to a LONG REAL. But not vice-versa. Examples: |
|||
<syntaxhighlight algol68>INT to LONG INT |
|||
INT to REAL |
|||
REAL to COMPL |
|||
BITS to []BOOL |
|||
BYTES to STRING</syntaxhighlight> |
|||
A variable can also be coerced (rowed) to an array of length 1. |
|||
For example: |
|||
<syntaxhighlight algol68>INT to [1]INT |
|||
REAL to [1]REAL</syntaxhighlight> etc |
|||
|- |
|||
!F<br> |
|||
i<br> |
|||
r<br> |
|||
m |
|||
|| |
|||
*Operands of formulas as "~" in:<syntaxhighlight algol68>OP: ~ * ~</syntaxhighlight> |
|||
*Parameters of transput calls |
|||
|colspan=3 bgcolor=ffcc99| Example: |
|||
<syntaxhighlight algol68>UNION(INT,REAL) var := 1</syntaxhighlight> |
|||
|- |
|||
!M<br> |
|||
e<br> |
|||
e<br> |
|||
k |
|||
|| |
|||
* Trimscripts (yielding INT) |
|||
* Enquiries: e.g. as "~" in the following |
|||
<syntaxhighlight algol68>IF ~ THEN ... FI</syntaxhighlight> and |
|||
<syntaxhighlight algol68>FROM ~ BY ~ TO ~ WHILE ~ DO ... OD etc</syntaxhighlight> |
|||
* Primaries of calls (e.g. sin in sin(x)) |
|||
|colspan=4 bgcolor=ffee99|Examples: |
|||
<syntaxhighlight algol68>REF REF BOOL to BOOL |
|||
REF REF REF INT to INT</syntaxhighlight> |
|||
|- |
|||
!W<br> |
|||
e<br> |
|||
a<br> |
|||
k |
|||
|| |
|||
* Primaries of slices, as in "~" in: <syntaxhighlight algol68>~[1:99]</syntaxhighlight> |
|||
* Secondaries of selections, as "~" in: <syntaxhighlight algol68>value OF ~</syntaxhighlight> |
|||
|colspan=5 bgcolor=aaeeaa|Examples: |
|||
<syntaxhighlight algol68>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</syntaxhighlight> |
|||
|- |
|||
!S<br> |
|||
o<br> |
|||
f<br> |
|||
t |
|||
|| The LHS of assignments, as "~" in: <syntaxhighlight algol68>~ := ...</syntaxhighlight> |
|||
|colspan=6 bgcolor=aaaaff| Example: |
|||
* deproceduring of: <syntaxhighlight algol68>PROC REAL random: e.g. random</syntaxhighlight> |
|||
|} |
|||
For more details about Primaries and Secondaries refer to [[Operator_precedence#ALGOL_68|Operator precedence]]. |
|||
</div></div> |
|||
==See also== |
|||
*[[Web 68]] |
|||
*[[ALGOL 60]] |
|||
*[[ALGOL W]] |
|||
<br> |
|||
* [[Action!]] |
|||
* [[Agena]] |
|||
* [[Draco]] |
|||
* [https://en.wikipedia.org/wiki/S3_(programming_language) S3 for ICL 2900] |
|||
== Library code used in Rosetta Code samples == |
|||
[https://rosettacode.org/wiki/ALGOL_68/prelude Various (including the standard prelude)]<br/> |
|||
[https://rosettacode.org/wiki/Category:ALGOL_68-primes Prime related]<br/> |
|||
[https://rosettacode.org/wiki/Category:ALGOL_68-rows Row (array) related]<br/> |
|||
[https://rosettacode.org/wiki/Category:ALGOL_68-l-system L-System related] |
|||
== Tools == |
|||
Depending on the context a MODE (type) will be coerced (widened) to another type if there is no loss |
|||
[[Syntax_highlighting_using_Mediawiki_formatting#ALGOL 68|Format an upper-stropped Algol 68 source with Mediawiki markup]]<br/> |
|||
of precision. For example: An INT will be coerced to a REAL, and a REAL will be |
|||
[[Compiler/Simple_file_inclusion_pre_processor#ALGOL 68|Implement ''read'' and ''include'' pragmatic-comments for compilers that don't support file inclusion]] |
|||
coerced to a LONG REAL. But not vice-versa. Examples: |
|||
* INT to REAL |
|||
* REAL to COMPL |
|||
* BITS to []BOOL |
|||
* BYTES to STRING |
|||
A variable can also be coerced (rowed) to an array of length 1. For example: |
|||
* INT to [1]INT |
|||
* REAL to [1]REAL etc |
|||
Pointers are followed (dereferenced), For example: |
|||
* REF REF REAL to REAL |
|||
{{language programming paradigm|Concurrent}} |
{{language programming paradigm|Concurrent}} |
Latest revision as of 20:49, 20 April 2024
This programming language may be used to instruct a computer to perform a task.
Parameter passing methods: | By reference, By value |
---|---|
Type safety: | Safe |
Type strength: | Strong |
Type compatibility: | Structural |
Type expression: | Explicit |
Type checking: | Dynamic, Static |
Lang tag(s): | algol68 |
See Also: |
ALGOL 68 (short for ALGOrithmic Language 1968) is an imperative computer programming language that was conceived as a successor to the ALGOL 60 programming language, designed with the goal of a much wider scope of application and more rigorously defined syntax and semantics.
The main aims and principles of design of ALGOL 68:
- Completeness and clarity of design,
- Orthogonal design,
- Security,
- Efficiency:
- Static mode checking,
- Mode-independent parsing,
- Independent compilation,
- Loop optimization,
- Representations - in minimal & larger character sets.
Execute an ALGOL 68 program online
- http://www.compileonline.com/execute_algol_online.php
- Algol 68G is available as one of the languages at https://tio.run
Tasks not implemented in ALGOL 68
Tasks not implemented in ALGOL 68
Grammar
The formal definition of Algol 68 is given by a "Two-Level" or "Van Wijngaarden" grammar.
This specifies much more than "just" the syntax and includes such semantic details as the requirement of identifiers to be declared, the necessary type checking and coercions to be applied, etc. The degree of precision allowed by the grammar came at the cost of increased complexity relative to Backus Naur Form, which was used to define ALGOL 60. It is recomended that less formal material (such as the books mentioned under "Resources" below) be consulted before delving into the Revised Report.
A syntax chart is available here
Resources
- ALGOL BULLETIN - March 1959 to August 1988, in 52 issues
- Algol68 mailinglist - December 2008 - algol68-user AT lists.sourceforge.net
- Algol68 group at linkedin - includes various famous compiler composers.
Books available online:
- Algol 68G Manual - By Marcel van der Veer Includes the Revised Report
- Programming Algol 68 Made Easy - by Sian Mountbatten (on softwarepreservation.org)
- Informal Introduction to Algol 68 - by C. H. Lindsey & S. V. Van der Meulen (on softwarepreservation.org) - if you prefer (and find) a hardcopy, be sure to get the 1977 edition. Highly recomended!
Editor modes:
- Emacs mode for Algol 68 supporting syntax highlighting and context-sensitive indentation.
- Vim script providing support for syntax highlighting.
- GeSHi syntax highlighting
- VS-Code Algol 68 syntax highlighting
Status
- 20th December 1968 - ALGOL 68's Final Report was ratified by UNESCO's IFIP working group 2.1 in Munich.
- 20th December 2008 - Zig Zag - the 100th ALGOL 68 code contribution on rosettacode.org!
- Happy 40th Birthday ALGOL 68,
- AND 50th Birthday ALGOL 58.
- 23rd August 2009 - algol68g-1.18.0-9h released
- 20th December 2009 - Happy 51st/41st Birthdays with Hamming numbers - the 200th ALGOL 68 code contribution on rosettacode.org!
- This time code was by Marcel van der Veer, author of Algol 68 Genie
- 25th October 2011 - Jejones3141 added Soundex - the 300th ALGOL 68 code specimen.
Revisions
- Mar. 1968: Draft Report on the Algorithmic Language ALGOL 68 - Edited by: A. van Wijngaarden, B.J. Mailloux, J.E.L. Peck and C.H.A. Koster.
- Oct. 1968: Penultimate Draft Report on the Algorithmic Language ALGOL 68 - Chapters 1-9 - Edited by: A. van Wijngaarden, B.J. Mailloux, J.E.L. Peck and C.H.A. Koster.
- Dec. 1968: Report on the Algorithmic Language ALGOL 68 - Offprint from Numerische Mathematik, 14, 79-218 (1969); Springer-Verlag. - Edited by: A. van Wijngaarden, B.J. Mailloux, J.E.L. Peck and C.H.A. Koster.
- Sep 1973: Revised Report on the Algorithmic Language Algol 68 - Springer-Verlag 1976 - Edited by: A. van Wijngaarden, B.J. Mailloux, J.E.L. Peck, C.H.A. Koster, M. Sintzoff, C.H. Lindsey, L.G.L.T. Meertens and R.G. Fisker.
Coding style of samples, alphabets and stropping
Click "Expand" for more details.
Many of the code samples provided here have a leading main:(
and a matching )
at the end. These are not actually required in the language, but are included so as to highlight the main routine.
On some compilers, it may be necessary to include appropriate "job cards" or preludes in order for the programs to compile successfully. Hopefully not too much else is required. Examples:
Brief Algol68 | Algol68 as in rosettacode | Actual ELLA Algol 68RS code |
print(("Hello, world!",new line)) |
main:( print(("Hello, world!",new line)) ) |
PROGRAM helloworld CONTEXT VOID USE standard BEGIN print(("Hello, world!", new line)) END FINISH |
Alphabets
Notionally, Algol 68 source is written in two alphabets. The reserved words, mode indicants (type names) and operators that are non-symbolic (.e.g. and, or, ...) are generally referred to as "bold words" and usually shown in a bold font in literature. Words that are identifiers (used for "variable" names, procedure names, structure member names, ...) are in a separate, non-bold font.
The Manual for CMU ALGOL 68S (on softwarepreservation.org) refers to the non-bold words as being in timid face.
Examples of different program representations
At the time when ALGOL 68 was defined some predominant computers had
24 or 36 bit words, with 6 bit character sets. Hence it was desirable that
ALGOL 68 should be able to run on machines with only uppercase.
As multiple fonts were generally unavailable, a method of identifying the bold words was required.
The official spec provided for different representations of the same
program.
Quote stropping (enclosing the bold words in single quotes)
and Point stropping (preceeding the bold words with a dot)
were used.
A variant of Point stropping called RES stropping was also defined.
In RES stropping some language-defined bold words are not preceded by a dot.
A pragmatic comment may have been required to indicate which
stropping convention was to be used, as in some of the examples below.
Upper stropping (representing the bold words by upper case and
non-bold words in lower case) was introduced by Algol 68R.
Upper stropping is used by Algol 68RS and is one of the options for Algol 68G.
Rutgers ALGOL 68 uses quote stropping.
Most of the samples on Rosetta Code use Upper stropping.
Examples (pragmatic comments to set the stropping regime not shown):
Algol68 as typically published
mode xint = int; xint sum sq:=0; for i while sum sq≠70×70 do sum sq+:=i↑2 od |
QUOTE stropping (similar to wiki)
'mode' 'xint' = 'int'; 'xint' sum sq:=0; 'for' i 'while' sum sq≠70×70 'do' sum sq+:=i↑2 'od' |
POINT stropping
.MODE .XINT = .INT; .XINT SUM SQ:=0; .FOR I .WHILE SUM SQ .NE 70*70 .DO SUM SQ .PLUSAB I .UP 2 .OD |
RES stropping
mode .xint = int; .xint sum sq:=0; for i while sum sq≠70×70 do sum sq+:=i↑2 od |
Upper stropping
MODE XINT = INT; XINT sum sq:=0; FOR i WHILE sum sq /= 70*70 DO sum sq PLUSAB i UP 2 OD |
Coercion (casting)
ALGOL 68 has a hierarchy of contexts which determine which kind of coercions are available at a particular point in the program.
Click "Expand" for more details.
These contexts are:
N a |
Context location | Coercions available in this context | Coercion examples | ||||
---|---|---|---|---|---|---|---|
Soft | Weak | Meek | Firm | Strong | |||
S t |
Right hand side of:
Also:
|
deproc- eduring | all soft then weak deref- erencing | all weak then deref- erencing | all meek then uniting | all firm then widening, rowing and voiding |
Widening occurs if there is no loss of precision. For example: An INT will be coerced to a REAL, and a REAL will be coerced to a LONG REAL. But not vice-versa. Examples: INT to LONG INT
INT to REAL
REAL to COMPL
BITS to []BOOL
BYTES to STRING A variable can also be coerced (rowed) to an array of length 1. For example: INT to [1]INT
REAL to [1]REAL |
F i |
|
Example:
UNION(INT,REAL) var := 1 | |||||
M e |
IF ~ THEN ... FI FROM ~ BY ~ TO ~ WHILE ~ DO ... OD etc
|
Examples:
REF REF BOOL to BOOL
REF REF REF INT to INT | |||||
W e |
|
Examples:
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 | |||||
S o |
The LHS of assignments, as "~" in: ~ := ... |
Example:
|
For more details about Primaries and Secondaries refer to Operator precedence.
See also
Library code used in Rosetta Code samples
Various (including the standard prelude)
Prime related
Row (array) related
L-System related
Tools
Format an upper-stropped Algol 68 source with Mediawiki markup
Implement read and include pragmatic-comments for compilers that don't support file inclusion
Subcategories
This category has the following 3 subcategories, out of 3 total.
@
- ALGOL 68 Implementations (9 P)
- ALGOL 68 User (8 P)
Pages in category "ALGOL 68"
The following 200 pages are in this category, out of 1,018 total.
(previous page) (next page)A
- A+B
- Abbreviations, easy
- Abbreviations, simple
- ABC problem
- ABC words
- Abelian sandpile model
- Abelian sandpile model/Identity
- Abundant odd numbers
- Abundant, deficient and perfect number classifications
- Accumulator factory
- Achilles numbers
- Ackermann function
- Additive primes
- Address of a variable
- AKS test for primes
- Align columns
- Aliquot sequence classifications
- Almkvist-Giullera formula for pi
- Almost prime
- Alternade words
- Amb
- Amicable pairs
- Anadromes
- Anagrams
- Anagrams/Deranged anagrams
- Anaprimes
- Angle difference between two bearings
- Angles (geometric), normalization and conversion
- Anonymous recursion
- Anti-primes
- Append numbers at same position in strings
- Apply a callback to an array
- Apply a digital filter (direct form II transposed)
- Approximate equality
- Apéry's constant
- Arbitrary-precision integers (included)
- Arithmetic derivative
- Arithmetic evaluation
- Arithmetic numbers
- Arithmetic-geometric mean
- Arithmetic/Complex
- Arithmetic/Integer
- Arithmetic/Rational
- Array concatenation
- Array length
- Arrays
- Ascending primes
- ASCII control characters
- Assertions
- Associative array/Creation
- Associative array/Iteration
- Associative array/Merging
- Attractive numbers
- Averages/Arithmetic mean
- Averages/Mean angle
- Averages/Mean time of day
- Averages/Median
- Averages/Mode
- Averages/Pythagorean means
- Averages/Root mean square
- Averages/Simple moving average
B
- B-spline
- Babbage problem
- Bacon cipher
- Balanced brackets
- Balanced ternary
- Barnsley fern
- Base 16 numbers needing a to f
- Base64 encode data
- Bell numbers
- Benford's law
- Bernoulli numbers
- Bernstein basis polynomials
- Best shuffle
- Bin given limits
- Binary coded decimal
- Binary digits
- Binary search
- Binary strings
- Binomial transform
- Bioinformatics/base count
- Birthday problem
- Bitmap
- Bitmap/Bresenham's line algorithm
- Bitmap/Bézier curves/Cubic
- Bitmap/Midpoint circle algorithm
- Bitwise IO
- Bitwise operations
- Blum integer
- Boolean values
- Boustrophedon transform
- Box the compass
- Brilliant numbers
- Bulls and cows
- Bulls and cows/Player
C
- Caesar cipher
- Calculating the value of e
- Calendar
- Calendar - for "REAL" programmers
- Calkin-Wilf sequence
- Call a foreign-language function
- Call a function
- Call an object method
- Calmo numbers
- CalmoSoft primes
- Camel case and snake case
- Canonicalize CIDR
- Cantor set
- Carmichael 3 strong pseudoprimes
- Cartesian product of two or more lists
- Case-sensitivity of identifiers
- Casting out nines
- Catalan numbers
- Catalan numbers/Pascal's triangle
- Catamorphism
- Centre and radius of a circle passing through 3 points in a plane
- Centroid of a set of N-dimensional points
- Change e letters to i in words
- Changeable words
- Character codes
- Chebyshev coefficients
- Check if a polygon overlaps with a rectangle
- Check if two polygons overlap
- Check that file exists
- Chemical calculator
- Cheryl's birthday
- Chinese remainder theorem
- Chinese zodiac
- Cholesky decomposition
- Chowla numbers
- Circles of given radius through two points
- Circular primes
- Cistercian numerals
- Classes
- Closures/Value capture
- Code Golf: Code Golf
- Collect and sort square numbers in ascending order from three lists
- Collections
- Colorful numbers
- Combinations
- Combinations and permutations
- Comma quibbling
- Command-line arguments
- Commatizing numbers
- Comments
- Common list elements
- Compare a list of strings
- Compare length of two strings
- Compiler/code generator
- Compiler/lexical analyzer
- Compiler/Simple file inclusion pre processor
- Composite numbers k with no single digit factors whose factors are all substrings of k
- Compound data type
- Concatenate two primes is also prime
- Concurrent computing
- Conditional structures
- Conjugate a Latin verb
- Conjugate transpose
- Consecutive primes with ascending or descending differences
- Constrained random points on a circle
- Continued fraction
- Continued fraction/Arithmetic/Construct from rational number
- Convert CSV records to TSV
- Convert seconds to compound duration
- Conway's Game of Life
- Coprime triplets
- Coprimes
- Copy a string
- Copy stdin to stdout
- CORDIC
- Count how many vowels and consonants occur in a string
- Count in factors
- Count in octal
- Count occurrences of a substring
- Count the coins
- Count the coins/0-1
- Cousin primes
- Cramer's rule
- CRC-32
- Create a file
- Create a two-dimensional array at runtime
- Create an executable for a program in an interpreted language
- Create an HTML table
- CSV data manipulation
- CSV to HTML translation
- Cuban primes
- Cubic special primes
- Cullen and Woodall numbers
- Cumulative standard deviation
- Currency
- Currying
- Curzon numbers
- CUSIP
- Cyclops numbers