DIGITAL Fortran 90 conforms to American National Standard Fortran 90 (ANSI X3.198-1992)¹ and includes support for the High Performance Fortran Language Specification.

The ANSI committee X3J3 is currently answering questions of interpretation of Fortran 90 language features. Any answers given by the ANSI committee that are related to features implemented in DIGITAL Fortran 90 may result in changes in future releases of the DIGITAL Fortran 90 compiler, even if the changes produce incompatibilities with earlier releases of DIGITAL Fortran 90.

DIGITAL Fortran 90 also includes support for programs that conform to the previous Fortran standards (ANSI X3.9-1978 and ANSI X3.0-1966), the International Standards Organization standard ISO 1539-1980 (E), the Federal Information Processing Institute standard FIPS 69-1, and the Military Standard 1753 Language Specification.

DIGITAL Fortran 90 provides a number of extensions to the Fortran 90 Standard. DIGITAL Fortran 90 extensions to the Fortran 90 standard are generally provided for compatibility with DIGITAL Fortran extensions to the ANSI FORTRAN-77 standard and to support the High Performance Fortran (HPF) Language Specification.²

When creating new programs that need to be standard-conforming for portability reasons, you should avoid or minimize the use of extensions to the Fortran 90 standard. Extensions to the Fortran 90 standard are identified visually in the DIGITAL Fortran Language Reference Manual, which defines the DIGITAL Fortran 90 language.

This chapter provides:

• A summary of aspects of the Fortran 90 language related to the DIGITAL Fortran 90 program development environment on DIGITAL UNIX systems ( Section 1.1)
• The commands used to create, compile, link, and run a small program ( Section 1.2)
• The commands used to create, compile, link, and run a sample main program that has separate files for a module and a function declaration ( Section 1.3)
• An overview of the major software components associated with DIGITAL Fortran 90 ( Section 1.4)
• A summary of the important program development stages and tools ( Section 1.5)

1.1 The DIGITAL Fortran 90 Programming Environment

The following aspects of Fortran 90 are relevant to the compilation environment and should be considered before extensive coding begins:

• To install DIGITAL Fortran 90 on your system, first obtain the UNIX Software Program Library Compact Disc (CD) media. Then perform the installation as described in DIGITAL Fortran Installation Guide for DIGITAL UNIX Systems.
• Once DIGITAL Fortran 90 is installed, you can:
  • Use the f90 command to compile and link programs.
  • Use the online f90(1) reference page and this manual to provide information about the f90 command.
  • Install the DIGITAL Parallel Software Environment to run a program compiled for parallel HPF execution on more than one processor. Parallel HPF programs must be compiled with the -wsf option. To indicate parallel execution characteristics, use the f90 options described in Section 3.87 and the High Performance Fortran ( !hpf$ ) directives described in the DIGITAL High Performance Fortran 90 HPF and PSE Manual.
• Make sure you have adequate stack size, especially if your programs use large arrays as data. Users may be able to overcome this problem by increasing the per-process data limit, using the limit command (C shell) or ulimit command (Korn and Bourne shells) (see csh(1), ksh(1), or sh(1)).
  Determine whether the maximum per-process data size is already allocated by checking the value of the maxdsiz parameter in the system configuration file. If necessary, increase its value. Changes to the configuration file do not take effect until the operating system kernel has been rebuilt and the system has been rebooted.
  For example, the following C shell commands check the current stacksize limit and then increase the size to a larger value (if this limit can be increased from your process):

  % limit stacksize stacksize 4096 kbytes % limit stacksize 32676 % limit stacksize stacksize 32676 kbytes

  
  You can also remove the limitation on stacksize:

  % limit stacksize unlimited

  
  Similarly, with the Korn and Bourne shells, use the ulimit command with the -s option (see ksh(1) and sh(1)). For example:

  $ ulimit -s 4096 $ ulimit -s 32676 $ ulimit -s 32676

  
  If you are unable to increase your limits to a value needed by your program, contact your system administrator.

• Make sure you have an adequate process file descriptor limit, especially if your programs use a large number of module files.
  During compilation, your application may attempt to use more module files than your descriptor limit allows. In this case, the DIGITAL Fortran 90 compiler will close a previously opened module file before it opens another to stay within your descriptor limit. This results in slower compilation time. Increasing the descriptor limit may improve compilation time in such cases.
  Users can view and usually increase the per-process limit on the number of open files by using the limit command (C shell) or ulimit command (Korn and Bourne shell) (see csh(1), ksh(1), or sh(1)).
  Determine whether the maximum per-process limit is already allocated by checking the value of the appropriate descriptor parameter in the system configuration file. If necessary, increase its value. Changes to the configuration file do not take effect until the operating system kernel has been rebuilt and the system has been rebooted.
  For example, the following C shell commands check the current limits and then increase the size to a larger value for cases where this limit can be increased from your process:

  % limit descriptor descriptors 100 files % limit descriptor 4096 % limit descriptor descriptors 4096 files

  
  With the Korn and Bourne shells, you can use the ulimit command with the -n option (see ksh(1) and sh(1)). For example:

  $ ulimit -n 2048 $ ulimit -n 4096 $ ulimit -n 4096

• DIGITAL Fortran 90 supports the use of the environment variable TMPDIR to specify a working directory (instead of /tmp ) to contain temporary files created during compilation. Several other environment variables can similarly be used during program execution (see Appendix B).
  If you need to set environment variables frequently, consider setting these in your .login file or appropriate shell initialization file ( .cshrc or .profile ).
• Your source files can be in free or fixed form. The f90 command recognizes certain file suffixes as files containing fixed form or files containing free form. You can also specify an option on the f90 command line to specify the source form. Recognized file suffixes are described in Section 2.1.1.
  A special type of fixed source form is tab form (a DIGITAL extension). For details about the source forms, see the DIGITAL Fortran Language Reference Manual.
• Each source file to be compiled must contain at least one program unit (main program, external subroutine, external function, module, block data). Consider the following aspects of program development:
  • Modularity and Efficiency
    For a large application, using a set of relatively small source files promotes incremental application development.
    When compiling multiple source files into a single object file with a single f90 command, certain interprocedure optimizations will occur to minimize run-time execution time (unless you specify a lower level of optimization).
  • Code re-use
    Modules, external subprograms, and included files allow re-use of common code. Code used in multiple places in a program should be placed in a module, external subprogram (function or subroutine), or included file.
    When using modules and external subprograms, there is one copy of the code for a program. When using INCLUDE statements, the code in the specified source file is repeated once for each INCLUDE statement.
    In most cases, using modules or external subprograms makes programs easier to maintain and minimizes program size.

For More Information:

• On modules, see Section 2.1.4.
• On the types of subprograms and using an explicit interface to a subprogram, see Chapter 11.
• On performance considerations, including compiling source programs for optimal run-time performance, see Chapter 5.

Example 1-1 shows a short Fortran 90 main program using free form source.

Example 1-1 Sample Main Program

! File hello.f90 PROGRAM HELLO_TEST print *, 'hello world' print *, ' ' END PROGRAM HELLO_TEST

To create and revise your source files, use a text editor, such as vi or emacs . For instance, to use vi to edit the file hello.f90 , type:

% vi hello.f90

The following f90 command compiles the program named hello.f90 and automatically uses ld to link the main program into an executable program file named a.out :

% f90 hello.f90

The f90 command automatically passes a standard default list of DIGITAL UNIX and DIGITAL Fortran 90 libraries to the ld linker. In this example, because all external routines used by this program reside in these standard libraries, additional libraries or object files are not specified on the f90 command line.

If your path definition includes the directory containing a.out , you can run the program by simply typing its name:

% a.out

If the executable image is not in your current directory path, specify the directory path in addition to the file name.

1.3 Creating and Running a Program Using a Module and Separate Function

Example 1-2 shows a sample Fortran 90 main program using free source form that uses a module and an external subprogram.

The function CALC_AVERAGE is contained in a separately created file and depends on the module ARRAY_CALCULATOR for its interface block.

Example 1-2 Sample Main Program that Uses a Module and Separate Function

! File: main.f90 ! This program calculates the average of five numbers PROGRAM MAIN USE ARRAY_CALCULATOR (1) REAL, DIMENSION(5) :: A = 0 REAL :: AVERAGE PRINT *, 'Type five numbers: ' READ (*,'(F10.3)') A AVERAGE = CALC_AVERAGE(A) (2) PRINT *, 'Average of the five numbers is: ', AVERAGE END PROGRAM MAIN

1. The USE statement accesses the module ARRAY_CALCULATOR. This module contains the function declaration for CALC_AVERAGE (use association).
2. The 5-element array is passed to the function CALC_AVERAGE, which returns the value to the variable AVERAGE for printing.

Example 1-3 shows the module referenced by the main program. This example program shows more Fortran 90 features, including an interface block and an assumed-shape array.

Example 1-3 Sample Module

! File: array_calc.f90. ! Module containing various calculations on arrays. MODULE ARRAY_CALCULATOR INTERFACE FUNCTION CALC_AVERAGE(D) REAL :: CALC_AVERAGE REAL, INTENT(IN) :: D(:) END FUNCTION CALC_AVERAGE END INTERFACE ! Other subprogram interfaces... END MODULE ARRAY_CALCULATOR

Example 1-4 shows the function declaration CALC_AVERAGE referenced by the main program.

Example 1-4 Sample Separate Function Declaration

! File: calc_aver.f90. ! External function returning average of array. FUNCTION CALC_AVERAGE(D) REAL :: CALC_AVERAGE REAL, INTENT(IN) :: D(:) CALC_AVERAGE = SUM(D) / UBOUND(D, DIM = 1) END FUNCTION CALC_AVERAGE

1.3.1 Commands to Create the Executable Program

% f90 -c array_calc.f90 % f90 -c calc_aver.f90 % f90 -c main.f90 % f90 -o calc main.o array_calc.o calc_aver.o

In this sequence of f90 commands:

• The -c option (used in the first three commands) prevents linking and retains the .o files.
• The first command creates the files array_calculator.mod and array_calc.o (the name in the MODULE statement in Example 1-3 determines the name of module file array_calculator.mod ). Module files are written into the current working directory.
• The second command creates the file calc_aver.o .
• The third command creates the file main.o and uses the module file array_calculator.mod .
• The last command links all object files into the executable program named calc . To link files, use the f90 command instead of the ld command.

To allow more optimizations to occur (such as the inline expansion of called subprograms), the entire set of three source files can be compiled and linked together with a single f90 command:

% f90 -o calc array_calc.f90 calc_aver.f90 main.f90

The order in which the file names are specified is significant. This f90 command:

• Compiles the file array_calc.f90 , which contains the module definition, and creates its object file and the file array_calculator.mod .
• Compiles the file calc_aver.f90 , which contains the external function CALC_AVERAGE.
• Compiles the file main.f90 (main program). The USE statement references the module file array_calculator.mod .
• Uses ld to link the main program and all object files into an executable program file named calc .

If your path definition includes the directory containing calc , you can run the program by simply typing its name:

% calc

When running the sample program, the PRINT and READ statements in the main program result in the following dialogue between user and program:

Type five numbers: 55.5 4.5 3.9 9.0 5.6 Average of the five numbers is: 15.70000

1.3.3 Debugging the Sample Program

To debug a program with the DIGITAL Ladebug Debugger, compile the source files with the -g and -ladebug options to request additional symbol table information for source line debugging in the object and executable program files. The following f90 command also uses the -o option to name the executable program file calc_debug :

% f90 -g -ladebug -o calc_debug array_calc.f90 calc_aver.f90 main.f90

The Ladebug debugger has a character-cell interface ( ladebug command) and a windowing interface.

For instance, to use the character-cell interface to debug an executable program named calc_debug on a system running DIGITAL UNIX Version 4.0, type the following command:

% ladebug calc_debug

The DIGITAL UNIX operating system provides the Ladebug debugger and the dbx debugger, both of which can be used to debug DIGITAL Fortran 90 programs.

For more information on running the program within the debugger, see Chapter 4.

1.4 The f90 Command and Related Software Components

DIGITAL Fortran 90 provides the standard features of a compiler and linker. DIGITAL Fortran 90 also supports the use of preprocessors and other compilers.

Compiling and linking are usually done by a single f90 command. The f90 command allows you to use:

• The cpp preprocessor (if needed)
• The DIGITAL Fortran 90 compiler
• The cc compiler (if needed)
• The ld linker

The f90 command invokes a driver program that is the actual user interface to the DIGITAL Fortran 90 compiler. It accepts a list of command options and file names, and causes one or more programs (preprocessor, compiler, assembler, or linker) to process each file.

After the DIGITAL Fortran 90 compiler processes the appropriate files to create one or more object files, the driver program passes a list of files, certain options, and other information to the cc compiler. The cc compiler processes relevant non-Fortran files and information (including running cpp ) and passes certain information (such as .o object files) to the ld linker.

The f90 command executes each related program (preprocessor, compiler, assembler, or linker) in a sequential manner. If the cpp preprocessor is used, cpp is executed once for each file.

If any processor does not return a normal status, further processing is discontinued and the f90 command displays a message identifying the program (and its returned status, in hexadecimal) before terminating its own execution.