This section discuss the issues surrounding assignment, expression and parameter compatibility, their effect of the additional fixed sized datatypes and also their effect of run time checking. The data types supported by the compiler are:
GNU Modula-2 scope switches ============================================= INTEGER pervasive LONGINT pervasive SHORTINT pervasive CARDINAL pervasive LONGCARD pervasive SHORTCARD pervasive BOOLEAN pervasive BITSET pervasive REAL pervasive LONGREAL pervasive SHORTREAL pervasive CHAR pervasive SHORTCOMPLEX pervasive COMPLEX pervasive LONGCOMPLEX pervasive LOC SYSTEM -fiso BYTE SYSTEM WORD SYSTEM ADDRESS SYSTEM The following extensions are supported for most architectures (please check SYSTEM.def). ============================================= INTEGER8 SYSTEM INTEGER16 SYSTEM INTEGER32 SYSTEM INTEGER64 SYSTEM CARDINAL8 SYSTEM CARDINAL16 SYSTEM CARDINAL32 SYSTEM CARDINAL64 SYSTEM BITSET8 SYSTEM BITSET16 SYSTEM BITSET32 SYSTEM WORD16 SYSTEM WORD32 SYSTEM WORD64 SYSTEM REAL32 SYSTEM REAL64 SYSTEM REAL96 SYSTEM REAL128 SYSTEM COMPLEX32 SYSTEM COMPLEX64 SYSTEM COMPLEX96 SYSTEM COMPLEX128 SYSTEM
The Modula-2 language categorizes compatibility between entities of possibly differing types into three sub components: expressions, assignments, and parameters. Parameter compatibility is further divided into two sections for pass by reference and pass by value compatibility.
For more detail on the Modula-2 type compatibility see the Modula-2 ISO standard BS ISO/IEC 10514-1:1996 page 121-125. For detail on the PIM type compatibility see Programming in Modula-2 Edition 4 page 29, (Elementary Data Types).
Modula-2 restricts the types of expressions to the same type. Expression compatibility is a symmetric relation.
For example two sub expressions of INTEGER
and CARDINAL
are not expression compatible
(http://freepages.modula2.org/report4/modula-2.html and ISO
Modula-2).
In GNU Modula-2 this rule is also extended across all fixed sized data types (imported from SYSTEM).
This section discusses the assignment issues surrounding assignment
compatibility of elementary types (INTEGER
, CARDINAL
,
REAL
and CHAR
for example). The information here is
found in more detail in the Modula-2 ISO standard BS ISO/IEC
10514-1:1996 page 122.
Assignment compatibility exists between the same sized elementary types.
Same type family of different sizes are
also compatible as long as the MAX(
type)
and
MIN(
type)
is known. So for example this includes the
INTEGER
family, CARDINAL
family and the REAL
family.
The reason for this is that when the assignment is performed
the compiler will check to see that the expression (on the right of
the :=
) lies within the range of the designator type (on the
left hand side of the :=
). Thus these ordinal types can be
assignment compatible. However it does mean that WORD32
is not
compatible with WORD16
as WORD32
does not have a minimum
or maximum value and therefore cannot be checked. The compiler does
not know which of the two bytes from WORD32
should be copied
into WORD16
and which two should be ignored. Currently the
types BITSET8
, BITSET16
and BITSET32
are
assignment incompatible. However this restriction maybe lifted when
further run time checking is achieved.
Modula-2 does allow INTEGER
to be assignment compatible with
WORD
as they are the same size. Likewise GNU Modula-2 allows
INTEGER16
to be compatible with WORD16
and the same for
the other fixed sized types and their sized equivalent in either
WORD
n, BYTE
or LOC
types. However it prohibits
assignment between WORD
and WORD32
even though on many
systems these sizes will be the same. The reasoning behind this rule
is that the extended fixed sized types are meant to be used by
applications requiring fixed sized data types and it is more portable
to forbid the blurring of the boundaries between fixed sized and
machine dependent sized types.
Intermediate code run time checking is always generated by the front end. However this intermediate code is only translated into actual code if the appropriate command line switches are specified. This allows the compiler to perform limited range checking at compile time. In the future it will allow the extensive GCC optimizations to propagate constant values through to the range checks which if they are found to exceed the type range will result in a compile time error message.
Parameter compatibility is divided into two areas, pass by value and
pass by reference (VAR
). In the case of pass by value the
rules are exactly the same as assignment. However in the second case,
pass by reference, the actual parameter and formal parameter must be
the same size and family. Furthermore INTEGER
and
CARDINAL
s are not treated as compatible in the pass by
reference case.
The types BYTE
, LOC
, WORD
and WORD
n
derivatives are assignment and parameter compatible with any data type
of the same size.