Go to the first, previous, next, last section, table of contents.

# Other Languages

Note: This portion of the documentation definitely needs a lot of work!

## Tools and advice for interoperating with C and C++

The following discussion assumes that you are running `g77` in `f2c` compatibility mode, i.e. not using ``-fno-f2c'`. It provides some advice about quick and simple techniques for linking Fortran and C (or C++), the most common requirement. For the full story consult the description of code generation. See section Debugging and Interfacing.

When linking Fortran and C, it's usually best to use `g77` to do the linking so that the correct libraries are included (including the maths one). If you're linking with C++ you will want to add ``-lstdc++'`, ``-lg++'` or whatever. If you need to use another driver program (or `ld` directly), you can find out what linkage options `g77` passes by running ``g77 -v'`.

### C Interfacing Tools

Even if you don't actually use it as a compiler, ``f2c'` from @url{ftp://ftp.netlib.org/f2c/src}, can be a useful tool when you're interfacing (linking) Fortran and C. See section Generating Skeletons and Prototypes with `f2c`.

To use `f2c` for this purpose you only need retrieve and build the ``src'` directory from the distribution, consult the ``README'` instructions there for machine-specifics, and install the `f2c` program on your path.

Something else that might be useful is ``cfortran.h'` from @url{ftp://zebra/desy.de/cfortran}. This is a fairly general tool which can be used to generate interfaces for calling in both directions between Fortran and C. It can be used in `f2c` mode with `g77`---consult its documentation for details.

### Accessing Type Information in C

Generally, C code written to link with `g77` code--calling and/or being called from Fortran--should ``#include <f2c.h>'` to define the C versions of the Fortran types. Don't assume Fortran `INTEGER` types correspond to C ``int'`s, for instance; instead, declare them as `integer`, a type defined by ``f2c.h'`. ``f2c.h'` is installed where `gcc` will find it by default, assuming you use a copy of `gcc` compatible with `g77`, probably built at the same time as `g77`.

### Generating Skeletons and Prototypes with `f2c`

A simple and foolproof way to write `g77`-callable C routines--e.g. to interface with an existing library--is to write a file (named, for example, ``fred.f'`) of dummy Fortran skeletons comprising just the declaration of the routine(s) and dummy arguments plus ``END'` statements. Then run `f2c` on file ``fred.f'` to produce ``fred.c'` into which you can edit useful code, confident the calling sequence is correct, at least. (There are some errors otherwise commonly made in generating C interfaces with f2c conventions, such as not using `doublereal` as the return type of a `REAL` `FUNCTION`.)

`f2c` also can help with calling Fortran from C, using its ``-P'` option to generate C prototypes appropriate for calling the Fortran.(1) is probably better for this purpose.} If the Fortran code containing any routines to be called from C is in file ``joe.f'`, use the command `f2c -P joe.f` to generate the file ``joe.P'` containing prototype information. `#include` this in the C which has to call the Fortran routines to make sure you get it right.

See section Arrays (DIMENSION), for information on the differences between the way Fortran (including compilers like `g77`) and C handle arrays.

### C++ Considerations

`f2c` can be used to generate suitable code for compilation with a C++ system using the ``-C++'` option. The important thing about linking `g77`-compiled code with C++ is that the prototypes for the `g77` routines must specify C linkage to avoid name mangling. So, use an ``extern "C"'` declaration. `f2c`'s ``-C++'` option will take care of this when generating skeletons or prototype files as above, and also avoid clashes with C++ reserved words in addition to those in C.

### Startup Code

Unlike with some runtime systems, it shouldn't be necessary (unless there are bugs) to use a Fortran main program to ensure the runtime--specifically the i/o system--is initialized. However, to use the `g77` intrinsics `GETARG()` and `IARGC()` the `main()` routine from the ``libf2c'` library must be used, either explicitly or implicitly by using a Fortran main program. This `main()` program calls `MAIN__()` (where the names are C-type `extern` names, i.e. not mangled). You need to provide this nullary procedure as the entry point for your C code if using ``libf2c'`'s `main`. In some cases it might be necessary to provide a dummy version of this to avoid linkers complaining about failure to resolve `MAIN__()` if linking against ``libf2c'` and not using `main()` from it.

Go to the first, previous, next, last section, table of contents.