In this section you will find information on which versions of the compiler and runtime systems of the individual programming languages you can use to create UTM program units. The following data is listed in a table for each programming language supported by openUTM:
versions of the compiler that you can use to create the objects (OM or LLM) of a UTM program unit
versions of the runtime system that are suitable for these program units
values for the COMP operand of the PROGRAM control statement that you must specify in the KDCDEF generation to add these program units to the application configuration
In particular, you can determine from the table which combinations of compiler version, version of the runtime system and COMP values are allowed.
You will also find information on the compiler and runtime system versions allowed in the CRTE manual and in the documentation for the various compilers (Release Notes, manuals).
Note that compiler versions are listed in the following for which support has already been set. The reason for this is that there are older programs available as objects in some customer applications, and these objects will continue to be used.
You should generally use the compiler and runtime system versions that are still supported for all further developments and new developments! Otherwise you may not place warranty claims or have the right to receive corrections when a problem arises.
In general, the notes and restrictions in the Release Notes and compiler manuals are to be observed.
Mixing languages in an application
Mixing languages means that a UTM application can be compiled from program units which were generated with compilers using different languages and which thus use different runtime systems when operating. The following should be noted, however:
A UTM application is only permitted to contain one runtime system for each programming language that is supported by openUTM and must be generated with
PROGRAM ... COMP NOT EQAL ILCS.
Mixing languages in a program unit
openUTM also allows you to mix languages within a single program unit, i.e. program units can consist of several source codes written in different programming languages. A requirement for this to function is that the program components are called in accordance with the same logical operand conventions; see the CRTE manual. In particular, the data displays when transferring parameters and when accessing shared data structures must be identical.
CAUTION!
The instructions in section "Information for applications with ILCS program units" are to be followed closely.
The calling program as well as the subroutine called are ILCS programs. In this case, there are no restrictions to observe.
It is possible to program Assembler ILCS programs with Z-macros. See the openUTM manual “Programming Applications with KDCS for Assembler”.
The calling and the called program are not ILCS programs, but they observe the same logical operation conventions. The logical operation conventions are described in the user manuals for the corresponding programming languages.
Errors in the logical language operations or address errors can arise when switching to a different language in the following constructions:
C function calls
Assembler function calls with @-macros
calls to third-party software
database calls
formatting system calls