This C++ program is a simple example of how a language like Fortran 77 can be converted into usable C++ code. The C++ code leaves the original intent of the program intact, but the current example does not handle special cases like string formatting, such as the
FORMAT statement. In addition,
GOTO statements are converted as they are in the original Fortran program, which in some cases may lead to spaghetti-like code.
The program works by first asking the user for a file list after loading the configuration file. The configuration file allows the program settings to be modified without recompiling. The main program loops the strings of files and processes them one at a time. All of the file I/O is handled within the
convertFortran subroutine. After the entire input file is read to memory into
QStringList, which is only a list of strings, each line of the program is processed one at a time.
The C++ example program was also written using Qt to allow the program to be compiled across many platforms, as many Fortran source code files may be located on legacy systems. Please go to Qt-TrollTech for the latest Qt library download.
Using the Code
determineFortranType takes the Fortran code in and passes back, by reference: the stripped Fortran statement, the label and the indication if the line is a continuation line. The first item that is processed is the replacement of tabs with the correct number of spaces, because column positions are important. Next, the subroutine determines if the line is empty. If so, an enum
eBlank is returned. The subroutine tries to determine if the statement is a comment or a
# statement, as dictated by the first character. Then the reserved statement numbers are stripped from the line, the continuation character is determined and the code statement is stripped from the Fortran line.
FortranType determineFortranType( QString fullLine,
QString &code, QString &label, bool &isCont )
isCont = false;
code = "";
label = "";
QString line = fullLine;
line.replace( "\t", " " );
int length = line.length();
if ( length == 0 )
if ( line == 'c' || line == 'C' || line == '*' )
if ( length > 2 )
code = line.right( length - 2 );
if ( line == '#' )
code = line;
if ( line.find( "include", 0, FALSE ) == 1 )
else if ( line.find( "define", 0, FALSE ) == 1 )
else if ( line.find( "ifdef", 0, FALSE ) == 1 )
else if ( line.find( "endif", 0, FALSE ) == 1 )
QString reserved, cont;
reserved = line.left( 6 );
cont = line.mid( 5, 1 );
code = line.right( length-6 ).stripWhiteSpace();
if ( ( cont != "0" && cont != " " ) || reserved == '&' )
isCont = true;
if ( reserved == '&' )
reserved = "";
label = "";
if ( cont != "0" )
reserved = reserved.left( 5 );
label = reserved.stripWhiteSpace();
if ( isCont )
if ( code.find( "program", 0, FALSE ) == 0 )
else if ( code.find( "subroutine", 0, FALSE ) == 0 )
else if ( code.find( "parameter", 0, FALSE ) == 0 )
else if ( code.find( "write", 0, FALSE ) == 0 )
else if ( code.isEmpty() && !label.isEmpty() )
else if ( code.isEmpty() )
for ( int ii = 0; ii < _ReservedLength; ii++ )
if ( code.find( FortranReserved[ii], 0, FALSE ) == 0 )
If the line is a continuation line, the enum
eCode is returned. This is because each continuation line is added to the previous one in the subroutine
convertFortran. Lastly, the first keyword of the stripped code statement is matched to determine the Fortran type that is returned back as an enum. Also, if a match is not found, the program assumes that the line must be code, such as an assignment. In this case, it returns the default enum
Points of Interest
The work is mostly accomplished inside the subroutine
determineFortranType. The above code snippet is part of the function that determines: the statement type, the code section, the label (if any) and finally, whether or not the line is a Fortran continuation line. Because Fortran code must follows the rules below, coding was made easier.
- Columns 1 through 5 are reserved for statement numbers or what are also called labels.
- Column 6 allows any non-blank character except a zero to indicate the continuation of a Fortran line. I've also seen the character
& in column 1 used for this in addition.
- Fortran statements start in column 7 and can extend to column 72.
Also, remember that this process in not complete. Indices must be changed from the default one-based to the C++ zero-based. Also, multi-dimensional arrays in C/C++ are opposite from the Fortran language. Some key words will require rework for the converted code. As an example, the
DATA statements will both require some rework. Also,
GOTO statements can be eliminated or reworked as C++ switches. In the example provided, the
GOTO to label 1 has an
IF statement that could be switched out to a C++
while statement, which totally eliminates the need for a
GOTO statement. Additional note: be careful with the
COSD intrinsic functions, as they use degrees and not radians.
Web pages that may help:
- Version 1.0: Program creation. -- July 21, 2007
- Version 1.1: Added Fortran types to the enum list. Added COMMON conversion. Moved all local variables into one section. -- August 02, 2007
I can alternately be contacted at firstname.lastname@example.org