Algol-68D Summary
-----------------
Version 1 02-07-12

MODES
-----

Predefined modes are

  INT   (32-bit signed twos complement)
  BOOL  (8-bits with value 0 or 1)
  REAL  (64-bit IEEE float)
  CHAR  (8-bit ASCII)

Defining new modes (AMODE is any mode)

  REF AMODE
  
     Reference to given mode. You can think of this as a pointer to an
     amode value, or a variable of type AMODE (these notions are the
     same in A68D).

  [expr]AMODE
  [expr:expr]AMODE
  []AMODE

     These declare a one dimensional array. The expr values are expressions
     that are of mode INT (or can be coerced to INT) and represent the
     bounds. In the first form, the lower bound is 1. The expr values are
     evaluated when the mode is declared. The form with no bounds is used
     only for procedure formal modes, where it indicates that the bounds
     are passed in as parameters.


  STRUCT (AMODE field, field, AMODE field, ....)

     Declares a struct type (record type) with given fields. A restriction
     is that if row (array) modes appear as field modes, then they must have
     fixed bounds known at compile time (explicit integers).

  UNION (AMODE, AMODE, AMODE, ...)

     A union mode, values can be of any of the given modes, and the value
     is stored with an implicit tag showing what kind of value is stored
     currently.

The Mode declaration gives a name to a mode, e.g.

  MODE PTR = REF INT;

  Mode names have upper case letters and digits, and start with an upper
  case letter.

DECLARATIONS
------------

   Form of declaration is

     AMODE xy = expression

   where expression is of mode AMODE. The effect is to bind the name xy
   to the given expression. Identifiers have lower case letters and
   digits, and start with a lower case letter.

ASSIGNMENTS
-----------

   An assignment has the form:

      expr := expr

   where the expr on the left has mode REF AMODE, and the expr on the
   right has mode AMODE, the effect is to assign the given value to
   the referenced cell, and the result is the REF AMODE value.

ALLOCATORS
----------

   Allocators are expressions that allocate space for a value and return
   a reference to the created space.

       LOC AMODE     creates space on the local stack frame for a value of
                     mode AMODE.

       HEAP AMODE    creates space on the garbage collected heap for a
                     value of mode AMODE.

   These allocators return a value of REF AMODE, so they are suitable
   for use on the left side of an assignment for example:

       LOC INT := 3;

   Most often the allocators are used in declarations as in

       REF INT xx = LOC INT         uninitialized integer variable
       REF INT xx = LOC INT := 3    initialized integer variable

   A short hand is permitted
   
       AMODE xyz          means   REF AMODE xyz = LOC AMODE
       AMODE xyz := expr  means   REF AMODE xyz = LOC AMODE := expr

EXPRESSIONS
-----------

   Literals

      12
      14.0
      3.1E-5
      TRUE
      FALSE

   SKIP, undefined value of appropriate mode

   NIL,  pointer to no value (of type REF any mode)
   
   Arithmetic operators

     expr + expr
     expr - expr
     expr * expr
     expr / expr
     + expr
     - expr
     ABS expr

     Also: expr +:= (plus and becomes)

   Logical operators (operate on BOOL)

     expr AND expr
     expr OR expr
     expr 

   Short circuiting

    expr ANDTH expr
    expr OREL  expr

   Arithmetic comparison operators 
      =
      <
      >
      >=
      <=
      /=

  Pointer comparison

     IS
     ISNT

   Selection from structure

     next OF expr

         where expr is of mode STRUCT AMODE, and next is one of the
         field names in this mode.

   Subscripting an array

     aexpr [sexpr]

         sexpr is of mode INT, aexpr is a row mode, the effect is to
         yield the corresponding value.

   Slicing an array 

     aexpr [expr
                                    

Control Structures
------------------

   A series is a a sequence of one or more declarations or expressions
   separated by semicolons. Evaluated left to right in sequence. Each
   value is computed and then discarded, except the last, which is the
   value of the series.

   Serial clause

      BEGIN series END
      (     series )


   Collateral clause

      BEGIN expr, expr, expr ... , expr END
      (     expr, expr, expr ... , expr )

         The expressions are evaluated in any order, or even in parallel.
         The result is either VOID, or it can be a STRUCT value for a
         STRUCT whose field values match the modes of the expressions.
          

   IF series THEN series ELSE series FI
   (  series  |   series  |   series )

   IF series THEN series ELIF series THEN series ...
                         ELSE series THEN series  FI
   (  series |    series  |:  series  |   series
                          |   series  |   series  FI

   FOR idf FROM series BY series TO series WHILE series
        DO series OD

      The loop counter, idf, is of mode INT (not REF INT)
      and its declaration is created by (and local to) the
      loop. It is effectively re-declared on each iteration
      and can not be modified from within the loop. Any
      declarations in the subclause between the WHILE
      and DO are visible in the subclause between the
      DO and OD. The yield of a loop clause is void. 

  
   Case Conformity Clause

       CASE series IN
          (AMODE idf): series
          (AMODE idf): series
           OUT  series
       ESAC

COMMENTS
--------

 Comments are {text}

COERCIONS
---------

Uniting      AMODE => UNION(AMODE, ...)
Dereference  REF AMODE => AMODE
Rowing       AMODE => []AMODE
Voiding      AMODE => VOID