Return to style CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / new / help / src / f77

Annotation of 43BSDTahoe/new/help/src/f77/style, revision 1.1.1.1

1.1       root        1: .TI F77/STYLE "Sep. 4, 1985"
                      2: Programming Style: fsplit; include and parameter statements
                      3: 
                      4: This help file discusses several elements of programming style that
                      5: make Fortran programs easier to read, debug, and maintain.
                      6: 
                      7: First it is best to keep each program in a separate directory with each
                      8: subprogram in a separate file.  This minimizes compilation time as
                      9: you will only have to recompile those subroutines you have changed.
                     10: You can use the 'fsplit' utility to split up a source file with many
                     11: program units into separate files for each program unit, e.g.:
                     12: 
                     13:        fsplit bigsource
                     14: 
                     15: Put each common block declaration in a separate file and use the 
                     16: \&'include' statement to include the declaration in the source stream.
                     17: For example, if you have a common block 'c2' declared in several
                     18: program units as:
                     19: 
                     20: .nf
                     21:             ...
                     22:        integer cnt2, ivec2(20), tot
                     23:        common /c2/ cnt2, ivec2, tot
                     24:             ...
                     25: .fi
                     26: 
                     27: replace the declarations in the program units by:
                     28: 
                     29: .nf
                     30:             ...
                     31:        include 'c2.h'
                     32:             ...
                     33: .fi
                     34: 
                     35: and create a two line file 'c2.h':
                     36: 
                     37: .nf
                     38:        integer cnt2, ivec2(20), tot
                     39:        common /c2/ cnt2, ivec2, tot
                     40: .fi
                     41: 
                     42: This eliminates problems of different common block declarations in different
                     43: program units, and makes it easier to maintain the program.  Use the 'make'
                     44: utility to keep updating the object files if you change a common block
                     45: (see "help f77 make").
                     46: 
                     47: Use parameter statements to define symbolic constants that may be used in
                     48: dimension statements and arithmetic expressions.  You may say:
                     49: 
                     50: .nf
                     51:        parameter   (NROWS=20, NCOLS=30, LENBUF=800)
                     52:        parameter   (PI=3.1415926535)
                     53:        real        a(NROWS,NCOLS), b(NROWS,NCOLS)
                     54:        character   buffer(LENBUF)
                     55:                        ...
                     56:                    do 100 i = 1,NROWS
                     57:                        do  90 j = 1,NCOLS
                     58:                           a(i,j) = b(i,j)*PI
                     59:                        ...
                     60: .fi
                     61: 
                     62: instead of:
                     63: 
                     64: .nf
                     65:        real        a(20,30),b(20,30)
                     66:        character   buffer(800)
                     67:                        ...
                     68:                    do 100 i = 1,20
                     69:                        do  90 j = 1,30
                     70:                           a(i,j) = b(i,j)*3.1415926535
                     71:                        ...
                     72: .fi
                     73:                        
                     74: .LP
                     75: Parameters are useful for dimensions, and limits.  This way, you
                     76: don't have to remember the meaning of each number when you decide to
                     77: change the numerical values of the dimensions.  Parameters can also be
                     78: used for constants (e.g. 'PI' above).  Although the parameters are written
                     79: in upper case letters in this example, remember that f77 normally does
                     80: not distinguish case so that 'PI' and 'pi' are the same.
                     81: Parameter statements that are repeated in several subprogram units
                     82: should be put into include files.

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.