The incompatibilities between C and Fortran can be relieved at the source code level. The following code fragment illustrates the principle:
This short Fortran program calls the function rtisrv with one
parameter. The implementation of rtisrv is provided within a C++
program. Obviously parameters are passed by reference. When passing arrays
the memory management differs between C and Fortran. C stores multidimensional
arrays in row-major order but Fortran in column-major order.
Additionally the Fortran compiler extends the function name with an underline
character. This behaviour is compiler dependent but can easily handled on C
source code level. The problem gets more complex when calling Fortran
module functions from C. For example generates the Intel Fortran Compiler
ifort (9.x, 10.x) from a function with the name fcnname within a module named
modulename the symbol modulename_mp_fcnname_. Instead generates the GNU
compiler gfortran the symbol __modulename__fcnname. The F90HLA library uses
conditional preprocessor constants to support different compilers. Functions
for data type conversions are also provided.
When integrating the object oriented RTI interface within a procedural language environment four main challanges have to be overcome:
- Object instantiation,
- function overloading,
- exception handling and
- bidirectional communication.
The F90HLA library provides the function rtiOn() to instantiate statically an RTI ambassador object and a federate ambassador object. Once instantiated a procedural interface towards libRTI as shown in the right figure can be built up.
The usage of methods with the same name but different signatures is common practise in the object orientation. Also the RTI-C++-interface makes extensive use of overloaded methods. However, Fortran90 do not support overloading natively. But Fortran90 knows the concept of optional function parameters. With the intrinsic function present the existence of a parameter declared as optional can be tested. These tests are performed on an additional Fortran90 module layer. After that the layer calls the corresponding method of the C++ wrapper. Finally this C++ routine converts Fortran types to C/C++ types and calls the appropriate RTI service.
A similar method is applied to realize a selectable exception handling. When an optional error parameter is passed potential exceptions generated on the C++ wrapper layer are returned to the Fortran federate. By default the application terminates when an error occurs.
A Fortran90 federate invokes RTI services by calling the appropriate rtiModSrv function. There the function signature is analysed and the appropriate C function in the C++-Wrapper called. At C++ level all necessary type conversion are done. After that the actual library function is called. All RTI services return after execution immediatly. RTI initiated calls are handled first on the C++ wrapper layer. LibRTI calls the implemented federate services. There a type conversion from C resp. C++ types into Fortran types takes place. Finally the appropriate Fortran90 federate service implementation is called.