Re: [Hostess-info] Re: test suite preliminary

[Michael v. A. <mi...@de...>]

re...@in... writes:

> mf...@ma... writes:
> 
> > 2. There are two ways of interpretation of constant expression. The
> > first says that each literal have its own type assigned by its value.
> > But according to this way expression 2000000000-2000000000 has type
> > LONGINT (32 bit) but not SHORTINT as 0. Using this way one can define
> > LONG and SHORT for constant expressions. The second interpretation is
> > that the whole constant expression has type according to its value.
> > And for this case it is impossible to change type of a constant
> > expression, so LONG and SHORT cannot change expression's type and thus
> > I did not implemented them for constants.

I implemented the same logic in OOC, using the same arguments.
Because an integer constant's type is always a function of its value,
and SHORT and LONG are identity operations, they do not change the
integer constant's type and are effectively noops.  They are still
supported, though, to allow expressions like "SHORT(LEN(a^))" for both
open array and fixed array types of "a^" even if the compiler does
constant folding during parsing.

> > 3. Oberon language report. 6.2. "The number of elements of an array is
> > called its length. The elements of the array are designated by indices,
> > which are integers between 0 and the length minus 1."
> > Let's apply this clause to lengths 0 and -1.
> > For 0: The elements of the array are designated by indices, which are
> > integers between 0 and -1.
> > For -1: The elements of the array are designated by indices, which are
> > integers between 0 and -2.
> > These statements appear to be identical because second boundary for
> > indices is less than the first.
> 
> This is also not clearly specified (IMHO). It is impossible to access
> the elements of the array (doing it causes an exception); some compilers
> deduce that the type must also be illegal, but the report is not
> explicit about this.

An old favorite of mine ;-) If I can do "NEW(array,0)" (an expression
which can be useful, but seems to be used more often in the Java
camp), then declaring an array "TYPE A=ARRAY 0 OF CHAR" should not be
illegal.  I'm not in favour of negative array length, though, and
would prefer to have an invariant "LEN(a)>=0" for all array variables
`a'.

-- mva