1. Promula® FORTRAN to C Translator/Compiler
2. How Does It Work?
3. Rationale for Developing promulaFortran
4. Downsizing Mainframe Codes for Use on the PC DOS Platform
5. Dealing with FORTRAN Dialect Problems
6. Dealing with C Types and FORTRAN Types
7. Dealing with FORTRAN Input/Output in C
8. Runtime Library
9. Dealing with COMMON Blocks
10. Allocation of Local Variables
11. A Sample Translation to C
12. Licensing
13. Pricing
14. Customer References

1. Multi-Dialect, Multi-Platform Processing. promulaFortran translates both standard and nonstandard dialects of FORTRAN. Both the ANSI FORTRAN 66 and the ANSI FORTRAN 77 dialects are supported, and several Fortran 90 extensions are included as well. Several commercial, extended dialects of FORTRAN -such as VAX, PDP, PRIME, Honeywell, Data general, and SUN -are also supported. The C source code generated can be ported to any platform that supports a standard C compiler. In addition, the translator can be configured to process dialect extensions not included in the default dialect definition.
    
2. Completeness. The syntax processor handles almost all features of standard and extended FORTRAN dialects, including structures and pointer variables. On the execution side, its comprehensive runtime library covers the full functionality of all of the above FORTRAN dialects (full FORTRAN I/O, complex arithmetic, NAMELIST, DECODE/ENCODE, DEFINE FILE, B-FORMAT, %VAL, %REF, %DESCR, STRUCTURE, RECORD, embedded and inline comments, etc.).
    
3. Correctness. Since promulaFortran compiles FORTRAN to C, i.e., performs both a syntactic and a semantic transformation of FORTRAN to C, the translated C code is both compilable and "correct,” that is, it yields reproducible results -which is not the case with other translation tools which are limited to simple syntax transformations that yield partial or incorrect translations. The compiler has been tested on several platforms with Version 2.0 of the FORTRAN compiler Validation System from the Federal Software Testing Center and passed the test at the full validation level on all platforms.
    
4. Software Conversion. promulaFortran is a highly efficient portation tool. It can convert thousands of lines of code per minute, depending on the platform, and achieves 100 percent conversion rates routinely, “right out of the box." By removing the need to make any manual source changes during the conversion, it makes the porting process repeatable and allows for rigorous port verification.
    
5. Language Migration. promulaFortran is a language migration tool. It helps you migrate from maintaining your applications in FORTRAN to maintaining them in C. You can treat the C code generated by promulaFortran as an intermediate step in a compilation or as the end product of an automatic translation process.
    
6. Documentation. According to a Computer Language review (October, 1988), “the documentation for promulaFortran is excellent. It meticulously details the translation process, how to create your own dialects, all the runtime library routines, the inner pseudocode into which promulaFortran translates your FORTRAN, how this pseudocode translates back to C, and more." In addition, the language reference component of the documentation describes the actual FORTRAN dialect that promulaFortran supports.
    
7. Error Processing. When a FORTRAN error occurs, an error message is issued and the user has the option to exit or continue processing. A command-line switch allows the user to select from five different error handling options:
   1. Stop translation when the first error is encountered
   2. Translate all errors into non-compilable FORTRAN ERROR statements
   3. Translate all errors into non-linkable FORTRAN ERROR function calls
   4. Translate all errors into executable print-error-message statements
   5. Translate all errors into warning comments.

1. The FORTRAN bias generates C output which is as close to the original FORTRAN as possible and is aimed at easing the transition of those users who are presently FORTRAN programmers but wish to (or must) become C programmers.
2. The C bias generates C output which looks much like a standard C program and is aimed at those users who are C programmers but must now take over the maintenance of a FORTRAN code
3. The optimized bias generates C output which is designed to compile as quickly as possible and to produce an efficient as possible executable module. This output is not very readable and is aimed at those users who wish to continue to program in FORTRAN. For these users, the C output is of no importance as such. It is merely an intermediate step and serves as input to the C compiler.

1. “Design of a FORTRAN to C Translator," Fred K. Goodman, Vol. 1, December, 1989 and March, 1990.
2. “FORTRAN to C: Numerical Issues," Fred K. Goodman, Vol. 2, June, 1990.
3. “FORTRAN to C: Character Manipulation," Fred K. Goodman, Vol. 2, September, 1990.

   DIMENSION A(10000,20),B(10000,20)

would be

   static float a[20][10000],b[20][10000];

The fact that this is syntactically error-free is of little significance since no C compiler presently available for the PC will accept it. Faced with this problem, what do you do? In the brute force approach, you would probably go through the code -maybe all 10000 lines of it -and change the references to arrays A and B to some sort of disk reference. You would probably also analyze how these arrays are referenced so that you could make the disk accesses as efficient as possible.

   DO10I=1,5 and DO10I=1.5

or

   DO 10 I = 1,5 and DO 10 I = 1.5

and translates them all correctly.

promulaFortran deals with all of the “violations" of standard character manipulation including hiding character values in arithmetic variables, mixing character and non-character variables in COMMON blocks, equivalencing character variables with arithmetic variables, and assuming that CHARACTER*N and CHARACTER*1(N) have the same memory representations.

• signed char
• unsigned char
• short signed int
• short unsigned int
• long signed int
• long unsigned int
• float
• double

1. The default is to declare the COMMON block identifiers simply as external void pointers and then to assign them locally to a structure pointer whose members are defined in the same manner as the COMMON definition in the routine. This technique works in all cases except where alignments are needed.
    
2. In cases where COMMON blocks are always defined in the same manner, the common blocks are simply defined as external structures. This gives more efficient code than the technique above.
    
3. The most efficient technique can be used when no games are played with the common blocks at all. Then, the blocks themselves are removed and the variables within them become external variables directly.
    
4. The final technique is used when an exact block layout is required. The COMMON block is declared as an external pointer to a char. The variable positions within the block are calculated with user-supplied alignment and size specifications. Actual variable references then become references to the COMMON block name plus the calculated position.

INPUT SUBROUTINE EX001(VAL,N,XBAR,VAR) DIMENSION VAL(N) XBAR=0.0 VAR=0.0 DO 10 J = 1,N XBAR = XBAR + VAL(J) 10 CONTINUE XBAR = XBAR/N DO 15 J = 1,N S = VAL(J) - XBAR VAR = VAR + S*S 15 CONTINUE VAR = VAR/(N-1) RETURN END	OUTPUT void ex001(val,n,xbar,var) int n; float *val,*xbar,*var; { auto int j; auto float s; *xbar = *var = 0.0; for(j=0; j<n; j++) *xbar += *(val+j); *xbar /= n; for(j=0; j<n; j++) { s = *(val+j)-*xbar; *var += (s*s); } *var /= (n-1); }	NOTES    (1)         (2) (3)-(6) (5) (3) (4) (5) (7) (5)
Note (1) that the parameter “n" is not declared as a pointer, since it is not changed within the routine. promulaFortran uses what are called “prototypes" of subprogram arguments so that it can generate optimal calling sequences. These “prototypes" may be specified by the user or may be determined internally by the translator. The above was internally determined by the translator.   Note (2) that C allows multiple assignments to the same value to be written together. The translator looks for such assignments and combines them whenever possible.   Note (3) that in FORTRAN the default base for a subscript is 1. Thus, all do loops which generate subscripts tend to start at 1. In C, however, subscripts start at zero. This fact makes for much more efficient code. The translator looks for do loops whose only purpose is to move through array subscripts and reduces their range to start at zero, thus producing a very natural looking for-statement and optimizing subscript expressions.   Note (4) that C has “++" and “--" operators which take advantage of the fact that most computers have increment and decrement operators. The translator uses these operators whenever possible.   Note (5) that C has operators like “+=“, “-=“, “*=“, “/=“, etc. The use of these operators ensures that the address of the left-hand-side of the assignment will only be computed as often as necessary. promulaFortran uses these operators.   Note (6) that the do loop running to statement 10 in the FORTRAN code is collapsed into a single compound statement, and that the now unneeded statement label is removed.   Note (7) that though the do loop statements in loop 15 cannot be reduced to a single statement, the statement label can still be removed.

1. Single User License for use by a single user
2. Group License (2-5 users) for use by a small group of users
3. Custom License for use in support of migration projects with specific custom requirements. This includes both product and varying levels of product customization services, as needed by the migration project.
4. Enterprise License for use by an enterprise in support of large-scale migration projects. This includes both product and software conversion services, as needed by the migration project.