Type compatibility (The GNU Modula-2 Compiler)

### 2.11 Type compatibility ¶

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).

#### 2.11.1 Expression compatibility ¶

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 (https://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).

#### 2.11.2 Assignment compatibility ¶

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.

#### 2.11.3 Parameter compatibility ¶

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.