EN Homepage NL Thuispagina  • Marcel van der Veer  • Privacy and cookies Posts  • English (61)  • Dutch (42)  • Other (10)  • All posts (113)  • Taxonomy Top categories  • Algol 68  • Essays  • Projects Top keywords  • Computer history  • Education  • Repositories  • Science

Algol68G - Algol 68 for GNU/Linux

November 2001

Version 0.0.1: pre-alpha release

Table of contents

Algol 68 for GNU/Linux

ALGOL68G implements an extended subset of the language described in the Revised Report. ALGOL68G is an interpreter that offers many runtime checks, in this sense ALGOL68G bears resemblance to FLACC. ALGOL68G is intended for small to medium sized algorithms, solving not too complex problems.

Description of the implementation

ALGOL68G actually is a Mailloux-type implementation. A hand coded parser makes several passes resolving the program text hence tags can be applied before they are declared, etcetera. This type of implementation also produces few spurious errors while parsing since ALGOL68G only allows a pass to start when the preceeding ones terminated succesfully.

About this Algol 68 implementation

• Unlike some other implementations, ALGOL68G implements flexible names, transient names and proceduring of jumps to proc void.
• Some Algol 68 parsers require symbols to be declared before they are applied. ALGOL68G implements the Revised Report in this respect, hence symbols can be applied before they are declared. This allows for top down programming:
  
  
  OP ELEM = (ELEMENT sought, NODE root) BOOL:
.. ;
PRIO ELEM = 8;
.. ;
MODE NODE = REF STRUCT (ELEMENT record, .. );
.. ;
MODE ELEMENT = .. ;

  
  However, accessing an uninitialised value is only detected at runtime.
  
• Also, there is at least one implementation that enforces actual declarers to have bounds elaborated at the textual point of declaration rather than at any generator of the actual declarer. ALGOL68G elaborates bounds as the Revised Report requires it, that is, at any generator. Example:
  
  
  MODE A = [1 : n] INT;
INT n := read int;
A row 1;
n *:= 2;
A row 2;
  
  produces two arrays, the latter having twice the length as the former. Therefore, ALGOL68G correctly executes this oddity.
• There is a garbage collector. There should be one, but for instance ALGOL68C never had a working one.
  
• Checks are offered on many events, notably:
  • Assigning to, or dereferencing of, nil,
    
  • Using uninitialised (or empty) values,
    
  • Dangling references to values that no longer exist,
    
  • Bounds check when manipulating arrays.
    
  It should be noted however that although arguments to math functions are checked, overflow and underflow may go undetected when hardware does not trap such condition.
• There is an enlarged set of arithmetic operators and math functions, see quick reference of coercions and standard environ.
• The standard environment allows for drawing graphics with GNU plotutils through extension of Algol 68 transput.
  
• About precision of numeric modes:
  • Implementation of 64 bits int and bits, also on 32 bits platforms.
  • Internal representation of real is C type double. Note that there is no implementation of a single precision short real.
  • Implementation of long int, long real, long complex with roughly doubled precision with respect to int, real, complex.
  • ALGOL68G implements long long real with user defined precision.
    
• The scope rules applied by ALGOL68G appear more strict than applied by some former implementations, since ALGOL68G identifies scope violations in some programs of the MC Revised Algol 68 Test Set. This is because ALGOL68G enforces the (Revised Report) rules:
  • Algol 68 does not allow constructs that potentially could export a reference-to value (that is, a name) out of its scope; whether or not such construct actually does export a name out of scope, is irrelevant.
  • a routine text has a scope that does not exceed that of the youngest tag defined outside the routine text and referenced from same routine text.

  Examples:
  
  

  • [n] REF INT i; BEGIN INT j; i[1 + ENTIER (n * random)] := j; ... END; ...
    is not acceptable since `j' might be exported out of its scope. Whether or not this actually happens is irrelevant.
    
    
  • REF INT i; BEGIN INT j; i := j; ... END; ...
    also is not acceptable - potentially, `j' might be exported out of scope.
    
    
  • PROC VOID pp; INT n := 0; (PROC p = VOID: print (n); pp := p);
    is acceptable since the scope of `p' is that of `n'.
    
    
  • PROC pp = INT: (HEAP INT n := 0; INT: n);
    is not acceptable, since the routine text is passed to a scope outside the scope of `n'. Even though `n' is in the heap and at runtime no dangling reference would occur, such construct is unacceptable in Algol 68.

Deviations from the Revised Report

• The Algol 68 transput model is not implemented entirely; format and format-texts are not implemented and therefore straightening is omitted. When Algol 68 was defined, the transput model was designed with contemporary IO devices in mind. ALGOL68G sees files as things to read data from or to write data to, not as books.
• Transput of bits is in hexadecimal digits.
• The parallel-clause is recognised but is executed as a strong-void-collateral-clause. As a consequence, sema is not implemented.
• The parser does not allow the exchange of sub and bus symbols by open and close symbols, for example () INT must be written as [] INT. The rationale for having alternative notations was that in the sixties and seventies when Algol 68 was developed, not all IO devices featured `[' and `]' symbols.
• The parser allows for colons, used in bounds and indexers, to be replaced by '..' which is the Pascal style. For instance
  
  
  MODE A = [1 .. n] INT;
INT n := read int;
A z;
z [1 .. n - 1] := ... ;

  
  
• There is an enlarged set of arithmetic operators and math functions, see quick reference of coercions and standard environ.
• bytes is not implemented.
• The mode tag identifying a complex number reads complex as well as compl.

Memory model

ALGOL68G's interpreter emulates a stack machine with a heap. Two stacks are used, one to evaluate expressions, and one to stack call frames. Heap management in Algol 68 is implicit; when the heap is full, a garbage collector will compact it. This requires pointers in the heap to be actually handles, as to allow the garbage collector to shift data in the heap.

The stacks and the heap - and handle pool are separate blocks with presetable size. The reason for memory being set up this way is that fixed-size blocks prevent ALGOL68G from allocating all memory available to it before the garbage collector is called, which would impede overall system performance.

The sizes of the four blocks can be controlled using options, and are specified as the number of 1 kB blocks. Current default values are expression stack 512, frame stack 512, handle pool 1024 and heap 4096.

Execution speed

Bugs and caveats

• Although ALGOL68G offers many runtime checks, and arguments to math functions are checked, overflow and underflow may go undetected when hardware does not trap such condition.
• Some platforms do not give reliable information on the actual size of the system stack (for instance when information is updated periodically). Therefore deep recursion may result in a segment violation caused by system stack overflow.
• The parser does not implement context sensitive scanning. Hence, the parser will expect spaces, tabs or newlines to separate symbols whenever ambiguity may arise. For instance, PRIO+=1 will be scanned as `PRIO' `+=' `1', resulting in an error message.
• Algorithms for extended precision are not really suited for precisions larger than a few hundred digits. In fact, implemented algorithms are not even the most efficient, although they preserve accuracy better than some other multiple-precision implementations.
• ALGOL68G was not designed with size efficiency in mind. A program may need more memory than a comparable program in another high level language. This is due to several reasons: not all recursion is removed from the interpreter, basic types have overhead as to check values for emptiness etcetera.

How to use language extensions

Assertions as pre- or postconditions

ALGOL68G supports an extension called assertions. Assertions can be viewed in two ways. First, they provide a notation for invariants that can be used to code a proof of correctness together with an algorithm. Hardly anyone does this, but assertions make for debugging statements. The syntax for assertions reads

assertion:
assertion open symbol,
enquiry clause,
assertion close symbol.


assertion open symbol: {.
assertion close symbol: }.

Under control of the `assertions' and `noassertions' pragmat items, the enquiry clause of an assertion is elaborated at runtime. If the enquiry clause yields false, the program is terminated and a runtime error is generated. Example:

OP FACULTY = (INT n) INT: ({n >= 0}; n > 0 | n * FACULTY (n - 1) | 1);

will produce a runtime error when faculty is called with a negative argument.

Drawing using GNU plotutils

Introduction

ALGOL68G offers a number of routines for drawing. To this end it implements a subset of libplot from GNU plotutils. This allows for drawing in for example X windows and pnm files from Algol 68. Note that ALGOL68G is not an Algol 68 binding for libplot.

A plotter (window, postscript file, etcetera) can be considered as a stream to which plotting commands are `written', hence ALGOL68G considers plotters to be objects of mode ref file. To interface with libplot, the transput model has been augmented as to accommodate plotters. A plotter must be opened and closed, just like any file. To specify the file to be a drawing device, stand draw channel is declared in the standard environment, that yields true when inspected by draw possible. To specify details on the plotter type and page size, a procedure make device has to be used. For example:

FILE window;
make device (window, "X", "600x400");	# `window' is an X window with 600x400 pixels #
open (window, "Hello!", stand draw channel);	# The string will be the X window name #
draw erase (window);	# Only now does the window appear on the screen #
draw move (window, 0.25, 0.5);	# Goto pixel 0.25x600, 0.5x400 #
draw color (window, 1, 0, 0);	# Color will be 100% red, 0% green, 0% blue #
draw text (window, "c", "c", "Hello!");	# Writes an aligned text #
VOID (read char);	# Give audience a chance to read the message #
close (window);	# The window disappears from the screen #

Implemented drawing routines are part of the standard environment.

Setting up a graphics device

proc make device = (file file, string type, string params) void

Sets parameters for plotter file. One sets plotter type to either "X" or "pnm" (the ALGOL68G alpha release only supports these two). X plotters write graphics to an X Window System display rather than to an output stream. Error messages from libplot are written to the ALGOL68G log file. A runtime error results when the plotter could not be opened.

Argument params currently is interpreted as an image size only. For X plotters and pnm plotters the syntax reads "x pixels x y pixels".

proc draw erase = (file file) void

Begins the next frame of a multiframe page, by clearing all previously plotted objects from the graphics display, and filling it with the background color (if any).

proc draw show = (file file) void

Flushes all pending plotting commands to the display device. This is useful only if the currently selected plotter does real-time plotting, since it may be used to ensure that all previously plotted objects have been sent to the display and are visible to the user. It has no effect on plotters that do not do real-time plotting.

proc draw move = (file file, real x, y) void

The arguments specify the coordinates (x, y). The graphics cursor is moved to (x, y). The values of x and y are fractions 0 .. 1 of the page size in respectively the x and y directions.

proc draw aspect = (file file) real

Yields the aspect ratio (y size / x size).

proc draw fill style = (file file, int level) void

Sets the fill fraction for all subsequently drawn objects. A value of level = 0 indicates that objects should be unfilled, or transparent. This is the default. A value in the range 16r0001 .. 16rffff, indicates that objects should be filled. A value of 1 signifies 100% filling; the fill color will be the color specified by calling draw color. If level = 16rffff, the fill color will be white. Values 16r0002 .. 16rfffe represent a proportional saturation level, for instance 16r8000 denotes 50%.

proc draw linestyle = (file file, []char style) void

Sets the line style for all lines subsequently drawn on the graphics display. The supported line styles are "solid", "dotted", "dotdashed", "shortdashed", "longdashed", "dotdotdashed", "dotdotdotdashed", and "disconnected". The first seven correspond to the following dash patterns:

"solid"             --------------------------------
"dotted"            -   -   -   -   -   -   -   -   
"dotdashed"         ----   -   ----   -   ----   -
"shortdashed"       ----    ----    ----    ----    
"longdashed"        -------    -------    -------    
"dotdotdashed"      ----   -   -   ----   -   -
"dotdotdotdashed"   ----   -   -   -   ----   -   -   -

In the preceding patterns, each hyphen stands for one line thickness. This is the case for sufficiently thick lines, at least. So for sufficiently thick lines, the distance over which a dash pattern repeats is scaled proportionately to the line thickness. The "disconnected" line style is special. A "disconnected" path is rendered as a set of filled circles, each of which has diameter equal to the nominal line thickness. One of these circles is centered on each of the juncture points of the path (i.e., the endpoints of the line segments or arcs from which it is constructed). Circles with "disconnected" line style are invisible. Disconnected circles are not filled. All line styles are supported by all plotters.

proc draw linewidth = (file file, real thickness) void

Sets the thickness of all lines subsequently drawn on the graphics display. The value of thickness is a fraction 0 .. 1 of the page size in the y direction. A negative value resets the thickness to the default. For plotters that produce bitmaps, i.e., X plotters, and pnm plotters, it is zero. By convention, a zero-thickness line is the thinnest line that can be drawn.

Specifying colors

proc draw background color = (file file, real red, green, blue) void

Sets the background color for plotter file's graphics display, using fractional intensities in a 48-bit RGB color model. The arguments red, green and blue specify the red, green and blue intensities of the background color. Each is a real value in the range 0 .. 1. The choice (0, 0, 0) signifies black, and the choice (1, 1, 1) signifies white. This procedure affects only plotters that produce bitmaps, i. e. , X plotters and pnm plotters. Its effect is that when the draw erase procedure is called for such a plotter, its display will be filled with the specified color.

proc draw color = (file file, real red, green, blue) void

Sets the foreground color for plotter file's graphics display, using fractional intensities in a 48-bit RGB color model. The arguments red, green and blue specify the red, green and blue intensities of the foreground color. Each is a real value in the range 0 .. 1. The choice (0, 0, 0) signifies black, and the choice (1, 1, 1) signifies white.

Drawing objects

proc draw point = (file file, real x, y) void

The arguments specify the coordinates (x, y) of a point that will be drawn. The graphics cursor is moved to (x, y). The values of x and y are fractions 0 .. 1 of the page size in respectively the x and y directions.

proc draw line = (file file, real x, y) void

The arguments specify the coordinates (x, y) of a line that will be drawn starting from the current graphics cursor. The graphics cursor is moved to (x, y). The values of x and y are fractions 0 .. 1 of the page size in respectively the x and y directions.

proc draw rect = (file file, real x, y) void

The arguments specify the corner coordinates (x, y) of a rectangle that will be drawn starting from the diagonally opposing corner represented by the current graphics cursor. The graphics cursor is moved to (x, y). The values of x and y are fractions 0 .. 1 of the page size in respectively the x and y directions.

proc draw circle = (file file, real x, y, r) void

The three arguments specifying the centre (x, y) and radius (r) of a circle, and the circle is drawn. The graphics cursor is moved to (x, y). The values of x and y are fractions 0 .. 1 of the page size in respectively the x and y directions. The value of r is a fraction 0 .. 1 of the page size in the y direction.

Drawing text

proc draw text = (file file, char horiz_justify, vert_justify, [] char s) void

The justified string s is drawn according to the specified justifications. If horiz_justify is equal to `l', `c', or `r', then the string will be drawn with left, centre or right justification, relative to the current graphics cursor position. If vert_justify is equal to `b', `x', `c', or `t', then the bottom, baseline, centre or top of the string will be placed even with the current graphics cursor position. The graphics cursor is moved to the right end of the string if left justification is specified, and to the left end if right justification is specified. The string may contain escape sequences of various sorts (see section Text string format and escape sequences in the plotutils manual), though it should not contain line feeds or carriage returns; in fact it should include only printable characters. The string may be plotted at a nonzero angle, if draw textangle has been called.

proc draw text angle = (file file, int angle) void

Argument angle specifies the angle in degrees counter clockwise from the x (horizontal) axis in the user coordinate system, for text strings subsequently drawn on the graphics display. The default angle is zero. The font for plotting strings is fully specified by calling draw font name, draw font size, and draw text angle.

proc draw font name = (file file, [] char name) void

The case-insensitive string name specifies the name of the font to be used for all text strings subsequently drawn on the graphics display. The font for plotting strings is fully specified by calling draw font name, draw font size, and draw text angle. The default font name depends on the type of plotter. It is "Helvetica" for X plotters, for pnm it is "HersheySerif". If the argument name is NIL or an empty string, or the font is not available, the default font name will be used. Which fonts are available also depends on the type of plotter; for a list of all available fonts, see section Available text fonts in the plotutils manual.

proc draw font size = (file file, int size) void

Argument size is interpreted as the size, in the user coordinate system, of the font to be used for all text strings subsequently drawn on the graphics display. A negative value for size sets the size to the default, which depends on the type of plotter. Typically, the default font size is 1/50 times the size (i. e. , minimum dimension) of the display. The font for plotting strings is fully specified by calling draw font name, draw font size, and draw text angle.

Reference

Options

Options are passed to ALGOL68G either from the command line or through pragmats. Options are not case sensitive. In the table below, bold letters denote letters mandatory for recognition. Listing and tracing options, and also -pragmat, -nopragmat, take their effect when they are encountered in a left-to-right pass of the program text, and can thus be used, for example, to generate a cross reference for a particular part of the user program.

One-liners

-print unit

Command line only. Prints the value yielded by Algol 68 unit unit. In this way ALGOL68G can execute one-liners from the command line. See also -execute.

-execute unit

Command line only. Executes Algol 68 unit unit. In this way ALGOL68G can execute one-liners from the command line. See also -print.

Memory size

ALGOL68G manages allocation and deallocation of heap space. However, if memory would be unbound, ALGOL68G might claim all available memory before the garbage collector is called. This would impede overall system performance. Therefore memory size is bound.

-heap number

Sets heap size to number kB. This is the size of the block that will actually hold data, not handles. At run-time ALGOL68G will use the heap to store temporary arrays, so even a program that has no heap generators requires some heap space, and might even invoke the garbage collector.

-handles number

Sets handle space size to number kB. This is the size of the block that hold handles that point to data in the heap. A reference to the heap does not point to the heap, but to a handle as to make it possible for the garbage collector to compact the heap.

-frame number

Sets frame stack size to number kB. A heavily recursive program with many local variables may require a large frame stack space.

-stack number

Sets expression stack size to number kB. A heavily recursive program may require a large expression stack space.

Listing options

-extensive

Generates extensive listing, including source listing, syntax tree, cross reference etcetera. This listing can be quite bulky.

-listing

Generates concise listing.

-moids

Generates overview of moids in listing file.

-preludelisting

Generates a listing of preludes.

-source, -nosource

Starts (or stops) listing of source lines in listing file.

-statistics

Generates statistics in listing file.

-terminal

Echo listing file to stdout.

-tree, -notree

Generates syntax tree listing in listing file. This option can make the listing file bulky, so use considerately.

-unused

Generates an overview of unused tags in the listing file.

-xref, -noxref

Starts (or stops) generating a cross reference in the listing file.

Miscellaneous options

-assertions, -noassertions

Starts (or stops) elaboration of assertions.

-help

Provides an overview of options.

-norun

Check syntax only, interpreter does not start.

-nowarnings

Suppresses warning messages.

-pragmats, -nopragmats

Starts (or stops) elaboration of pragmat items. When disabled, pragmat items are ignored, except for -pragmats.

-precision number

Sets precision for long long real to number significant digits. Note that ALGOL68G algorithms for extended precision are not really suited for precisions larger than a few hundred digits.

-trace, -notrace

Starts (or stops) tracing of a running program.

-verbose

ALGOL68G will inform you on its actions.

-version

States the version of the running copy of ALGOL68G, including date of compilation.

Examples

From the command line
$ a68g -p 'long long pi' -prec 250
+3.141592653589793238462643383279502884197169399375105820974944592307816
406286208998628034825342117067982148086513282306647093844609550582231725
359408128481117450284102701938521105559644622948954930381964428810975665
933446128475648233786783165271201909E +0
$


From the command line
$ a68g -e "INT m = read int, n = read int; print ((m + n, m - n))"
20 10
+30 +10
$


Quick reference of coercions and standard environment

Widenings

From int to complex, long int, long real, long complex, long long real
From real to complex, long real, long complex, long long real
From complex to long complex
From long int to long real, long complex, long long real
From long real to long complex, long long real
From bits to [] bool

Enquiries

intint lengths, int shorts, max int, real lengths, real shorts, bits lengths, bits shorts, max abs char, int width, real width, exp width, bits width
realmax real, small real
long intlong max int
long reallong max real, long small real
long long reallong long max real, long long small real
ref charerrorchar, expchar, flip, flop # constants in Algol 68, names in ALGOL68G#

Modes

mode double= long real, quad= long long real
mode complex= struct(realre, im), long complex= struct(long realre, im)
mode string= flex[1 : 0] char
mode ?rows= union(# all modes that are rows #)

Transput

mode number= union(int, long int, real, long real, long long real)
mode ?simplin= union(ref int, ref real, ref complex, ref long int, ref long real, ref long long real, ref long complex, ref bool, ref bits, ref char, ref [] char, proc(ref file) void)
mode ?simplout= union(int, real, bool, bits, char, complex, long int, long real, long long real, long complex, [] char, string, proc(ref file) void)

channelstand in channel, stand out channel, stand back channel, stand draw channel;
ref filestand in, stand out

proc(ref file) boolput possible, get possible, bin possible, set possible, reset possible, reidf possible, draw possible
proc(ref file, proc(ref file) void) voidon logical file end, on value error

proc(ref file, string, channel) boolopen
proc(ref file) voidclose, space, new line

proc(ref file, string) voidmake term
proc(ref file, string, string) voidmake device

proc([] ?simplout) voidwrite, print

proc([] ?simplin) voidread

proc(ref file, [] ?simplout) voidput, print f, write f

proc(ref file, [] ?simplin) voidget, read f

proc(ref file, [] ?simplout) voidput bin, print bin, write bin

proc(ref file, [] ?simplin) voidget bin, read bin

procintread int
proclong intread long int
procrealread real
proclong realread long real
proclong long realread long long real
procboolread bool
proccharread char
procstringread string

proc(number, int) stringwhole
proc(number, int, int) stringfixed
proc(number, int, int, int) stringfloat

Math constants

realpi
proc long reallong pi, dpi # A constant in Algol 68, a procedure in ALGOL68G#
proc long long reallong long pi, qpi # A constant in Algol 68, a procedure in ALGOL68G#

Math functions

proc (real) real

sqrt, exp, ln, log, sin, asin, arcsin, cos, acos, arccos, tan, atan, arctan, sinh, asinh, arcsinh, cosh, acosh, arccosh, tanh, atanh, arctanh

proc (long real) long real

long sqrt, long exp, long ln, long log, long sin, long asin, long arcsin, long cos, long acos, long arccos, long tan, long atan, long arctan, long sinh, long asinh, long arcsinh, long cosh, long acosh, long arccosh, long tanh, long atanh, long arctanh
and shorthand synonyms d sqrt, d exp, d ln, d log, d sin, d asin, d arcsin, d cos, d acos, d arccos, d tan, d atan, d arctan, d sinh, d asin, d arcsin, d cosh, d acosh, d arccosh, d tanh, d atanh, d arctanh

proc (long long real) long long real

long long sqrt, long long exp, long long ln, long long log, long long sin, long long asin, long long arcsin, long long cos, long long acos, long long arccos, long long tan, long long atan, long long arctan, long long sinh, long long asinh, long long arcsinh, long long cosh, long long acosh, long long arccosh, long long tanh, long long atanh, long long arctanh
and shorthand synonyms q sqrt, q exp, q ln, q log, q sin, q asin, q arcsin, q cos, q acos, q arccos, q tan, q atan, q arctan, q sinh, q asin, q arcsin, q cosh, q acosh, q arccosh, q tanh, q atanh, q arctanh

proc (complex) complex

csqrt, cexp, cln, csin, casin, carcsin, ccos, cacos, carccos, ctan, catan, carctan, csinh, casinh, carcsinh, ccosh, cacosh, carccosh, ctanh, catanh, carctanh

proc (long complex) long complex

long csqrt, long cexp, long cln, long csin, long casin, long carcsin, long ccos, long cacos, long carccos, long ctan, long carctan, long catan, long csinh, long casinh, long carcsinh, long ccosh, long cacosh, long carccosh, long ctanh, long catanh, long carctanh
and shorthand synonyms d csqrt, d cexp, d cln, d csin, d casin, d carcsin, d ccos, d cacos, d carccos, d ctan, d catan, d carctan, d csinh, d casinh, d carcsinh, d ccosh, d cacosh, d carccosh, d ctanh, d catanh, d carctanh

Operator synonyms

For operator symbols, next synonyms are implemented



Operator tag	Alternative
=	eq
/=	ne, ~=, ^=
<	lt
<=	le
>	gt
>=	ge
&	and
+*	i
%*	mod
~	not
%	over
**	up, ^
+:=	plusab
-:=	minusab
*:=	timesab
/:=	divab
%:=	overab
%*:=	modab
+=:	plusto

Operator priorities

Priority	Operators
1	+:=, -:=, *:=, /:=, %:=, %*:=, +=:
2	or
3	&, xor
4	=, /=
5	<, <=, >, >=
6	+, -
7	*, /, %, %*, elem
8	**, lwb, upb
9	+*

Monadic operators

mode a	Implemented operators
int real complex long int long real long complex long long real	op (a) a +, -, abs, sign
real long real long long real	op (a) a nint
real	op (a) int round, entier
long real	op (a) long int round, entier
complex long complex	op (a) real re, im, abs, arg
complex long complex	op (a) a conj
bool bits	op (a) a ~
char bits	op (a) int abs
int	op (a) char repr op (a) bits bin
int long int	op (a) bool odd
?rows	op (a) int lwb, upb




mode a	Implemented operators
int	op (a) long int leng
long int	op (a) int shorten
real	op (a) long real leng
long real	op (a) real shorten
complex	op (a) long complex leng
long complex	op (a) complex shorten
long real	op (a) long long real leng
long long real	op (a) long real shorten

Dyadic operators

mode a	mode b	Implemented operators
int	int	op (a, b) int +, -, *, %, *%, ** op (a, b) real / op (a, b) complex +* op (a, b) bool =, /=, <, <=, >, >= op (ref a, b) ref a +:=, -:=, *:=, %:=, %*:=
real	real int	op (a, b) real +, -, *, /, ** op (b, a) real +, -, *, /, ** op (a, b) complex +* op (b, a) complex +* op (a, b) bool =, /=, <, <=, >, >= op (b, a) bool =, /=, <, <=, >, >= op (ref a, b) ref a +:=, -:=, *:=, /:=
complex	complex real int</ td>	op (a, b) complex +, -, *, /, ** op (b, a) complex +, -, *, /, ** op (a, b) bool =, /= op (b, a) bool =, /= op (ref a, b) ref a +:=, -:=, *:=, /:=
long int	long int int	op (a, b) long int +, -, *, %, *%, ** op (b, a) long int +, -, *, %, *%, ** op (a, b) long real / op (b, a) long real / op (a, b) long complex +* op (b, a) long complex +* op (a, b) bool =, /=, <, <=, >, >= op (b, a) bool =, /=, <, <=, >, >= op (ref a, b) ref a +:=, -:=, *:=, %:=, %*:=
long real	long real long int real int	op (a, b) long real +, -, *, /, ** op (b, a) long real +, -, *, /, ** op (a, b) long complex +* op (b, a) long complex +* op (a, b) bool =, /=, <, <=, >, >= op (b, a) bool =, /=, <, <=, >, >= op (ref a, b) ref a +:=, -:=, *:=, /:=
long complex	long complex long real long int complex real int	op (a, b) long complex +, -, *, /, ** op (b, a) long complex +, -, *, /, ** op (a, b) bool =, /= op (b, a) bool =, /= op (ref a, b) ref a +:=, -:=, *:=, /:=
long long real	long long real long real long int real int	op (a, b) long long real +, -, *, /, ** op (b, a) long long real +, -, *, /, ** op (a, b) bool =, /=, <, <=, >, >= op (b, a) bool =, /=, <, <=, >, >= op (ref a, b) ref a +:=, -:=, *:=
bool	bool	op (a, b) bool &, or, xor, =, /=
string char	string char	op (a, b) string + op (a, b) bool =, /=, <, <=, >, >=
string	string char	op (ref a, b) ref a +:= op (b, ref a) ref a +=:
string char	int	op (a, b) string * op (b, a) string *
string	int	op (ref a, b) ref a *:= op (a, b) char elem
bits	bits	op (a, b) bits &, or, xor op (a, b) bool =, /=, <, <=, >, >=
bits	int	op (a, b) bits shl, shr op (a, b) bool elem
int	?rows	op (a, b) int upb, lwb

Miscellaneous

proc(char, ref int, string) boolchar in string
proc(ref int) realnext random

References

• Mailloux et al. , Edmonton, Canada 1978. FLACC Full Language Algol 68 Checkout Compiler, an interpreter for the full language, available on IBM mainframes and used in teaching, both in North America and in Europe.
  
  
• A. van Wijngaarden et al., editors. Revised Report on the Algorithmic Language ALGOL 68. Acta Informatica 5 1-236 [1975]; SIGPLAN Notices 12(5) 1-70 [1977].
  
  
• D. Grune, The Revised MC ALGOL 68 Test Set, IW XX/79, Mathematical Centre, Amsterdam.
  
  
• The plotutils Package.
  
  
• C.H.A. Koster. The Making of Algol 68. Presented at the conference `25 years Algol 68' at the CWI, Feb 1993.

Appendix. Example programs

Towers of Hanoi by a recursive mode declaration

After a program from the MC Revised Algol 68 Test Set.

# After `P. G. Hibbard, Proc. Int. Conf. A68 III, Winnipeg, June, 1974'         #
# Applied occurrence of mode-indication in actual-bounds of its actual-declarer #

  INT n := read int; 

  CHAR a := "a", b := "b", c := "c";

  PROC swap = (REF CHAR c1, c2) VOID: (CHAR d = c1; c1 := c2; c2 := d);

  MODE HANOI = [
    IF n > 0
    THEN n -:= 1;
         swap(b, c); HANOI h1; swap(b, c);
         print((newline, "move ", whole(LWB h1 + 1, 0), 
                " from ", a, " to ", c, "."));
         swap(a, b); HANOI h2; swap(a, b);
         n +:= 1
    ELSE 0
    FI  :  1] INT;

  LOC HANOI

This website is archived by the National Library of the Netherlands.