Converting FORTRAN to C / C++

Question

As part of my Final Year Project, I need to convert some FORTRAN code into C or C++ (it doesn't matter which language as long as I can understand it, and I can understand C style languages).

I have discovered f2c, a program that allegedly converts FORTRAN to C, and tried to install it, following instructions, by saving a makefile.vc file on my drive and then doing

copy makefile.vc makefile
nmake

(here is the part of the README file about installing f2c that is included in the f2c download page)

To compile f2c on Linux or Unix systems, copy makefile.u to makefile, edit makefile if necessary (see the comments in it and below) and type "make" (or maybe "nmake", depending on your system).

To compile f2c.exe on MS Windows systems with Microsoft Visual C++,

copy makefile.vc makefile nmake

With other PC compilers, you may need to compile xsum.c with -DMSDOS (i.e., with MSDOS #defined).

If your compiler does not understand ANSI/ISO C syntax (i.e., if you have a K&R C compiler), compile with -DKR_headers .

On non-Unix systems where files have separate binary and text modes, you may need to "make xsumr.out" rather than "make xsum.out".

I am running x64 bit version of Windows Vista and tried "nmake", but I get

'nmake' is not recognised as an internal or external command, operable program or batch file.

I downloaded Nmake15.exe after some searching but it doesn't work on x64 bit machines and apparently there is not version of it that does. So I downloaded the Windows SDK, after being told that would work, but it didn't change anything.

Where have I gone wrong in all this, if I have, and is there any way of converting that FORTRAN code into C or C++?

Answer 1

I found there is a small toolkit named fable fable - Automatic Fortran to C++ conversion which is dedicated to such conversion.

THere is also a review of such a tool. Abstract from the review authors:

Background

In scientific computing, Fortran was the dominant implementation language throughout most of the second part of the 20th century. The many tools accumulated during this time have been difficult to integrate with modern software, which is now dominated by object-oriented languages.

Results

Driven by the requirements of a large-scale scientific software project, we have developed a Fortran to C++ source-to-source conversion tool named FABLE. This enables the continued development of new methods even while switching languages. We report the application of FABLE in three major projects and present detailed comparisons of Fortran and C++ runtime performances.

Conclusions

Our experience suggests that most Fortran 77 codes can be converted with an effort that is minor (measured in days) compared to the original development time (often measured in years). With FABLE it is possible to reuse and evolve legacy work in modern object-oriented environments, in a portable and maintainable way. FABLE is available under a nonrestrictive open source license. In FABLE the analysis of the Fortran sources is separated from the generation of the C++ sources. Therefore parts of FABLE could be reused for other target languages.

Answer 2

f2c really is the way to go, provided you have F77 code. If you have F90 or later then f2c won't help. I've used f2c many many times with great success, so long as you remember the -a switch.

As an aside I would rate f2c as one of the all time great codes!

Answer 3

You need to be clear why you are doing this. Is it because the functionality you need is ONLY available in some legacy FORTRAN? I had this problem many years ago when I needed a general matrix inversion algorithm, that was only available in FORTRAN. It wasn't easy to understand - no comments and variables named like G(J). I converted it to C using f2c and it ran perfectly. But it was even harder to understand. Two points were that FORTRAN counts from 1 and C from 0, so there were lots of i+1 and j-1. Also arguments had to be implemented by reference.

Later I had to run this in Java. Still no other algorithm, so I converted the C to Java. This was really painful. And I still didn't understand what has happening.

And after a year or two it stopped working!

But, luckily, now there are several Java implementations.

So if you can explain your real requirements maybe we can help. I hope that this isn't an assignment, because if so it's (IMO) a poor one. If there is some magic legacy code, suggest you try as hard as possible to find a modern equivalent.

Answer 4

The method I've been using for conversion so far is semi-automated: lots of editor and text scripts.

First, collimate all the Fortran source into a single file (placing markers as appropriate to allow the files to be re-separated).

Next, convert the numeric labels to named labels (e.g. adding an L before them for gotos and F for formats). Make the appropriate changes in the places that reference the labels.

Next, mark off the label - continue combinations and the statement continuations (e.g. with a mark at the start of each line where they occur). Then re-join the label-continue and statement-continuation lines. In an editor like vi, that would mean doing a series of (say) 1000J's, and then a massive substitute :%s/#/^V^M/g if the start of line marker is a #. Since the continuation lines were specially marked as were the do-continue combos, then they get rejoined.

Ensure the if-labels and do-labels are separated (e.g. write a grep pattern to extract the relevant lines and then write a simple bracket-matching program to check them out). Once separated, you can then turn the do-continues into brackets.

Turn the if-then-else, and dowhile/enddo, subroutine/endsub, etc. into brackets. Make subroutine void, pony up fake names for the basic types (e.g. Boolean, Character, Integer, Real, Double, Complex, Complex).

Comments are converted over to C++ // comments; both the column 0 and ! comments.

Then you can re-prototype the functions. This is effectively a KR to ANSI-C conversion and requires a simple program to read the function headers and variable declarations to match them off. Ideally you may want to first put the variable declarations as one to a line. This also requires an edit script and a utility. For instance a "Double A, B, C, ..." would be converted to "#Double\nA\nB\n." and then a utility is set up to prefix all the non-# lines with the most recent preceding # line.

Parameter statements get rejoined to the type declarations and converted to "const" statements. Saves get converted to static declarations. Commons I haven't yet figured out a good way to work with.

Now the HARD parts come next: the array dimensioning, variable in/out analysis (to determine which variables need to be passed by value or by reference). You should get a C compiler that recognizes the reference type & or use C++. For array-redimensioning you may also need to go over to C++ which allows [] to be redefined.

The in-out analysis is something I haven't yet worked through, likewise the redimensioning. But at this point, the relevant source is mostly in C or C++ at this stage.

Be warned: Fortran 2010allows parallel processing, which goes beyond C and even C++ (except for their multithreaded abilities). If you programs have these in them, things will become a lot harder.

Answer 5

You aren't real clear on this, but it sounds like you want to study the code, and in order to do that you want to convert it to C or C++. If you want to use the code rather than study it, then I'm off-base here, and you should look for Fortran compilers.

Give up. You can't find any way of translating idiomatic Fortran to idiomatic C or C++. There's subtle semantic differences between the languages, and in order to get it right the translation program needs to be very precise, and account for lots of things, and make obscure function calls, and that can be very confusing. You will not get readable C or C++.

Instead, you should learn the appropriate version of Fortran. If you understand C and C++, it shouldn't be at all hard to learn. It's just another language, and it won't have much in the way of new concepts.

Answer 6

Direct conversion to/from FORTRAN to C or to procedural version of C++ should not be complicated and is recommended mainly because you will learn the inner working of FORTRAN implementation.

Automatic tools like f2c will produce messy code with double underscore like this: __i (i being the loop counter variable).

Answer 7

If I had to install f2c on Windows I would use Cygwin. Now there is g77 I expect not many people use f2c any more.

Answer 8

I'm going to answer only the very last part of your question:

is there any way of converting that FORTRAN code into C or C++?

Yes there is: Read the fortran code, and write the equivalent C statements in a C file. They are both imperative languages. The syntax is different but not impossible to decode. This will likely give you much better results than an auto-converter, and will also give you an much deeper understanding of how the original program works.

Answer 9

Have you tried the binary?

Answer 10

Do you have MS's Visual Studio installed? If so, nmake is available on the Visual Studio Command Line (not the normal command line). If not, perhaps try downloading and installing that?

Answer 11

The output of f2c could be converted into better readable C/C++ sources by using the f2cpp program which is available here.

It's written in Python and could be called together with f2c under Linux by e.g. a shell script

#!/bin/bash

f2c -a -C++ -p *.f
c2cpp.py *.c

where f2c converts the Fortran fixed format into C and c2cpp in human readable C/C++ sources.

License is GPL.