Converting Fortran into usable C++ pseudo-code

• Download demo project - 1.88 MB
• Download source - 10.2 KB

Introduction

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.

Qt Library

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

The subroutine 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;

    // Convert tabs into spaces first

    line.replace( "\t", "      " );

    int length        = line.length();
    if ( length == 0 ) 
    {
        return eBlank;
    }

    // Is it a comment?

    if ( line[0] == 'c' || line[0] == 'C' || line[0] == '*' ) 
    {
        
        if ( length > 2 )
            code = line.right( length - 2 );
        return eComment;
    }

    // Does this have the special # character

    if ( line[0] == '#' ) 
    {
    
        code = line;
        if ( line.find( "include", 0, FALSE ) == 1 )
            return eInclude;
        else if ( line.find( "define", 0, FALSE ) == 1 )
            return eDefine;
        else if ( line.find( "ifdef", 0, FALSE ) == 1 )
            return eIfDef;
        else if ( line.find( "endif", 0, FALSE ) == 1 )
            return eEndDef;
        else
            return eUnknown;
    }

    QString reserved, cont;
    
    // Pull the six reserved characters off and get 

    // continuation character and the code

    reserved    = line.left( 6 );
    cont    = line.mid( 5, 1 );
    code    = line.right( length-6 ).stripWhiteSpace();

    // Is this a continuation line, process it as one

    if ( ( cont != "0" && cont != " " ) || reserved[0] == '&' ) 
    {

        isCont = true;
        if ( reserved[0] == '&' ) 
        {
            reserved = "";
            label = "";
            return eCode;
        }
        
        if ( cont != "0" ) 
        {
            reserved = reserved.left( 5 );
        }
    }

    // Get label if any

    label = reserved.stripWhiteSpace();

    if ( isCont )
        return eCode;

    if ( code.find( "program", 0, FALSE ) == 0 ) 
    {
        return eBeginProgram;
    } 
    else if ( code.find( "subroutine", 0, FALSE ) == 0 ) 
    {
        return eSubroutine;
    } 
    else if ( code.find( "parameter", 0, FALSE ) == 0 ) 
    {
        return eParameter;
    } 
    else if ( code.find( "write", 0, FALSE ) == 0 ) 
    {
        return eWrite;
    } 
    ...
    } 
    else if ( code.isEmpty() && !label.isEmpty() ) 
    {
        return eLabel;
    } 
    else if ( code.isEmpty() ) 
    {
        return eBlank;
    }

    // Is this a Fortran variable?

    for ( int ii = 0; ii < _ReservedLength; ii++ ) 
    {
    
        if ( code.find( FortranReserved[ii], 0, FALSE ) == 0 )
            return eVariable;
    }

    // Must be code at this point

    return eCode;
}

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 eCode.

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.

1. Columns 1 through 5 are reserved for statement numbers or what are also called labels.
2. 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.
3. 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 ENTRY and 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 SIND and COSD intrinsic functions, as they use degrees and not radians.

Web pages that may help:

• LinuxTutorialMixingFortranAndC
• FORTRAN Help

History

• 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 jciii@earthlink.net