History of Changes for the UV System
		     Revision 1.20, 29 June 1995
		   (C) 1994, 1995 Markus Kaltenbach


Changes made from 1.19 to 1.20:
-------------------------------

 * BUG FIXES: Parser, type checking and constant folding

   Constants (like true or false) were not correctly folded in some
   cases of multiple-case assigment statements. During type checking
   some symboltable lookups were incorrect, possibly causing the
   parser to crash.

Changes made from 1.18 to 1.19:
-------------------------------

 * BUG FIX: Parser, incorrect treatment of if-cases

    A stupid bug (well, nearly all bugs are stupid, but this one in
    particular) caused the parser to report conflicting if-cases of
    assignment statements, when they were indeed consistent.

 * LANGUAGE EXTENSION: compiler directive '%interleaved'

    So far BDD indices were allocated to program variables in the
    order of the declaration of the variables. In particular for any
    two variables all BDD indices for one always preceded all BDD
    indices for the other. This can easily lead to problems when
    dealing with arithmetic and comparison operators, which require an
    interleaved index allocation in order to yield compact internal
    representations. This can now be achieved with the compiler
    directive '%interleaved' in the declare section of a program.

    The grammar for the declare section is extended as follows:

    <declare> ::= 'declare' (<ditem> ';')*
    <ditem>   ::= 'var' <name>*, ':' <type> <interl>
                | 'const' <name>*, ':' <type> ':=' <expression>
                | 'type' <name>*, '=' <type>
    <interl>  ::= 
		| '%' 'interleaved'
		| '%' 'interleaved' <name>

    An empty <interl> corresponds to the sequential allocation as
    before; the directive '%interleaved' after a list of variables
    causes all variables in the list to have interleaved BDD indices;
    the directive '%interleaved' followed by a variable name after a
    list of variables causes all the variables in the list to have
    BDD indices that are interleaved not only for the list of
    variables, but also for the named variable (and all variables the
    named variable is interleaved with). <name> in the last variation
    must be a previously declared variable name (including the
    immediately preceding list of declared variables), there is no
    restriction on its type (in particular it does not need to match
    the type of the declared variables).

    As an example consider:

        declare
          type T = [0..6];
          var x, y, z: T;

    Each variables requires 3 bits, represented by x0, x1, x2, y0, y1,
    y2, z0, z1, and z2. The index ordering for the above declaration
    is:

	x0 < x1 < x2 < y0 < y1 < y2 < z0 < z1 < z2.

    For

        declare
          type T = [0..6];
          var x, y, z: T %interleaved;

    we obtain the following interleaved ordering:

	x0 < y0 < z0 < x1 < y1 < z1 < x2 < y2 < z2.

    The third variant gives even more flexibility, for
    
        declare
          type T = [0..6];
          var x, y : T;
	  var z : T %interleaved y;

    yields

	x0 < x1 < x2 < y0 < z0 < y1 < z1 < y2 < z2,

    and

        declare
          type T = [0..6];
          var x, y : T %interleaved;
	  var z : [0..8] %interleaved x;

    yields

	x0 < y0 < z0 < x1 < y1 < z1 < x2 < y2 < z2 < z3.