Algol68G - an Algol 68 interpreter

 Revision 1.0

 Marcel van der Veer

---

Table of contents

• About Algol68G
• No warranty
• Synopsis and options
  • One-liners
  • Memory size
  • Listing options
  • Miscellaneous options
  • Examples
• Description of the implementation
  • About this Algol 68 implementation
  • Deviations from the Revised Report
  • Execution speed
  • Known problems
• Drawing using GNU plotutils
  • Introduction
  • Setting up a graphics device
  • Specifying colours
  • Drawing objects
  • Drawing text
• An elementary vector library
• Assertions as pre- or postconditions
• The refinement preprocessor
• Coercions and standard environment
  • Widenings
  • Enquiries
  • Math constants
  • Math functions
  • Modes
  • Transput
  • Operator synonyms
  • Operator priorities
  • Monadic operators
  • Dyadic operators
  • Random number generator
  • Miscellaneous
• Referenced sources

---

About Algol68G

Algol 68 was conceived as a successor to Algol 60, with special attention given to wide applicability and a rigorously defined syntax. The contribution of Algol 68 to the development of computer science comes from original design concepts which were passed on in one form or another to many of the later developed programming languages. The language has compact, orthogonal syntax and strong typing that eliminates many programming errors. It has been said that those who used the language remember it as a beautiful means of denoting algorithms.

Algol68G consists of the command-line program a68g that is an Algol 68 subset interpreter. Algol68G is a check-out system, intended for small to medium size algorithms, that first translates a program entirely into an intermediate representation whereafter the latter is interpreted. Therefore, considering function, it resembles FLACC [Mailloux 1978]. Being a check-out system, a68g is suited for small to medium size programs that solve not too complex problems. Algol68G offers multi-precision arithmetic and graphic routines, for instance for the X Window System. Although Algol68G is not a full implementation, it is more complete than Algol68C.

No warranty

The software described in this manual has no warranty, it is provided "as is". Consult the GNU General Public License for further details.

Synopsis and options

From the command-line you would use

a68g [option | file] ...

Options are passed to a68g either from the file .a68g.rc in the working directory, the command-line or through pragmats. Precedence is as follows: pragmats supersede command-line options, command-line options supersede options in .a68g.rc. Options are not case sensitive. In the list below, bold letters denote letters mandatory for recognition. Listing options, tracing options and -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 a68g can execute one-liners from the command-line. The one-liner is written in file .a68g.x in the working directory. See also -execute.

-execute unit

Command-line only. Executes Algol 68 unit unit. In this way a68g can execute one-liners from the command-line. The one-liner is written in file .a68g.x in the working directory. See also -print.

Memory size

a68g manages allocation and de-allocation of heap space. However, if memory would be unbound, a68g 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 a68g 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. Current default value is 4096.

-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. Current default value is 1024.

-frame number

Sets frame stack size to number kB. A deeply recursive program with many local variables may require a large frame stack space. Current default value is 512.

-stack number

Sets expression stack size to number kB. A deeply recursive program may require a large expression stack space. Current default value is 512.

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.

-trace, -notrace

Starts (or stops) tracing of a running program.

-help

Provides an overview of options.

-check, -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 modes to number significant digits. The precision cannot be less than the precision of LONG modes. Note that a68g algorithms for extended precision are not really suited for precisions larger than a few thousand digits.

-timelimit number

Interrupts the interpreter after number seconds; a time limit exceeded runtime error will be given.

-verbose

a68g will inform you on its actions.

-version

States the version of the running copy of a68g.

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
$


Description of the implementation

About this Algol 68 implementation

Algol68G implements an extended subset of the language described in [Revised Report 1975]. A program is parsed and when it is found to be free of errors, the resulting syntax tree, that functions as an intermediate program representation, is interpreted offering many runtime checks; therefore Algol68G resembles FLACC [Mailloux 1978]. Algol68G employs the classical multi-pass scheme to parse Algol 68 [Lindsey 1993].

• The parser of Algol68G allows symbols to be applied before they are declared. This allows for top down programming. However, accessing an uninitialised value is only detected at runtime.
• Algol68G implements flexible names, transient names and proceduring of jumps to PROC VOID.
• Algol68G has a "mark and sweep" garbage collector.
  
• The interpreter checks on many events, notably:
  • Assigning to, or dereferencing of, NIL.
    
  • Using uninitialised values.
    
  • Invalid operands to standard prelude operators and procedures.
    
  • Bound check when manipulating arrays.
    
  Note that the current revision does not offer dynamic scope checking. Also, not all modern hardware traps numeric exceptions, so although division by zero is handled, for instance over - or underflow may go undetected.
• The standard environment allows for drawing graphics with GNU plotutils through extension of transput.
  
• About precision of numeric modes:
  • Optionally 64-bit INT and BITS on 32-bit platforms. Not all platforms support this correctly (more details).
  • 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 multi-precision arithmetic through LONG LONG INT, LONG LONG REAL and LONG LONG COMPLEX which are modes with user defined precision.
• The scope rules applied by Algol68G appear more strict than (presumably) applied by some former implementations, since they identify unintended scope violations in a few programs of the MC Revised Algol 68 Test Set [Grune 1979]. 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.

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. Algol68G handles files as streams, not as BOOKs.
• Transput of BITS is in hexadecimal digits.
• BYTES is not implemented.
• The parallel-clause is recognised but is executed as a strong-void-collateral-clause. Since parallelism is not implemented, SEMA is also not implemented.
• The loop-clause is only accepted when it is used as a unit. When a loop-clause must be used as a primary, it must be embedded in another enclosed clause. Applications of a loop-clause other than a unit are rare, if not academic.
• 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; A z; z [1 .. n OVER 2];

  
  
• The current interpreter does not implement so-called ghost-elements, hence it cannot check bounds when assigning to rows of mode flexible-rows-of-rows-of-... when the destination has a flat descriptor, as in
  
  
  FLEX [1 : 0] [1 : 3] CHAR s := "A string with more than three characters"
  
  Effectively, those mixed cases are treated as if they were flexible in all dimensions. The scope checker recognises the potential introduction of transient references resulting from this peculiarity in Algol68G.
• The mode tag identifying a complex number reads COMPLEX as well as COMPL.
• There are two pseudo-operators ANDF and ORF, defined as
  
  
  tertiary 1 ANDF tertiary 2 = IF tertiary 1 THEN tertiary 2 ELSE FALSE FI
  tertiary 1 ORF tertiary 2 = IF tertiary 1 THEN TRUE ELSE tertiary 2 FI
  
  The syntactic position of those pseudo-operator expressions is a bool-unit, the same as an identity relation. The tertiaries are strong-bool-tertiaries.
  

Execution speed

It is difficult to determine at forehand at what speed the interpreter will run on a certain platform. To have an idea however, Algol68G is rated with the Whetstone benchmark and performance ranges from approximately 1 MWhets on older desktops to 10 MWhets on server hardware. Note that these performances are reached with all run time checks enabled. For comparison, the table below compiles approximate Whetstone ratings in double precision, achieved on machines from the mainframe era

System	MWhets
VAX 11/785	1
CDC Cyber 180-855	2
VAX 8650	4

Known problems

• Algol68G is being developed on GNU/Linux (PowerPC). Although the code is believed to be free of hardware dependencies, a small probability of encountering problems exists when building Algol68G on other platforms. Notably, problems have been reported when using gcc's 64-bit int extensions with FreeBSD, MacOS X (FreeBSD based) and OS/2. Therefore the default setting for the distribution builds Algol68G without 64-bit int support.
• Some platforms do not give reliable information on the actual size of the system stack (for instance when information is updated periodically). This has following practical consequences:
  • Deep recursion may result in a segment violation caused by system stack overflow.
  • The garbage collector is a straightforward "mark and sweep" algorithm that traces the stack and compacts the heap. A well known disadvantage of this method is that deeply recursive data structures might make the garbage collector use a lot of system stack space, thus forming a potential cause for a segment violation.
  • Using jumps to move between incarnations of recursive procedures can make the system stack overflow in case of deep recursion.
  Hence a strategy on encountering a segment violation is to increase system stack size.
• Algorithms for extended precision (LONG LONG INT, LONG LONG REAL, LONG LONG COMPLEX) are not really suited for precisions larger than about a thousand digits. Larger precisions are handled but with a performance penalty with respect to the state of the art in the field of multi-precision calculations. The rationale here is that whenever such high precision is needed, Algol68G would not be the tool of choice on efficiency considerations.

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 X Windows, postscript format, pseudo graphical interface format (pseudo-gif) and portable any-map format (pnm) 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. This seems consistent with the design of Algol 68 transput as a file is associated with a channel that describes the device, and therefore can be considered as a description of a device driver.

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;
# 'window' is an X window with 600x400 pixels #
make device (window, "X", "600x400");
open (window, "Hello!", stand draw channel);
draw erase (window);
# Only now does the window appear on the screen #
# Goto pixel 0.25x600, 0.5x400 #
draw move (window, 0.25, 0.5);
# Color will be 100% red, 0% green, 0% blue #
draw colour (window, 1, 0, 0);
# Write an aligned text #
draw text (window, "c", "c", "Hello!");
# Give audience a chance to read the message #
VOID (read char);
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 = (REF FILE file, STRING type, STRING params) VOID

Sets parameters for plotter file. Parameter type sets the plotter type. Algol68G supports "X" for X Window System, "ps" for postscript, "gif" for pseudo graphical interface format and pnm for portable any-map format. 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 if the plotter could not be opened. Argument params is interpreted as an image size. For X, gif and pnm the syntax reads "x pixels x y pixels", for instance "500x500". For postscript, image size is the size of the page on which the graphics display will be positioned. Any ISO page size in the range "a0" - "a4" or ANSI page size in the range "a" - "e" may be specified. Recognised aliases are "letter" for "a" and "tabloid" for "b". Other valid page sizes are "legal", "ledger", and "b5". The graphics display will be a square region centred on the specified page and occupying its full width, with allowance being made for margins.

PROC draw erase = (REF 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 colour (if any).

PROC draw show = (REF 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 = (REF FILE file, REAL x, y) VOID

The arguments specify the co-ordinates (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 = (REF FILE file) REAL

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

PROC draw fill style = (REF 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 colour will be the colour specified by calling draw colour. If level = 16rffff, the fill colour will be white. Values 16r0002 .. 16rfffe represent a proportional saturation level, for instance 16r8000 denotes 50%.

PROC draw linestyle = (REF 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 centred 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 = (REF 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 colours

PROC draw background colour = (REF FILE file, REAL red, green, blue) VOID
PROC draw background color = (REF FILE file, REAL red, green, blue) VOID

Sets the background colour for plotter file's graphics display, using fractional intensities in a 48-bit RGB colour model. The arguments red, green and blue specify the red, green and blue intensities of the background colour. 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 this plotter, its display will be filled with the specified colour.

PROC draw background colour name = (REF FILE file, STRING name) VOID
PROC draw background color name = (REF FILE file, STRING name) VOID

Sets the background colour for plotter file's graphics display. Argument name is a case insensitive string. Accepted names are essentially those supported by recent revisions of the X Window System. Its effect is that when the draw erase procedure is called for this plotter, its display will be filled with the specified colour.

PROC draw colour = (REF FILE file, REAL red, green, blue) VOID
PROC draw color = (REF FILE file, REAL red, green, blue) VOID

Sets the foreground colour for plotter file's graphics display, using fractional intensities in a 48-bit RGB colour model. The arguments red, green and blue specify the red, green and blue intensities of the foreground colour. 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.

PROC draw colour name = (REF FILE file, STRING name) VOID
PROC draw color name = (REF FILE file, STRING name) VOID

Sets the foreground colour for plotter file's graphics display. Argument name is a case insensitive string. Accepted names are essentially those supported by recent revisions of the X Window System.

Drawing objects

PROC draw point = (REF FILE file, REAL x, y) VOID

The arguments specify the co-ordinates (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 = (REF FILE file, REAL x, y) VOID

The arguments specify the co-ordinates (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 = (REF FILE file, REAL x, y) VOID

The arguments specify the corner co-ordinates (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 = (REF 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 = (REF 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 = (REF FILE file, INT angle) VOID

Argument angle specifies the angle in degrees counter clockwise from the x (horizontal) axis in the user co-ordinate 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 = (REF 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 = (REF FILE file, INT size) VOID

Argument size is interpreted as the size, in the user co-ordinate 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.

An elementary vector library

Algol68G implements a small vector library that relaxes the limitation that the interpreter poses on speed in arithmetic operations. Using these elementary procedures, more complex operations can be programmed. Consider for instance multiplication of a matrix m times a vector b:

FOR n TO UPB a DO a[n] := vector inner product(m[n, ], b) OD;

The procedures in the vector library are optimised for speed, although they still perform runtime checks on vector length, initialisation, assignment to NIL and division by zero. Please note that the procedures strictly process vector elements sequentially as in

PROC vector add = ([] REAL a, b, c) VOID:
   FOR n TO UPB a DO a[n] := b[n] + c[n] OD;

Therefore, take care when passing overlapping slices as arguments.

Following is a list of available procedures.

PROC vector set = (REF [] REAL a, REAL b) VOID

Sets all elements of vector a to real value b.

PROC vector times scalar = (REF [] REAL a, REAL b) VOID

Multiplies all elements of vector a by real value b.

PROC vector move = (REF [] REAL a, [] REAL b) VOID

Copies vector b to vector a. Both vectors are required to have equal number of elements.

PROC vector plus = (REF [] REAL a, [] REAL b, [] REAL c) VOID

Adds vector b to vector c and puts the result in vector a. All vectors are required to have equal number of elements.

PROC vector minus = (REF [] REAL a, [] REAL b, [] REAL c) VOID

Subtracts vector c from vector b and puts the result in vector a. All vectors are required to have equal number of elements.

PROC vector times = (REF [] REAL a, [] REAL b, [] REAL c) VOID

Multiplies, element by element, vector b by vector c and puts the result in vector a. All vectors are required to have equal number of elements.

PROC vector div = (REF [] REAL a, [] REAL b, [] REAL c) VOID

Divides, element by element, vector b by vector c and puts the result in vector a. All vectors are required to have equal number of elements.

PROC vector inner product = ([] REAL a, [] REAL b) REAL

PROC vector inproduct = ([] REAL a, [] REAL b) REAL

Yields the inner product of vector a and vector b. Both vectors are required to have equal number of elements. Summation is done at LONG REAL precision.

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:
  IF {n >= 0}; n > 0 THEN n * FACULTY (n - 1) ELSE 1 FI;

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

The refinement preprocessor

Algol68G is equipped with a refinement preprocessor, that allows programming through stepwise refinement in the style of Wirth's well known lecture. The idea is that program construction is facilitated when the description of the solution to a problem (in casu, an algorithm) can be elaborated as ever more detailed steps until the description of the solution to the problem in Algol 68 is complete. The syntax of a program written this way is

program:
paragraph,
point symbol,
refinement definition sequence.



refinement definition sequence:

• defining identifier,
  colon symbol,
  paragraph,
  point symbol,
  refinement definition sequence.
• empty.

where paragraph is a sequence of tokens (Algol 68 text, actually), other than a point symbol. This form of notation interferes somewhat with Algol 68 notation for labels.

Note that refinements cannot be recursive, nor can their definitions be nested. Also, refinement definitions must be unique, and a refinement can only be applied once (refinements are not procedures).

A trivial example of a program constructed this way is

get two numbers;
tell us their sum.

get two numbers:
  put a polite question;
  INT i = read int, j = read int.

put a polite question:
  print ("Please give two numbers").

tell us their sum:
  print ((i, "+", j, "=", i + j).

Less trivial examples can be found in several lectures and text books on top-down program construction through stepwise refinement.

Algol68G will check whether a program looks like a stepwise refined program. The refinement preprocessor is transparent to programs that are not stepwise refined.

Coercions and standard environment

Widenings

From INT  to REAL
From LONG INT  to LONG REAL
From LONG INT  to LONG LONG INT
From LONG LONG INT  to LONG LONG REAL
From REAL  to COMPLEX
From REAL  to LONG REAL
From LONG REAL  to LONG COMPLEX
From LONG REAL  to LONG LONG REAL
From LONG COMPLEX  to LONG LONG COMPLEX
From LONG LONG REAL  to LONG LONG COMPLEX
From COMPLEX  to LONG COMPLEX
From LONG COMPLEX  to LONG LONG COMPLEX
From BITS  to [] BOOL

Enquiries

INT int lengths, int shorts, max int, real lengths, real shorts, bits lengths, bits shorts, max abs char, int width, real width, exp width, bits width
REAL max real, small real
LONG INT long max int
LONG REAL long max real, long small real
LONG LONG REAL long long max real, long long small real
REF CHAR errorchar, expchar, flip, flop # constants in Algol 68, names in Algol68G #

Modes

MODE DOUBLE = LONG REAL, QUAD = LONG LONG REAL
MODE COMPLEX = STRUCT (REAL re, im), LONG COMPLEX = STRUCT (LONG REAL re, im)
MODE STRING = FLEX [1 : 0] CHAR
MODE ?ROWS = UNION (# a sufficiently large set of rowed-modes #)


Transput

MODE NUMBER = UNION (INT, REAL, LONG INT, LONG REAL, LONG LONG INT, LONG LONG REAL)
MODE ?SIMPLIN = UNION (REF INT, REF REAL, REF COMPLEX, REF LONG INT, REF LONG REAL, REF LONG COMPLEX, REF LONG LONG INT, REF LONG LONG REAL, REF LONG LONG COMPLEX, REF BOOL, REF BITS, REF CHAR, REF [] CHAR, PROC (REF FILE) VOID)
MODE ?SIMPLOUT = UNION (INT, REAL, COMPLEX, LONG INT, LONG REAL, LONG COMPLEX, LONG LONG INT, LONG LONG REAL, LONG LONG COMPLEX, BOOL, BITS, CHAR, [] CHAR, STRING, PROC (REF FILE) VOID)

CHANNEL stand in channel, stand out channel, stand back channel, stand draw channel, stand error channel
REF FILE stand in, stand out, stand back, stand error

PROC (REF FILE) BOOL put possible, get possible, bin possible, set possible, reset possible, reidf possible, draw possible
PROC (REF FILE, PROC (REF FILE) VOID) VOID on logical file end, on value error

PROC (REF FILE, STRING, CHANNEL) INT open
PROC (REF FILE) VOID close, space, new line

PROC (REF FILE, STRING) VOID make term
PROC (REF FILE, STRING, STRING) VOID make device

PROC ([] ?SIMPLOUT) VOID write, print

PROC ([] ?SIMPLIN) VOID read

PROC (REF FILE, [] ?SIMPLOUT) VOID put, print f, write f

PROC (REF FILE, [] ?SIMPLIN) VOID get, read f

PROC (REF FILE, [] ?SIMPLOUT) VOID put bin, print bin, write bin

PROC (REF FILE, [] ?SIMPLIN) VOID get bin, read bin

PROC INT read int
PROC LONG INT read long int
PROC LONG LONG INT read long long int
PROC REAL read real
PROC LONG REAL read long real
PROC LONG LONG REAL read long long real
PROC COMPLEX read complex
PROC LONG COMPLEX read long complex
PROC LONG LONG COMPLEX read long long complex
PROC BOOL read bool
PROC CHAR read char
PROC STRING read string

PROC (INT) VOID print int
PROC (LONG INT) VOID print long int
PROC (LONG LONG INT) VOID print long long int
PROC (REAL) VOID print real
PROC (LONG REAL) VOID print long real
PROC (LONG LONG REAL) VOID print long long real
PROC (COMPLEX) VOID print complex
PROC (LONG COMPLEX) VOID print long complex
PROC (LONG LONG COMPLEX) VOID print long long complex
PROC (BOOL) VOID print bool
PROC (CHAR) VOID print char
PROC (STRING) VOID print string

PROC (NUMBER, INT) STRING whole
PROC (NUMBER, INT, INT) STRING fixed
PROC (NUMBER, INT, INT, INT) STRING float


Math constants

REAL pi
PROC LONG REAL long pi # A constant in Algol 68, a procedure in Algol68G #
PROC LONG LONG REAL long long pi # A constant in Algol 68, a procedure in Algol68G #


Math functions

PROC (REAL) REAL

sqrt, exp, ln, log, sin, arcsin, cos, arccos, tan, arctan

PROC (LONG REAL) LONG REAL

long sqrt, long exp, long ln, long log, long sin, long arcsin, long cos, long arccos, long tan, long arctan

PROC (LONG LONG REAL) LONG LONG REAL

long long sqrt, long long exp, long long ln, long long log, long long sin, long long arcsin, long long cos, long long arccos, long long tan, long long arctan

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 INT LONG LONG REAL LONG LONG COMPLEX	OP (A) A +, -, ABS
INT REAL LONG INT LONG REAL LONG LONG INT LONG LONG REAL	OP (A) INT SIGN
REAL	OP (A) INT ROUND, ENTIER
LONG REAL	OP (A) LONG INT ROUND, ENTIER
LONG LONG REAL	OP (A) LONG LONG INT ROUND, ENTIER
COMPLEX LONG COMPLEX LONG LONG COMPLEX	OP (A) REAL RE, IM, ABS, ARG
COMPLEX LONG COMPLEX LONG 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 LONG 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) LONG LONG INT LENG
LONG INT	OP (A) INT SHORTEN
LONG LONG INT	OP (A) LONG INT SHORTEN
REAL	OP (A) LONG REAL LENG
LONG REAL	OP (A) LONG LONG REAL LENG
LONG REAL	OP (A) REAL SHORTEN
LONG LONG REAL	OP (A) LONG REAL SHORTEN
COMPLEX	OP (A) LONG COMPLEX LENG
LONG COMPLEX	OP (A) LONG LONG COMPLEX LENG
LONG COMPLEX	OP (A) COMPLEX SHORTEN
LONG LONG COMPLEX	OP (A) LONG COMPLEX 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 +:=, -:=, *:=, /:=
COMPLEX	INT	OP (A, B) COMPLEX **
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 INT	INT	OP (A, B) LONG INT **
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 COMPLEX	INT	OP (A, B) LONG COMPLEX **
LONG LONG INT	LONG 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 LONG INT	INT	OP (A, B) LONG LONG INT **
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 +:=, -:=, *:=
LONG LONG COMPLEX	LONG LONG COMPLEX LONG LONG REAL LONG LONG INT LONG COMPLEX LONG REAL LONG INT COMPLEX REAL INT	OP (A, B) LONG LONG COMPLEX +, -, *, / OP (B, A) LONG LONG COMPLEX +, -, *, / OP (A, B) BOOL =, /= OP (B, A) BOOL =, /= OP (REF A, B) REF A +:=, -:=, *:=, /:=
LONG LONG COMPLEX	INT	OP (A, B) LONG LONG COMPLEX **
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 LWB, UPB

Random number generator

The current revision of Algol68G implements a Tausworthe generator that has a period of order 2 ** 113, from the GNU Scientific Library,

PROC (INT seed) VOID first random
Initialises the random number generator using the 32-bit significant number seed.


PROC REAL next random

PROC LONG REAL long next random

PROC LONG LONG REAL long long next random

Generates the next random number in the sequence. The result will be in [0 .. 1>.


Miscellaneous

PROC (CHAR sought, REF INT pos, STRING text) BOOL char in string

Looks up sought in text and assigns its position to pos if found. Returns TRUE if the character is found.

PROC (STRING command) INT system

Passes the string command to the operating system for execution. The operating system is expected to return an integer value, that is in turn returned by the procedure.


PROC VOID sweep heap

Invokes the garbage collector immediately. Sometimes the interpreter cannot sweep the heap when memory is required, for instance when copying stowed objects. In rare occasions this may lead to a program running out of memory. Calling this routine just before the position where the program ran out of memory might help to keep it running. Otherwise (or, alternatively) a larger heap size should be given to the program.


PROC VOID break

A call to this routine has the same effect as sending SIGINT to Algol68G (which usually comes from pressing ctrl-c). Upon receiving SIGINT Algol68G will stop in a primitive monitor routine that allows for instance for inspection of stack frames. Hence, calling break can be useful for debugging purposes.


Referenced sources

• [Grune 1979] D. Grune, The Revised MC Algol 68 Test Set, IW XX/79, Mathematical Centre, Amsterdam [1979].
  
  
• [Koster 1993] C.H.A. Koster, The Making of Algol 68. Presented at the conference "25 years Algol 68" at the CWI [1993].
  
  
• [Lindsey 1993] C.H. Lindsey, A History of Algol 68. ACM SIGPLAN Notices 28(3) 97-132 [1993]
  
  
• [Mailloux 1978] B.J. Mailloux et al., 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. Edmonton, Canada [1978].
  
  
• [Revised Report 1975] 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].
  
  

---