Compaq Fortran
User Manual for
OpenVMS Alpha Systems


Previous Contents Index


Chapter 2
Compiling Compaq Fortran Programs

This chapter describes how to use the FORTRAN command to compile your source programs into object files. The following topics are discussed:

2.1 Functions of the Compiler

The primary functions of the Compaq Fortran compiler are as follows:

When the compiler creates an object file, it provides the linker with the following information:

For More Information:

On the OpenVMS Linker, see Chapter 3.

2.2 The FORTRAN Command

The FORTRAN command initiates compilation of a source program.

The command has the following form:

FORTRAN [/qualifiers] file-spec-list[/qualifiers]

/qualifiers

Indicates either special actions to be performed by the compiler or special properties of input or output files.

file-spec-list

Specifies the source files containing the program units to be compiled. You can specify more than one source file:

When compiling source files with the default optimization (or additional optimizations), concatenating source files allows full interprocedure optimizations to occur.

In interactive mode, you can also enter the file specification on a separate line by typing the command FORTRAN, followed by a carriage return. The system responds with the following prompt:


 _File:

Type the file specification immediately after the prompt and then press Return.

2.2.1 Specifying Input Files and Source Form

If you omit the file type on the FORTRAN command line, the compiler searches first for a file with a file type of F90. If a file with a file type of F90 is not found, it then searches for file with a file type of FOR and then F.

For example, the following FORTRAN command line shows how file type searching occurs:


$ FORTRAN PROJ_ABC

This FORTRAN command searches for the following files:

  1. It searches first for PROJ_ABC.F90.
  2. If PROJ_ABC.F90 does not exist, it then searches for PROJ_ABC.FOR.
  3. If PROJ_ABC.F90 and PROJ_ABC.FOR do not exist, it then searches for PROJ_ABC.F.

Indicate the Fortran 90 source form used in your source files by using certain file types or a command-line qualifier:

For example, if you specify a file as PROJ_BL1.F90 on an FORTRAN command line (and omit the /SOURCE_FORM=FIXED qualifier), the FORTRAN command assumes the file PROJ_BL1.F90 contains free-form source code.

2.2.2 Specifying Multiple Input Files

When you specify a list of input files on the FORTRAN command line, you can use abbreviated file specifications for those files that share common device names, directory names, or file names.

The system applies temporary file specification defaults to those files with incomplete specifications. The defaults applied to an incomplete file specification are based on the previous device name, directory name, or file name encountered in the list.

The following FORTRAN command line shows how temporary defaults are applied to a list of file specifications:


$ FORTRAN USR1:[ADAMS]T1,T2,[JACKSON]SUMMARY,USR3:[FINAL]

The preceding FORTRAN command compiles the following files:


USR1:[ADAMS]T1.F90 (or .FOR or .F) 
USR1:[ADAMS]T2.F90 (or .FOR  or .F) 
USR1:[JACKSON]SUMMARY.F90 (or .FOR or .F) 
USR3:[FINAL]SUMMARY.F90 (or .FOR or .F) 

To override a temporary default with your current default directory, specify the directory as a null value. For example:


$ FORTRAN [OMEGA]T1, []T2

The empty brackets indicate that the compiler is to use your current default directory to locate T2.

FORTRAN qualifiers typically apply to the entire FORTRAN command line. One exception is the /LIBRARY qualifier, which specifies that the file specification it follows is a text library (positional qualifier). The /LIBRARY qualifier is discussed in Section 2.3.26.

You can specify multiple files on the FORTRAN command line. You can separate the multiple source file specifications with:

If you use multiple FORTRAN commands to compile multiple Compaq Fortran source files that are linked together into the same program, you must be consistent when specifying any qualifiers that effect run-time results. For instance, suppose you do the following:

  1. Specify /FLOAT=IEEE_FLOAT on one command line
  2. Specify /FLOAT=G_FLOAT on another command line
  3. Link the resulting object files together into a program

When you run the program, the values returned for floating-point numbers in a COMMON block will be unpredictable. For qualifiers related only to compile-time behavior (such as /LIST and /SHOW), this restriction does not apply.

2.2.3 Creating and Using Module Files

Compaq Fortran creates module files for each module declaration and automatically searches for a module file referenced by a USE statement (introduced in Fortran 90). A module file contains the equivalent of the module source declaration in a post-compiled, binary form.

2.2.3.1 Creating Module Files

When you compile a Compaq Fortran source file that contains module declarations, Compaq Fortran creates a separate file for each module declaration in the current process default device and directory. The name declared in a MODULE statement becomes the base prefix of the file name and is followed by the F90$MOD file type.

For example, consider a file that contains the following statement:


MODULE MOD1 

The compiler creates a post-compiled module file MOD1.F90$MOD in the current directory. An object file is also created for the module.

Compiling a source file that contains multiple module declarations will create multiple module files, but only a single object file. If you need a separate object file for each module, place only one module declaration in each file.

If a source file does not contain the main program and you need to create module files only, specify the /NOOBJECT qualifier to prevent object file creation.

To specify a directory other than the current directory for the module file(s) to be placed, use the /MODULE qualifier (see Section 2.3.30).

Note that an object file is not needed if there are only INTERFACE or constant (PARAMETER) declarations; however, it is needed for all other types of declarations including variables.

2.2.3.2 Using Module Files

Once you create a module file, you can copy module files into an appropriate shared or private directory. You reference a module file by specifying the module name in a USE statement (use association). For example:


 USE MOD1 

By default, the compiler searches for a module file named MOD1.F90$MOD in the current directory.

When selecting a directory location for a set of module files, consider how your application gets built, including:

Compaq Fortran allows you to use multiple methods to specify which directories are searched for module files:

To locate modules referenced by USE statements, the compiler searches directories in the following order:

  1. The current process device and directory
  2. Each directory specified by the /INCLUDE qualifier
  3. The directory specified by the logical name FORT$INCLUDE (unless /NOINCLUDE was specified).

You cannot specify a module (.F90$MOD) file directly on the FORTRAN command line.

Suppose you need to compile a main program PROJ_M.F90 that contains one or more USE statements. To request that the compiler look for module files in the additional directories DISKA:[PROJ_MODULE.F90] and then DISKB:[COMMON.FORT] (after looking in the current directory), type the following command line:


$ FORTRAN PROJ_M.F90 /INCLUDE=(DISKA:[PROJ_MODULE.F90],DISKB:[COMMON.FORT])

If you specify multiple directories with the /INCLUDE qualifier, the order of the directories in the /INCLUDE qualifier determines the directory search order.

Module nesting depth is unlimited. If you will use many modules in a program, check the process and system file limits (see Section 1.1).

For More Information:

2.2.4 Using Include Files and Include Text Library Modules

You can create include files with a text editor. The include files can be placed in a text library. If needed, you can copy include files or include text library to a shared or private directory.

When selecting a directory location for a set of include files or text libraries, consider how your application is to be built, including:

2.2.4.1 Using Include Files and INCLUDE Statement Forms

Include files have a file type like other Compaq Fortran source files (F90, FOR, or F). Use an INCLUDE statement to request that the specified file containing source lines be included in place of the INCLUDE statement.

To include a file, the INCLUDE statement has the following form:

INCLUDE 'name'
INCLUDE 'name.typ'

You can specify /LIST or /NOLIST after the file name. You can also specify the /SHOW=INCLUDE or /SHOW=NOINCLUDE qualifier to control whether source lines from included files or library modules appear in the listing file (see Section 2.3.42).

You can also include a file with a directory (and optionally the device name) specified with the following form:

INCLUDE '[directory]name'
INCLUDE '[directory]name.typ'

If a directory is specified, only the specified directory is searched. The remainder of this section addresses an INCLUDE statement where the directory has not been specified.

Compaq Fortran allows you to use multiple methods to specify which directories are searched for include files:

To locate include files specified in INCLUDE statements (without a device or directory name), the Compaq Fortran compiler searches directories in the following order:

  1. The current process default directory or the directory that the source file resides in (depending on whether /ASSUME=SOURCE_INCLUDE was specified)
  2. Each directory specified by the /INCLUDE qualifier
  3. The directory specified by the logical name FORT$INCLUDE (unless /NOINCLUDE was specified).

2.2.4.2 INCLUDE Statement Forms for Including Text Library Modules

Compaq Fortran provides certain include library modules in the text library FORSYSDEF.TLB. Users can create a text library and populate it with include library modules (see Section 2.4). Within a library, text library modules are identified by a library module name (no file type).

To include a text library module, the INCLUDE statement specifies the name of the library module within parentheses, as follows:

INCLUDE '(name)'

You can specify the library name before the library module name in the INCLUDE statement. For example:

INCLUDE 'MYLIB(PROJINC)'

Use one of the following methods to access a source library module in a text library:

2.2.4.3 Using Include Text Library Modules for a Specified Library Name

When the library is named in the INCLUDE statement, the FORTRAN command searches various directories for the named library, similar to the search for an include file.

Compaq Fortran allows you to use multiple methods to specify which directories are searched for named text libraries:

The Compaq Fortran compiler searches directories in the following order:

  1. The current process default directory or the directory that the source file resides in (depending on whether /ASSUME=SOURCE_INCLUDE was specified)
  2. Each directory specified by the /INCLUDE qualifier
  3. The directory specified by the logical name FORT$INCLUDE (unless /NOINCLUDE was specified).

You can specify /LIST or /NOLIST after the library module name. For example:


  INCLUDE 'PROJLIB(MYINC)/LIST' 

You can also specify the /SHOW=INCLUDE or /SHOW=NOINCLUDE qualifier to control whether source lines from included files or library modules appear in the listing file (see Section 2.3.42).

For More Information:

2.2.4.4 Using Include Text Library Modules for an Unspecified Library Name

When the INCLUDE statement does not specify the library, you can specify additional text libraries to be searched on the FORTRAN command line or by defining a logical name. The order in which the compiler searches for a library file follows:

You can specify /LIST or /NOLIST after the library module name. For example:


  INCLUDE '(MYINC)/NOLIST' 

You can also specify the /SHOW=INCLUDE or /SHOW=NOINCLUDE qualifier to control whether source lines from included files or library modules appear in the listing file (see Section 2.3.42).

For More Information:

2.2.5 Specifying Output Files

The output produced by the compiler includes the object and listing files. You can control the production of these files by using the appropriate qualifiers on the FORTRAN command line.

The production of listing files depends on whether you are operating in interactive mode or batch mode:

For command procedures that compile the application in either batch or interactive mode, consider explicitly specifying /NOLIST (or /LIST).

The compiler generates an object file by default. During the early stages of program development, you may find it helpful to use the /SYNTAX_ONLY or /NOOBJECT qualifiers to prevent the creation of object files until your source program compiles without errors. If you omit /NOOBJECT, the compiler generates object files as follows:

You can use both commas and plus signs in the same command line to produce different combinations of concatenated and separate object files (see the examples of the FORTRAN command at the end of this section).

To name an object file, use the /OBJECT qualifier in the form /OBJECT=file-spec. Otherwise, the object file has the file name of its corresponding source file and a file type of OBJ. By default, the object file produced from concatenated source files has the name of the first source file. All other file specification fields (node, device, directory, and version) assume the default values.

When creating object files that will be placed in an object library, consider using the /SEPARATE_COMPILATION qualifier, which places individual compilation units in a source file as separate components in the object file. This minimizes the size of the routines included by the linker as it creates the executable image. However, to allow more interprocedure optimizations, use the default /NOSEPARATE_COMPILATION.

For More Information:

2.2.6 Examples of the FORTRAN Command

The following examples show the use of the FORTRAN command.

2.2.6.1 Naming the Object File

The following FORTRAN command compiles the Compaq Fortran free-form source file (CIRCLE.F90) into an object file:


$ FORTRAN /OBJECT=[BUILD]SQUARE /NOLIST [Return]
_File: CIRCLE

The source file CIRCLE.F90 is compiled, producing an object file named SQUARE.OBJ in the [BUILD] directory, but no listing file.

2.2.6.2 Compiler Source Checking Only (No Object File)

The following FORTRAN command examines Compaq Fortran fixed-form source file (ABC.FOR) without creating an object file:


$ FORTRAN /NOOBJECT ABC.FOR 

The source file ABC.FOR is compiled, syntax checking occurs, but no object file is produced. The /NOOBJECT qualifier performs full compilation checking without creating an object file.

2.2.6.3 Requesting a Listing File and Contents

The following FORTRAN command compiles Compaq Fortran free-form source file (XYZ.F90) and requests a listing file:


$ FORTRAN /LIST /SHOW=INCLUDE /MACHINE_CODE XYZ.F90 

The source file XYZ.F90 is compiled, and the listing file XYZ.LIS and object file XYZ.OBJ are created. The listing file contains the optional included source files (/SHOW=INCLUDE) and machine code representation (/MACHINE_CODE).

The default is /NOLIST for interactive use and /LIST for batch use, so consider explicitly specifying either /LIST or /NOLIST.

2.2.6.4 Compiling Multiple Files

The following FORTRAN command compiles the Compaq Fortran free-form source files (AAA.F90, BBB.F90, and CCC.F90) into separate object files:


$ FORTRAN/LIST AAA.F90, BBB.F90, CCC.F90

Source files AAA.F90, BBB.F90, and CCC.F90 are compiled as separate files, producing:

The default level of optimization is used (/OPTIMIZE=LEVEL=4), but interprocedure optimizations are less effective because the source files are compiled separately.

The following FORTRAN command compiles the Compaq Fortran fixed-form source files XXX.FOR, YYY.FOR, and ZZZ.FOR into a single object file named XXX.OBJ:


$ FORTRAN XXX.FOR+YYY.FOR+ZZZ.FOR

Source files XXX.FOR, YYY.FOR, and ZZZ.FOR are concatenated and compiled as one file, producing an object file named XXX.OBJ. The default level of optimization is used, allowing interprocedure optimizations since the files are compiled together (see Section 5.1.2). In interactive mode, no listing file is created; in batch mode, a listing file named XXX.LIS would be created.

The following FORTRAN command compiles the Compaq Fortran free-form source files AAA.F90, BBB.F90, and CCC.F90 into two object files:


$ FORTRAN AAA+BBB,CCC/LIST

Two object files are produced: AAA.OBJ (comprising AAA.F90 and BBB.F90) and CCC.OBJ (comprising CCC.F90). One listing file is produced: CCC.LIS (comprising CCC.F90), since the positional /LIST qualifier follows a specific file name (and not the FORTRAN command). Because the default level of optimization is used, interprocedure optimizations for both AAA.F90 and BBB.F90 occur. Only interprocedure optimizations within CCC.F90 occur.

The following FORTRAN command compiles the Compaq Fortran free-form source files ABC.F90, CIRC.F90, and XYZ.F90, but no object file is produced:


$ FORTRAN ABC+CIRC/NOOBJECT+XYZ

The /NOOBJECT qualifier applies to all files in the concatenated file list and suppresses object file creation. Source files ABC.F90, CIRC.F90, and XYZ.F90 are concatenated and compiled, but no object file is produced.

2.2.6.5 Requesting Additional Compile-Time and Run-Time Checking

The following FORTRAN command compiles the Compaq Fortran free-form source file TEST.F90, requesting all possible compile-time diagnostic messages (/WARN=ALL) and run-time checking (/CHECK=ALL):


$ FORTRAN /WARNINGS=ALL /CHECK=ALL TEST.F90 

This command creates the object file TEST.OBJ and can result in more informational or warning compilation messages than the default level of warning messages. Additional run-time messages can also occur.

2.2.6.6 Checking Fortran 90 or 95 Standard Conformance

The following FORTRAN command compiles the Compaq Fortran free-form source file PROJ_STAND.F90, requesting compile-time diagnostic messages when extensions to the Fortran 90 language are detected without creating an object file:


$ FORTRAN /STANDARD=F90 /NOOBJECT PROJ_STAND.F90 

This command does not create an object file but issues additional compilation messages about the use of any nonstandard extensions to the Fortran 90 standard it detects.

To check for Fortran 95 standard conformance, specify /STANDARD=F95 instead of /STANDARD=F90.

2.2.6.7 Requesting Additional Optimizations

The following FORTRAN command compiles the Compaq Fortran free-form source files (M_APP.F90 and SUB.F90) as a single concatenated file into one object file:


$ FORTRAN /OPTIMIZE=(LEVEL=5,UNROLL=3) M_APP.F90+SUB.F90/NOLIST 

The source files are compiled together, producing an object file named M_APP.OBJ. The software pipelining optimization (/OPTIMIZE=LEVEL=4) is requested. Loops within the program are unrolled three times (UNROLL=3). Loop unrolling occurs at optimization level three (LEVEL=3) or above.

For More Information:

2.3 Qualifiers to the FORTRAN Command

FORTRAN command qualifiers influence the way in which the compiler processes a file. In some cases, the simplest form of the FORTRAN command is sufficient. Use optional qualifiers when needed.

You can override some qualifiers specified on the command line by using the OPTIONS statement. The qualifiers specified by the OPTIONS statement affect only the program unit where the statement occurs. For more information about the OPTIONS statement, see the Compaq Fortran Language Reference Manual.

2.3.1 FORTRAN Command Qualifier Syntax

Normal DCL parsing rules apply to the FORTRAN command, allowing you to abbreviate qualifier names and keywords as long as they are unique. For example, the following use of the FORTRAN command to specify the /ALIGNMENT qualifier as NATURAL and the /LIST qualifier is valid:


$ FORTRAN /ALIG=NAT /LIS EXTRAPOLATE.FOR

When creating command procedures, avoid using abbreviations for qualifiers and their keywords. Compaq Fortran might add new qualifiers and keywords for a subsequent release that makes an abbreviated qualifier and keyword nonunique in a subsequent release.

If you specify multiple keywords for a qualifier, enclose the keywords in parentheses:


$ FORTRAN /WARN=(ALIGN, DECLARATION) EXTRAPOLATE.FOR

To concatenate source files, separate file names with a plus sign (+) instead of a comma (,) (see Section 2.2.2).

2.3.2 Summary of FORTRAN Command Qualifiers

Table 2-1 lists the FORTRAN Command qualifiers, including their default values.

Sections 2.3.3 through 2.3.50 describe each qualifier in detail.

Table 2-1 FORTRAN Command Qualifiers
Qualifier Default
/ALIGNMENT or /NOALIGNMENT or
/ALIGNMENT=
  • rule
  • class = rule
  • ( class = rule [, ...])
  • [NO]SEQUENCE
  • ALL (or NATURAL)
  • NONE (or PACKED)
where:
class =
  • COMMONS
  • RECORDS
  • STRUCTURES
and
rule =
  • NATURAL
  • PACKED
  • STANDARD 2
  • [NO]MULTILANGUAGE 2



/ALIGNMENT=(COMMONS=(PACKED 1, NOMULTILANGUAGE), NOSEQUENCE 1, RECORDS=NATURAL)
/ANALYSIS_DATA[=filename] or /NOANALYSIS_DATA /NOANALYSIS_DATA
/ANNOTATIONS or /NOANNOTATIONS or
/ANNOTATIONS=
    • CODE
    • DETAIL
    • INLINING
    • LOOP_TRANSFORMS
    • LOOP_UNROLLING
    • PREFETCHING
    • SHRINKWRAPPING
    • SOFTWARE_PIPELINING
    • TAIL_CALLS
    • TAIL_RECURSION
    [, ...]
    • ALL
    • NONE

/NOANNOTATIONS
/ARCHITECTURE=
  • GENERIC
  • HOST
  • EV4
  • EV5
  • EV56
  • PCA56
  • EV6
  • EV67

/ARCHITECTURE=GENERIC 1
/NOASSUME or
/ASSUME=
    • [NO]ACCURACY_SENSITIVE
    • [NO]ALTPARAM
    • [NO]BUFFERED_IO
    • [NO]BYTERECL
    • [NO]DUMMY_ALIASES
    • [NO]FP_CONSTANT
    • [NO]INT_CONSTANT
    • [NO]MINUS0
    • [NO]PROTECT_CONSTANTS
    • [NO]SOURCE_INCLUDE
    [, ...]
    • ALL
    • NONE

/ASSUME=(ACCURACY_SENSITIVE 1, ALTPARAM, NOBUFFERED_IO, NOBYTERECL, NODUMMY_ALIASES, NOFP_CONSTANT, NOINT_CONSTANT, NOMINUS0, PROTECT_CONSTANTS, NOSOURCE_INCLUDE)
/AUTOMATIC or /NOAUTOMATIC /NOAUTOMATIC
/BY_REF_CALL=( routine-list) No default
/CCDEFAULT or
/CCDEFAULT=
    • FORTRAN
    • LIST
    • NONE
    • DEFAULT

/CCDEFAULT=DEFAULT
/NOCHECK or
/CHECK=
    • [NO]ARG_TEMP_CREATED
    • [NO]BOUNDS
    • [NO]FORMAT
    • [NO]FP_EXCEPTIONS
    • [NO]OUTPUT_CONVERSION
    • [NO]OVERFLOW
    • [NO]POWER
    • [NO]UNDERFLOW
    [, ...]
    • ALL
    • NONE

/CHECK=(NOARG_TEMP_CREATED, NOBOUNDS, FORMAT 3, NOFP_EXCEPTIONS, OUTPUT_CONVERSION 3, NOOVERFLOW, POWER, NOUNDERFLOW)
/CONVERT=
  • BIG_ENDIAN
  • CRAY
  • FDX
  • FGX
  • IBM
  • LITTLE_ENDIAN
  • NATIVE
  • VAXD
  • VAXG




/CONVERT=NATIVE
/D_LINES or /NOD_LINES /NOD_LINES
/DEBUG or /NODEBUG or
/DEBUG=
    • [NO]SYMBOLS
    • [NO]TRACEBACK
    [, ...]
    • ALL
    • NONE


/DEBUG=(NOSYMBOLS,
TRACEBACK)
/DIAGNOSTICS[=filename] or /NODIAGNOSTICS /NODIAGNOSTICS
/DOUBLE_SIZE=
  • 64
  • 128
/DOUBLE_SIZE=64
/ERROR_LIMIT= n or /NOERROR_LIMIT /ERROR_LIMIT=30
/EXTEND_SOURCE or /NOEXTEND_SOURCE /NOEXTEND_SOURCE
/F77 or /NOF77 /F77
/FAST No default
/FLOAT=
  • D_FLOAT
  • G_FLOAT
  • IEEE_FLOAT

/FLOAT=G_FLOAT 4
/GRANULARITY=
  • BYTE
  • LONGWORD
  • QUADWORD

/GRANULARITY=QUADWORD
/IEEE_MODE=
  • FAST
  • UNDERFLOW_TO_ZERO
  • DENORM_RESULTS

/IEEE_MODE=FAST
/INCLUDE= directory [, ...] or /NOINCLUDE /NOINCLUDE
/INTEGER_SIZE=
  • 16
  • 32
  • 64

/INTEGER_SIZE=32 4
/LIBRARY No default
/LIST[=file-spec] or /NOLIST /NOLIST (interactive)
/LIST (batch)
/MACHINE_CODE or /NOMACHINE_CODE /NOMACHINE_CODE
/MATH_LIBRARY=
  • ACCURATE
  • FAST

/MATH_LIBRARY=ACCURATE 1
/MODULE=directory or /NOMODULE /NOMODULE
/NAMES=
  • UPPERCASE
  • LOWERCASE
  • AS_IS

/NAMES=UPPERCASE
/OBJECT[=file-spec] or /NOOBJECT /OBJECT
/OLD_F77 Omitted
/OPTIMIZE or /NOOPTIMIZE or
/OPTIMIZE=
  • LEVEL= n
  • INLINE= NONE
  • MANUAL
  • SIZE
  • SPEED
  • ALL
  • NOINLINE
  • LOOPS
  • PIPELINE
  • TUNE= GENERIC
  • HOST
  • EV4
  • EV5
  • EV56
  • PCA56
  • EV6
  • EV67
  • UNROLL= n
[, ...]



/OPTIMIZE (same as /OPTIMIZE= (LEVEL=4, INLINE=SPEED, NOLOOPS, NOPIPELINE, TUNE=GENERIC 1, UNROLL=0))
/PAD_SOURCE or /NOPAD_SOURCE /NOPAD_SOURCE
/REAL_SIZE=
  • 32
  • 64
  • 128

/REAL_SIZE=32
/RECURSIVE or /NORECURSIVE /NORECURSIVE
/NOREENTRANCY or /REENTRANCY=
  • ASYNC
  • NONE
  • THREADED


/REENTRANCY=NONE
/ROUNDING_MODE=
  • NEAREST
  • CHOPPED
  • DYNAMIC
  • MINUS_INFINITY


/ROUNDING_MODE=NEAREST
/SEPARATE_COMPILATION or /NOSEPARATE_COMPILATION /NOSEPARATE_COMPILATION
/SEVERITY=WARNINGS=
  • WARNING
  • ERROR
  • STDERROR

/SEVERITY=WARNINGS=(WARNING)
/SHOW or /NOSHOW or
/SHOW=
    • [NO]INCLUDE
    • [NO]MAP
    [, ...]
    • ALL
    • NONE


/SHOW=(NOINCLUDE, MAP )
/SOURCE_FORM=
  • FREE
  • FIXED
Depends on file type (F90 for free form and FOR or F for fixed form)
/STANDARD=
  • F90
  • F95
or /NOSTANDARD
/NOSTANDARD
/SYNCHRONOUS_EXCEPTIONS or
/NOSYNCHRONOUS_EXCEPTIONS
/NOSYNCHRONOUS_EXCEPTIONS
/SYNTAX_ONLY or /NOSYNTAX_ONLY /NOSYNTAX_ONLY
/TIE or /NOTIE /NOTIE
/VERSION Omitted
/VMS or /NOVMS /VMS
/WARNINGS or /NOWARNINGS or
/WARNINGS=
    • [NO]ALIGNMENT
    • [NO]ARGUMENT_CHECKING
    • [NO]DECLARATIONS
    • [NO]GENERAL
    • [NO]GRANULARITY
    • [NO]IGNORE_LOC
    • [NO]TRUNCATED_SOURCE
    • [NO]UNCALLED
    • [NO]UNINITIALIZED
    • [NO]UNUSED
    • [NO]USAGE
    [, ...]
    • ALL
    • NONE



/WARNINGS=(ALIGNMENT, NOARGUMENT_CHECKING, NODECLARATIONS, GENERAL, GRANULARITY, NOIGNORE_LOC, NOTRUNCATED_SOURCE, UNCALLED, UNINITIALIZED, NOUNUSED, USAGE )


1The default changes if you specify /FAST.
2STANDARD and MULTILANGUAGE are valid for class=COMMON (not class=RECORDS).
3The default changes if you specify /NOVMS.
4Use the /FLOAT qualifier instead of the /[NO]G_FLOAT qualifier; use the /INTEGER_SIZE qualifier instead of the /[NO]I4 qualifier.

Table 2-2 shows the functional groupings of the FORTRAN command qualifiers and the section in which they are described in more detail.

Table 2-2 FORTRAN Command Flags and Categories
Category Flag Name and Section in this Manual
Carriage control for terminal or printer displays /CCDEFAULT (see Section 2.3.10)
Code generation for specific Alpha chip /ARCHITECTURE (see Section 2.3.6)
Convert Nonnative Data Files /CONVERT (see Section 2.3.12)
/ASSUME=BYTERECL (see Section 2.3.7)
Also see Chapter 9.
Data Size /DOUBLE_SIZE (see Section 2.3.16)
/INTEGER_SIZE (see Section 2.3.25)
/REAL_SIZE (see Section 2.3.36)
Also see Chapter 8.
Data Storage and Recursion /AUTOMATIC (see Section 2.3.8)
/RECURSIVE (see Section 2.3.37)
Debugging and Symbol Table /D_LINES (see Section 2.3.13)
/DEBUG (see Section 2.3.14)
Also see Chapter 4.
Floating-Point Exceptions and Accuracy /ASSUME=([NO]ACCURACY_SENSITIVE, [NO]FP_CONSTANT, [NO]MINUS0,) (see Section 2.3.7)
/CHECK=([NO]FP_EXCEPTIONS, [NO]POWER, [NO]UNDERFLOW) (see Section 2.3.11)
/DOUBLE_SIZE (see Section 2.3.16)
/FAST (see Section 2.3.20)
/FLOAT (see Section 2.3.21)
/IEEE_MODE (see Section 2.3.23)
/MATH_LIBRARY (see Section 2.3.29)
/REAL_SIZE (see Section 2.3.36)
/ROUNDING_MODE (see Section 2.3.39)
/SYNCHRONOUS_EXCEPTIONS (see Section 2.3.45)
Floating-Point Format in Memory /FLOAT (see Section 2.3.21)
Language Compatibility /F77 (see Section 2.3.19)
/ALIGNMENT=COMMONS=STANDARD (see Section 2.3.3)
/ASSUME=( [NO]ALTPARAM, [NO]DUMMY_ALIASES, [NO]INT_CONSTANT, /[NO]PROTECT_CONSTANTS ) (see Section 2.3.7)
/BY_REF_CALL (see Section 2.3.9)
/OLD_F77 (see Section 2.3.33)
/PAD_SOURCE (see Section 2.3.43)
/SEVERITY (see Section 2.3.41)
/STANDARD (see Section 2.3.44)
/VMS (see Section 2.3.49)
Language-Sensitive Editor Use /DIAGNOSTICS (see Section 2.3.15)
Listing File and Contents /ANNOTATIONS (see Section 2.3.5)
/LIST (see Section 2.3.27)
/MACHINE_CODE (see Section 2.3.28)
/SHOW (see Section 2.3.42)
Also see Section 2.6.
Module File Searching and Placement; Include File Searching /INCLUDE (see Section 2.3.24)
/ASSUME=[NO]SOURCE_INCLUDE (see Section 2.3.7)
/LIBRARY (see Section 2.3.26)
/MODULE (see Section 2.3.30)
Also see Section 2.2.3 (modules), Section 2.2.4 (include files), and Section 2.4 (text libraries).
Multithreaded Applications /REENTRANCY (see Section 2.3.38)
Object File Creation, Contents, Naming, and External Names /OBJECT (see Section 2.3.32)
/NAMES (see Section 2.3.31)
/SEPARATE_COMPILATION (see Section 2.3.40)
/SYNTAX_ONLY (see Section 2.3.46)
/TIE (see Section 2.3.48)
Performance Optimizations and Alignment /ALIGNMENT (see Section 2.3.3)
/ASSUME=(NOACCURACY_SENSITIVE, NODUMMY_ALIASES) (see Section 2.3.7)
/ARCHITECTURE (see Section 2.3.6)
/FAST (see Section 2.3.20)
/MATH_LIBRARY (see Section 2.3.29)
/OPTIMIZE (see Section 2.3.34)
Also see Chapter 5.
Recursion and Shared Access to Data /GRANULARITY (see Section 2.3.22)
/RECURSIVE (see Section 2.3.37)
/REENTRANCY (see Section 2.3.38)
/WARNINGS=GRANULARITY (see Section 2.3.50)
Source Code Analyzer Use /ANALYSIS_DATA (see Section 2.3.4)
Source Form and Column Use /D_LINES (see Section 2.3.13)
/EXTEND_SOURCE (see Section 2.3.18)
/PAD_SOURCE (see Section 2.3.35)
/SOURCE_FORM (see Section 2.3.43)
/WARNINGS=TRUNCATED_SOURCE (see Section 2.3.50)
Warning Messages and Run-Time Checking /CHECK (see Section 2.3.11)
/IEEE_MODE (see Section 2.3.23)
/ERROR_LIMIT (see Section 2.3.17)
/SEVERITY (see Section 2.3.41)
/WARNINGS (see Section 2.3.50)
Also see the qualifiers related to "Floating-Point Exceptions and Accuracy" in this table.

2.3.3 /ALIGNMENT --- Data Alignment

The /ALIGNMENT qualifier controls the data alignment of numeric fields in common blocks and structures.

If you omit the /ALIGNMENT and /FAST qualifiers:

Although Compaq Fortran always aligns local data items on natural boundaries, certain data declaration statements and unaligned arguments can force unaligned data.

Use the /ALIGNMENT qualifier to control the alignment of fields associated with common blocks, derived-type structures, and record structures.

The compiler issues messages when it detects unaligned data by default (/WARNINGS=ALIGNMENT). For information about the causes of unaligned data and detection at run-time, see Section 5.3.

Note

Unaligned data significantly increases the time it takes to execute a program, depending on the number of unaligned fields encountered. Specifying /ALIGNMENT=ALL (same as /ALIGNMENT=NATURAL) minimizes unaligned data.

The qualifier has the following form:

/ALIGNMENT=
  • rule
  • class = rule
  • (class = rule [, ...])
  • [NO]SEQUENCE
  • ALL (or NATURAL)
  • NONE (or PACKED)

where: class =
  • COMMONS
  • RECORDS
  • STRUCTURES
and rule =
  • NATURAL
  • PACKED
  • STANDARD
  • [NO]MULTILANGUAGE

STANDARD and MULTILANGUAGE are valid for class=COMMON (not class=RECORDS).

The /ALIGNMENT qualifier keywords specify whether the Compaq Fortran compiler should naturally align or arbitrarily pack the following:

class

Specifies the type of data blocks:

rule

Specifies the alignment for the specified class of data blocks:

[NO]SEQUENCE

Specifying /ALIGNMENT=SEQUENCE means that components of derived types with the SEQUENCE attribute will obey whatever alignment rules are currently in use. The default alignment rules align components on natural boundaries.

The default value of /ALIGNMENT=NOSEQUENCE means that components of derived types with the SEQUENCE attribute will be packed, regardless of whatever alignment rules are currently in use.

Specifying /FAST sets /ALIGNMENT=SEQUENCE so that components of derived types with the SEQUENCE attribute will be naturally aligned for improved performance. Specifying /ALIGNMENT=ALL also sets /ALIGNMENT=SEQUENCE.

ALL

Specifying /ALIGNMENT=ALL is equivalent to /ALIGNMENT, /ALIGNMENT=NATURAL), or /ALIGNMENT=(COMMONS= (NATURAL,NOMULTILANGUAGE),RECORDS=NATURAL, SEQUENCE ).

NONE

Specifying /ALIGNMENT=NONE is equivalent to /NOALIGNMENT, /ALIGNMENT=PACKED, or /ALIGNMENT=(COMMONS=(PACKED, NOMULTILANGUAGE), RECORDS=PACKED, NOSEQUENCE ).

Defaults depend on whether you specify or omit the /ALIGNMENT and /FAST qualifiers, as follows:
Command Line Default
Omit /ALIGNMENT and omit /FAST /ALIGNMENT=(COMMONS=(PACKED,NOMULTILANGUAGE),NOSEQUENCE,RECORDS=NATURAL)
Omit /ALIGNMENT and specify /FAST /ALIGNMENT=(COMMONS=NATURAL,
RECORDS=NATURAL,SEQUENCE)
/ALIGNMENT=COMMONS= rule Use whatever the /ALIGNMENT qualifier specifies for COMMONS, but use the default of RECORDS=NATURAL
/ALIGNMENT=RECORDS= rule Use whatever the /ALIGNMENT qualifier specifies for RECORDS, but use the default for COMMONS (depends on whether /FAST was specified or omitted)

You can override the alignment specified on the command line by using a cDEC$ OPTIONS directive, as described in the Compaq Fortran Language Reference Manual.

The /ALIGNMENT and /WARNINGS=ALIGNMENT qualifiers can be used together in the same command line.

For More Information:

2.3.4 /ANALYSIS_DATA---Create Analysis Data File

The /ANALYSIS_DATA qualifier produces an analysis data file that contains cross-reference and static-analysis information about the source code being compiled.

Analysis data files are reserved for use by Compaq products such as, but not limited to, the Source Code Analyzer (SCA).

The qualifier has the following form:

/ANALYSIS_DATA[=filename.type]

If you omit the file specification, the analysis file name has the name of the primary source file and a file type of ANA (filename.ANA).

The compiler produces one analysis file for each source file that it compiles. If you are compiling multiple files and you type in a file name, each analysis file is given that name (with an incremental version number).

If you do not specify the /ANALYSIS_DATA qualifier, the default is /NOANALYSIS_DATA.

2.3.5 /ANNOTATIONS --- Code Descriptions

The /ANNOTATIONS qualifier controls whether an annotated listing showing optimizations is included with the listing file.

The qualifier has the following form:

/ANNOTATIONS=
    • CODE
    • DETAIL
    • INLINING
    • LOOP_TRANSFORMS
    • LOOP_UNROLLING
    • PREFETCHING
    • SHRINKWRAPPING
    • SOFTWARE_PIPELINING
    • TAIL_CALLS
    • TAIL_RECURSION
    [, ...]
    • ALL
    • NONE

CODE

Annotates the machine code listing with descriptions of special instructions used for prefetching, alignment, and so on.

DETAIL

Provides additional level of annotation detail, where available.

INLINING

Indicates where code for a called procedure was expanded inline.

LOOP_TRANSFORMS

Indicates where advanced loop nest optimizations have been applied to improve cache performance.

LOOP_UNROLLING

Indicates where a loop was unrolled (contents expanded multiple times).

PREFETCHING

Indicates where special instructions were used to reduce memory latency.

SHRINKWRAPPING

Indicates removal of code establishing routine context when it is not needed.

SOFTWARE_PIPELINING

Indicates where instructions have been rearranged to make optimal use of the processor's functional units.

TAIL_CALLS

Indicates an optimization where a call can be replaced with a jump.

TAIL_RECURSION

Indicates an optimization that eliminates unnecessary routine context for a recursive call.

ALL

All annotations, including DETAIL, are selected. This is the default if no keyword is specified.

NONE

No annotations are selected. This is the same as /NOANNOTATIONS.

2.3.6 /ARCHITECTURE --- Architecture Code Instructions

The /ARCHITECTURE qualifier specifies the type of Alpha architecture code instructions generated for a particular program unit being compiled; it uses the same options (keywords) as used by the /OPTIMIZE=TUNE qualifier (for instruction scheduling purposes).

OpenVMS Version 7.1 and subsequent releases provide an operating system kernel that includes an instruction emulator. This emulator allows new instructions, not implemented on the host processor chip, to execute and produce correct results. Applications using emulated instructions will run correctly but may incur significant software emulation overhead at runtime.

All Alpha processors implement a core set of instructions. Certain Alpha processor versions include additional instruction extensions.

The qualifier has the following form:

/ARCHITECTURE=
  • GENERIC
  • HOST
  • EV4
  • EV5
  • EV56
  • PCA6
  • EV6
  • EV67

GENERIC

Generates code that is appropriate for all Alpha processor generations. This is the default.

Programs compiled with the GENERIC option run on all implementations of the Alpha architecture without any instruction emulation overhead.

HOST

Generates code for the processor generation in use on the system being used for compilation.

Programs compiled with this option may encounter instruction emulation overhead if run on other implementations of the Alpha architecture.

EV4

Generates code for the 21064, 21064A, 21066, and 21068 implementations of the Alpha architecture. Programs compiled with the EV4 option run on all Alpha processors without instruction emulation overhead.

EV5

Generates code for some 21164 chip implementations of the Alpha architecture that use only the base set of Alpha instructions (no extensions). Programs compiled with the EV5 option run on all Alpha processors without instruction emulation overhead.

EV56

Generates code for some 21164 chip implementations that use the BWX (Byte/Word manipulation) instruction extensions of the Alpha architecture.

Programs compiled with the EV56 option may incur emulation overhead on EV4 and EV5 processors but still run correctly on OpenVMS Version 7.1 (or later) systems.

PCA56

Generates code for the 21164PC chip implementation that uses the BWX (Byte/Word manipulation) and MAX (Multimedia) instruction extensions of the Alpha architecture.

Programs compiled with the PCA56 option may incur emulation overhead on EV4, EV5, and EV56 processors but will still run correctly on OpenVMS Version 7.1 (or later) systems.

EV6

Generates code for the 21264 chip implementation that uses the following extensions to the base Alpha instruction set: BWX (Byte/Word manipulation) and MAX (Multimedia) instructions, square root and floating-point convert instructions, and count instructions.

Programs compiled with the EV6 option may incur emulation overhead on EV4, EV5, EV56, and PCA56 processors but will still run correctly on OpenVMS Version 7.1 (or later) systems.

EV67

Generates code for chip implementations that use advanced instruction extensions of the Alpha architecture. This option permits the compiler to generate any EV67 instruction, including the following extensions to the base Alpha instruction set: BWX (Byte/Word manipulation), MVI (Multimedia) instructions, square root and floating-point convert extensions (FIX), and count extensions (C1X).

Programs compiled with the EV67 keyword might incur emulation overhead on EV4, EV5, EV56, PCA56, and EV6 processors but still run correctly on Compaq OpenVMS Alpha systems.

2.3.7 /ASSUME --- Compiler Assumptions

The /ASSUME qualifier specifies a variety of assumptions:

The qualifier has the following form:

/ASSUME=
    • [NO]ACCURACY_SENSITIVE
    • [NO]ALTPARAM
    • [NO]BUFFERED_IO
    • [NO]BYTERECL
    • [NO]DUMMY_ALIASES
    • [NO]FP_CONSTANT
    • [NO]INT_CONSTANT
    • [NO]MINUS0
    • [NO]PROTECT_CONSTANTS
    • [NO]SOURCE_INCLUDE
    [, ...]
    • ALL
    • NONE

[NO]ACCURACY_SENSITIVE

If you use ACCURACY_SENSITIVE (the default unless you specified /FAST), the compiler uses a limited number of rules for calculations, which might prevent some optimizations.

Specifying NOACCURACY_SENSITIVE allows the compiler to reorder code based on algebraic identities (inverses, associativity, and distribution) to improve performance. The numeric results can be slightly different from the default (ACCURACY_SENSITIVE) because of the way intermediate results are rounded. Specifying the /FAST qualifier (described in Section 2.3.20) changes the default to NOACCURACY_SENSITIVE.

Numeric results with NOACCURACY_SENSITIVE are not categorically less accurate. They can produce more accurate results for certain floating-point calculations, such as dot product summations.

For example, the following expressions are mathematically equivalent but may not compute the same value using finite precision arithmetic.


X = (A + B) - C 
 
X = A + (B - C) 

Optimizations that result in calls to a special reciprocal square root routine for expressions of the form 1.0/SQRT(x) or A/SQRT(B) are enabled only if /ASSUME=NOACCURACY_SENSITIVE is in effect.

[NO]ALTPARAM

Specifying the /ASSUME=ALTPARAM qualifier allows the alternate syntax for PARAMETER statements. The alternate form has no parentheses surrounding the list, and the form of the constant, rather than implicit or explicit typing, determines the data type of the variable. The default is /ASSUME=ALTPARAM.

[NO]BUFFERED_IO

The /ASSUME=[NO]BUFFERED_IO qualifier is provided for compatibility with other platforms. On OpenVMS systems, the SET RMS command controls the number of output buffers.

Specifying /ASSUME=BUFFERED_IO requests that buffered I/O be used for all Fortran logical units opened for sequential writing (default is NOBUFFERED_IO). On OpenVMS systems, this qualifier has an effect only if the system or process RMS default buffers are set to 1.

[NO]BYTERECL

Specifying the /ASSUME=BYTERECL qualifier:

To specify /ASSUME=BYTERECL your application must be running on a system that has the associated Fortran Run-Time Library support. This support is provided by installing one of the following on the system where the application will be run:

If you specify /ASSUME=BYTERECL and your application is running on a system without the proper Run-Time Library support, it will fail with an INVARGFOR, Invalid argument to Fortran Run-Time Library error.

[NO]DUMMY_ALIASES

Specifies whether dummy (formal) arguments are permitted to share memory locations with COMMON block variables or other dummy arguments.

If you specify DUMMY_ALIASES, the compiler must assume that dummy (formal) arguments to procedures share memory locations with other dummy arguments or with variables shared through use association, host association, or common block use.

These program semantics do not strictly obey the Fortran 90 and Fortran 95 Standards and slow performance.

If you use NODUMMY_ALIASES, the default, the compiler does not need to make these assumptions, which results in better run-time performance. However, omitting /ASSUME=DUMMY_ALIASES can cause some programs that depend on such aliases to fail or produce wrong answers.

You only need to compile the called subprogram with DUMMY_ALIASES.

If you compile a program that uses dummy aliasing with NODUMMY_ALIASES in effect, the run-time behavior of the program will be unpredictable. In such programs, the results will depend on the exact optimizations that are performed. In some cases, normal results will occur; however, in other cases, results will differ because the values used in computations involving the offending aliases will differ.

[NO]FP_CONSTANT

Specifies whether a single-precision constant assigned to a double-precision variable will be evaluated in double precision.

If you use NOFP_CONSTANT, the default, a single-precision constant assigned to a double-precision variable is evaluated in single precision. The Fortran 90 and 95 standards require that the constant be evaluated in single precision.

If you specify FP_CONSTANT, a single-precision constant assigned to a double-precision variable is evaluated in double precision.

Certain programs created for FORTRAN-77 compilers (including Compaq Fortran 77) may show different results with FP_CONSTANT than when you use NOFP_CONSTANT, because they rely on single-precision constants assigned to a double-precision variable to be evaluated in double precision.

In the following example, if you specify FP_CONSTANT, identical values are assigned to D1 and D2. If you use NOFP_CONSTANT, Compaq Fortran will follow the standard and assign a less precise value to D1:


    REAL (KIND=8) D1,D2 
    DATA D1 /2.71828182846182/    ! REAL (KIND=4) value expanded to double 
    DATA D2 /2.71828182846182D0/  ! Double value assigned to double 

[NO]INT_CONSTANT

Specifies whether Compaq Fortran 77 or Fortran 90/95 semantics are used to determine the type for integer constants.

If you specify /ASSUME=INT_CONSTANT, integer constants take their type from the value, as interpreted by Compaq Fortran 77.

If you specify /ASSUME=NOINT_CONSTANT, integer constants have Fortran 90/95 "default integer" type. This is the default.

[NO]MINUS0

Controls whether the compiler uses Fortran 95 standard semantics for the IEEE floating-point value of -0.0 (minus zero) in the SIGN intrinsic, if the processor is capable of distinguishing the difference between -0.0 and +0.0.

The default is /ASSUME=NOMINUS0, which uses Fortran 90 and FORTRAN 77 semantics where the value -0.0 or +0.0 in the SIGN function is treated as an 0.0.

To request Fortran 95 semantics, specify /ASSUME=MINUS0 to allow use of the IEEE value -0.0 in the SIGN intrinsic and printing -0.0. This option applies only to programs compiled with the /FLOAT=IEEE_FLOAT qualifier.

[NO]PROTECT_CONSTANTS

Specifies whether constant actual arguments can be changed. By default, actual arguments that are constants are read-only (/ASSUME=PROTECT_CONSTANTS): any attempt to modify them in the called routine results in an error. /ASSUME=NOPROTECT_CONSTANTS specifies that a copy of a constant actual argument is to be passed, so it can be modified by the called routine, even though the Fortran standard prohibits such modification. The constant is not modified in the calling routine.

If NOPROTECT_CONSTANTS is specified, a writeable copy of the constant is passed as the actual argument.

[NO]SOURCE_INCLUDE

Controls whether the directory where the compiler searches for source files or text libraries specified by an INCLUDE statement is either:

The default, NOSOURCE_INCLUDE, indicates that the compiler should search in the current default directory.

Specifying SOURCE_INCLUDE causes the compiler to search the directory of the source file specified on the FORTRAN command line, instead of the current default directory.

You can specify additional directories for the compiler to search for module files, include files, or include libraries by using the /INCLUDE qualifier.

For More Information:

2.3.8 /AUTOMATIC --- Data Storage

The /AUTOMATIC and /NOAUTOMATIC qualifiers are synonyms of /RECURSIVE or /NORECURSIVE (see Section 2.3.37). This qualifier is provided for Compaq Fortran 77 compatibility.

2.3.9 /BY_REF_CALL --- Character Literal Argument Passing

Specifying /BY_REF_CALL=routine-list indicates that character constants used as actual arguments in calls to the specified routines be passed by reference and not by character descriptor. This helps applications that pass quoted character constants to numeric dummy parameters, such as applications ported from OpenVMS VAX systems that rely on the OpenVMS VAX Linker to change the argument passing mechanism for character constant actual arguments.

By default, Compaq Fortran passes character constants used as actual arguments by the usual OpenVMS character descriptor mechanism.

You can specify a list of routines or use wildcard characters (such as an asterisk (*)) to indicate all routines, for example:


$ FORTRAN/BY_REF_CALL=(PROJA_ROUT,PROJB_ROUT) TEST.FOR
$ FORTRAN/BY_REF_CALL=(*) APPLIC.FOR

The first FORTRAN command requests special character constant actual argument handling for two specific routines. The second requests this for all routines. You can select routines whose names match certain characters and a wildcard, such as all routines that start with MY:


$ FORTRAN/BY_REF_CALL=(MY*) X.FOR

2.3.10 /CCDEFAULT --- Carriage Control for Terminals

The /CCDEFAULT qualifiers specify default carriage control when a terminal or printer displays a file.

The qualifier has the following form:

/CCDEFAULT=
    • FORTRAN
    • LIST
    • NONE
    • DEFAULT

FORTRAN

Specifying /CCDEFAULT=FORTRAN results in normal Fortran interpretation of the first character, such as the character "0" resulting in a blank line before output.

LIST

Specifying /CCDEFAULT=LIST results in one linefeed between records.

NONE

Specifying /CCDEFAULT=NONE results in no carriage control processing.

DEFAULT

Specifying /CCDEFAULT=DEFAULT results in the possibility of other qualifiers, such as /VMS, affecting this default setting: if /NOVMS is specified, the default is LIST; otherwise the default is FORTRAN.

2.3.11 /CHECK --- Generate Code for Run-Time Checking

The /CHECK qualifier requests certain error checking during program execution (run time). The compiler produces extra code that performs the checks.

The qualifier has the following form:

/CHECK=
    • [NO]ARG_TEMP_CREATED
    • [NO]BOUNDS
    • [NO]FORMAT
    • [NO]FP_EXCEPTIONS
    • [NO]OUTPUT_CONVERSION
    • [NO]OVERFLOW
    • [NO]POWER
    • [NO]UNDERFLOW
    [, ...]
    • ALL
    • NONE

ARG_TEMP_CREATED

Controls whether a run-time warning message is displayed (execution continues) if a temporary is created for an array actual argument passed to a called routine.

[NO]BOUNDS

Controls whether run-time checking occurs for each dimension of an array reference or substring reference to determine whether it is within the range of the dimension specified by the array or character variable declaration.

Specify BOUNDS to request array bounds and substring checking. With the default, NOBOUNDS, array bounds and substring checking does not occur.

[NO]FORMAT

Controls whether the run-time message number 61 (FORVARMIS) is displayed and halts program execution when the data type for an item being formatted for output does not match the format descriptor being used (such as a REAL data item with an I format).

The default, FORMAT, causes FORVARMIS to be a fatal error and halts program execution.

Specifying NOFORMAT ignores the format mismatch, which suppresses the FORVARMIS error and allows program continuation.

If you omit /NOVMS and omit /CHECK=NOFORMAT, the default is /CHECK=FORMAT.

If you specify /NOVMS, the default is NOFORMAT (unless you also specify /CHECK=FORMAT).

[NO]FP_EXCEPTIONS

Controls whether run-time checking counts calculations that result in exceptional values. With the default, NOFP_EXCEPTIONS, no run-time messages are reported.

Specifying FP_EXCEPTIONS requests reporting of the first two occurrences of each type of exceptional value and a summary run-time message at program completion that displays the number of times exceptional values occurred. Consider using FP_EXCEPTIONS when the /IEEE_MODE qualifier allows generation of exceptional values.

To limit reporting to only denormalized numbers (and not other exceptional numbers), specify UNDERFLOW instead of FP_EXCEPTIONS.

Using FP_EXCEPTIONS applies to all types of native floating-point data.

[NO]OUTPUT_CONVERSION

Controls whether run-time message number 63 (OUTCONERR) is displayed when format truncation occurs. Specifying /CHECK=NOOUTPUT_CONVERSION disables the run-time message (number 63) associated with format truncation. The data item is printed with asterisks. When OUTPUT_CONVERSION is in effect and a number could not be output in the specified format field length without loss of significant digits (format truncation), the OUTCONERR (number 63) error occurs.

If you omit /NOVMS and omit /CHECK=NOOUTPUT_CONVERSION, the default is OUTPUT_CONVERSION.

If you specify /NOVMS, the default is NOOUTPUT_CONVERSION (unless you also specify /CHECK=OUTPUT_CONVERSION).

[NO]OVERFLOW

Controls whether run-time checking occurs for arithmetic overflow of all integer calculations (INTEGER, INTEGER with a kind parameter, or INTEGER with a length specifier). Specify OVERFLOW to request integer overflow checking.

Real and complex calculations are always checked for overflow and are not affected by /NOCHECK. Integer exponentiation is performed by a routine in the mathematical library. The routine in the mathematical library always checks for overflow, even if NOOVERFLOW is specified.

With the default, NOOVERFLOW, overflow checking does not occur.

[NO]POWER

Specifying the /CHECK=NOPOWER qualifier allows certain arithmetic expressions containing floating-point numbers and exponentiation to be evaluated and return a result rather than cause the compiler to display a run-time message and stop the program. The specific arithmetic expressions include:

For example, if you specify /CHECK=NOPOWER the calculation of the expression 0.0 ** 0.0 results in 1. The expression (--3.0) ** 3.0 results in --27.0.

If you omit /CHECK=NOPOWER for such expressions, an exception occurs, error message number 65 is displayed, and the program stops (default is /CHECK=POWER).

[NO]UNDERFLOW

Controls whether run-time messages are displayed for floating underflow (denormalized numbers) in floating-point calculations. Specifying UNDERFLOW might be used in combination with the /IEEE_MODE=DENORM_RESULTS qualifier. Specify UNDERFLOW to request reporting of the first two occurrences of denormalized numbers and a summary run-time message at program completion that displays the number of times denormalized numbers occurred.

The default, NOUNDERFLOW, means that floating underflow messages are not displayed. To check for all exceptional values (not just denormalized numbers), specify /CHECK=FP_EXCEPTIONS.

ALL

Requests that all run-time checks (BOUNDS, FORMAT, FP_EXCEPTIONS, OUTPUT_CON2VERSION, OVERFLOW, and UNDERFLOW) be performed. Specifying /CHECK and /CHECK=ALL are equivalent.

NONE

Requests no run-time checking. This is the default. Specifying /NOCHECK and /CHECK=NONE are equivalent.

For More Information:

2.3.12 /CONVERT --- Unformatted Numeric Data Conversion

The /CONVERT qualifier specifies the format of numeric unformatted data in a file, such as IEEE little endian, VAX G_float, VAX D_float floating-point format, or a nonnative big endian format.

By default, an unformatted file containing numeric data is expected to be in the same floating-point format used for memory representation or /CONVERT=NATIVE. You set the floating-point format used for memory representation using the /FLOAT qualifier (see Section 2.3.21).

Instead of specifying the unformatted file format by using the /CONVERT qualifier, you can use one of the other methods (predefined logical names or the OPEN CONVERT keyword) described in Chapter 9, which allow the same program to use different floating-point formats, as shown in Figure 2-1.

The qualifier has the following form (specify one keyword):

/CONVERT=
  • BIG_ENDIAN
  • CRAY
  • FDX
  • FGX
  • IBM
  • LITTLE_ENDIAN
  • NATIVE
  • VAXD
  • VAXG

BIG_ENDIAN

Specifies that unformatted files containing numeric data are in IEEE big endian (nonnative) format.

If you specify BIG_ENDIAN, the resulting program will read and write unformatted files containing numeric data assuming:

CRAY

Specifies that unformatted files containing numeric data are in CRAY (nonnative) big endian format.

If you specify CRAY, the resulting program will read and write unformatted files containing numeric data assuming:

FDX

Specifies that unformatted files containing numeric data are in OpenVMS Alpha little endian format, as follows:

FGX

Specifies that unformatted files containing numeric data are in OpenVMS Alpha little endian format, as follows:

IBM

Specifies that unformatted files containing numeric data are in IBM® (nonnative) big endian format (such as IBM System\370 and similar systems).

If you specify IBM, the resulting program will read and write unformatted files containing numeric data assuming:

LITTLE_ENDIAN

Specifies that unformatted files containing numeric data are in native little endian integer format and IEEE little endian floating-point format, as follows:

NATIVE

Specifies that the format for unformatted files containing numeric data is not converted. When using NATIVE (the default), the numeric format in the unformatted files must match the floating-point format representation in memory, which is specified using the /FLOAT qualifier.

This is the default.

VAXD

Specifies that unformatted files containing numeric data are in OpenVMS VAX little endian format, as follows:

VAXG

Specifies that unformatted files containing numeric data are in OpenVMS VAX little endian format, as follows:

For More Information:

2.3.13 /D_LINES --- Debugging Statement Indicator, Column 1

Specify /D_LINES to request that the compiler should treat lines in fixed-form source files that contain a D in column 1 as source code rather than comment lines. Such lines might print the values of variables or otherwise provide useful debugging information. This qualifier is ignored for free-form source files.

The default is /NOD_LINES, which means that lines with a D in column 1 are treated as comments.

2.3.14 /DEBUG --- Object File Traceback and Symbol Table

The /DEBUG qualifier requests that the object module contain information for use by the OpenVMS Debugger and the run-time error traceback mechanism.

The qualifier has the following form:

/DEBUG=
    • [NO]SYMBOLS
    • [NO]TRACEBACK
    [, ...]
    • NONE
    • ALL

[NO]SYMBOLS

Controls whether the compiler provides the debugger with local symbol definitions for user-defined variables, arrays (including dimension information), structures, parameter constants, and labels of executable statements.

[NO]TRACEBACK

Controls whether the compiler provides an address correlation table so that the debugger and the run-time error traceback mechanism can translate virtual addresses into source program routine names and compiler-generated line numbers.

ALL

Requests that the compiler provide both local symbol definitions and an address correlation table. If you specify /DEBUG without any keywords, it is the same as /DEBUG=ALL or /DEBUG=(TRACEBACK,SYMBOLS). When you specify /DEBUG, also specify /NOOPTIMIZE to prevent optimizations that complicate debugging.

NONE

Requests that the compiler provide no debugging information. The /NODEBUG, /DEBUG=NONE, and /DEBUG=(NOTRACEBACK, NOSYMBOLS) qualifiers are equivalent.

If you omit /DEBUG, the default is /DEBUG=(TRACEBACK, NOSYMBOLS).

Note

The use of /NOOPTIMIZE is strongly recommended when the /DEBUG qualifier is used. Optimizations performed by the compiler can cause several different kinds of unexpected behavior when using the OpenVMS Debugger.

For More Information:

2.3.15 /DIAGNOSTICS --- Create Diagnostics File

The /DIAGNOSTICS qualifier creates a file containing compiler messages and diagnostic information.

The qualifier has the following form:

/DIAGNOSTICS[=file-spec]

The default is /NODIAGNOSTICS.

If you omit the file specification, the diagnostics file has the name of your source file and a file type of DIA.

The diagnostics file is reserved for use with Compaq third-party layered products such as, but not limited to, the Language Sensitive Editor (LSE).

For More Information:

On using LSE, see the Guide to Source Code Analyzer for OpenVMS Systems or online LSE HELP.

2.3.16 /DOUBLE_SIZE --- DOUBLE PRECISION Data Size

The /DOUBLE_SIZE qualifier allows you to specify the data size for floating-point DOUBLE PRECISION data declarations. The qualifier has the following form:

/DOUBLE_SIZE=
  • 64
  • 128

To request that all DOUBLE PRECISION declarations, constants, functions, and intrinsics use the REAL (KIND=16) extended-precision data rather than REAL (KIND=8) double-precision data, specify /DOUBLE_SIZE=128. REAL (KIND=16) data is stored in memory using X_float format.

If you omit /DOUBLE_SIZE=128, the size of DOUBLE PRECISION declarations is REAL (KIND=8) or 64-bit double-precision data (default is /DOUBLE_SIZE=64). To select the floating-point format used in memory for 64-bit REAL (KIND=8) data, use the /FLOAT qualifier.

For More Information:

On the /FLOAT qualifier, see Section 2.3.21.

2.3.17 /ERROR_LIMIT --- Limit Compiler Messages

The /ERROR_LIMIT qualifier specifies the maximum number of error-level or fatal-level compiler errors allowed for a given compilation unit (one or more files specified on the FORTRAN command line that create a single object file).

The qualifier has the following form:

/ERROR_LIMIT[=nn] or /NOERROR_LIMIT

If you specify /ERROR_LIMIT=n, the compilation can have up to n - 1 errors without terminating the compilation. When the error limit is reached, compilation is terminated. If you specify /NOERROR_LIMIT, there is no limit on the number of errors that are allowed.

By default, execution of the compiler is terminated when 30 error (E-level) and fatal (F-level) messages are detected (default is /ERROR_LIMIT=30).

When the error limit is surpassed, only compilation of the current comma-list element is terminated; the compiler will proceed to compile any other comma-list element. For example, consider the following:


$ FORTRAN A,B,C

If comma-list element A has more than 30 E- or F-level errors, its compilation is terminated, but the compiler proceeds to compile elements B and C.

A list of files separated by plus signs (+) form a single compilation unit. In the following example, compilation of the plus-sign separated files A, B, or C stops when the total of E- or F-level errors for all three files exceeds 30:


$ FORTRAN A+B+C

Specifying /ERROR_LIMIT=0 is equivalent to specifying /ERROR_LIMIT=1 (compilation terminates when the first error-level or fatal-level error occurs).

For More Information:

On compiler diagnostic messages, see Section 2.5.

2.3.18 /EXTEND_SOURCE --- Line Length for Fixed-Form Source

Specify /EXTEND_SOURCE to request that the compiler increase the length of Compaq Fortran statement fields to column 132 for fixed-form source files, instead of column 72 (the default). It is ignored for free-form source files.

You can also specify this qualifier by using the OPTIONS statement. The default in either case is /NOEXTEND_SOURCE.

To request warning messages for truncated fixed-form source lines, specify /WARNINGS=TRUNCATED_SOURCE.

For More Information:

2.3.19 /F77 --- FORTRAN IV or FORTRAN-77 Compatibility

The /F77 qualifier requests that the compiler use FORTRAN-77 (and thus Fortran 90/95) interpretation rules for those statements that have different meanings in older versions of the Fortran standards. The default is /F77.

If you specify /NOF77, the compiler uses the FORTRAN 66 (FORTRAN IV) interpretation, which include:

2.3.20 /FAST --- Request Fast Run-Time Performance

Specifying /FAST changes the defaults for certain qualifiers, usually improving run-time performance. The new defaults are:

2.3.21 /FLOAT --- Specify Floating-Point Format in Memory

The /FLOAT qualifier specifies the floating-point data format to be used in memory for REAL or COMPLEX data. For performance reasons, consider specifying the same floating-point memory format as the floating-point format used by unformatted files the program will access if the data falls within the acceptable range.

Figure 2-1 shows the FORTRAN command qualifiers used to specify the floating-point format used in memory and in an unformatted file. Because REAL (KIND=16) (same as REAL*16) data is always in X_float format on Alpha systems, the /FLOAT keyword specifies the format for REAL (KIND=4), COMPLEX (KIND=4), REAL (KIND=8), and COMPLEX (KIND=8) data (or equivalent declarations).

Figure 2-1 Specifying the Format of Numeric Data for Unformatted Files


Specifying the Format of Numeric Data for Unformatted Files

To specify the floating-point format (such as big endian) for all unformatted files opened by the program, use the /CONVERT qualifier. To allow the same program to use different floating-point formats, you must use the predefined logical names or the OPEN CONVERT keyword to specify the format for specific unit numbers, as described in Chapter 9.

The qualifier has the following form:

/FLOAT=
  • D_FLOAT
  • G_FLOAT
  • IEEE_FLOAT

D_FLOAT

Specifies that the memory format for REAL (KIND=4) and COMPLEX (KIND=4) data is VAX F_float and that the memory format for REAL (KIND=8) and COMPLEX (KIND=8) data is VAX D_float. Same as the obsolete qualifier /NOG_FLOATING.

OpenVMS VAX systems fully support D_float and G_float implementations of the REAL (KIND=8) (DOUBLE PRECISION) data type in memory. OpenVMS Alpha systems can store REAL (KIND=8) floating-point data in memory in D_float, G_float, or T_float format.

Because the Alpha instruction set does not support D_float computations, D_float data is converted to G_float format for arithmetic computations and then converted back to D_float format. For programs that perform many REAL (KIND=8) computations, using D_float data on Alpha systems is slower than G_float or T_float data and the results will differ from VAX D_float computations and results.

Unless a program uses unformatted data files in D_float format, do not use the /FLOAT=D_FLOAT qualifier. If range and accuracy constraints do not disallow the use of the other REAL (KIND=8) data types, consider converting existing unformatted files that contain D_float data to another format, such as G_float, T_float, or X_float (see Chapter 9).

G_FLOAT

Specifies that the memory format for single precision REAL (KIND=4) and COMPLEX (KIND=4) data is VAX F_float and that the memory format for double precision REAL (KIND=8) and COMPLEX (KIND=8) data is VAX G_float. Same as the obsolete qualifier /G_FLOATING.

The default is /FLOAT=G_FLOAT, unless you specify /NOG_FLOATING.

IEEE_FLOAT

Specifies that the memory format for single precision REAL (KIND=4) and COMPLEX (KIND=4) data is IEEE S_float and the memory format for double precision REAL (KIND=8) and COMPLEX (KIND=8) is IEEE T_float.

Specifying /FLOAT=IEEE_FLOAT allows the use of certain IEEE exceptional values. When you specify /FLOAT=IEEE_FLOAT, you should be aware of the /CHECK=FP_EXCEPTIONS, /IEEE_MODE, and /ROUNDING_MODE qualifiers.

Because REAL (KIND=16) (same as REAL*16) and COMPLEX (KIND=16) (same as COMPLEX*32) data is always in X_float format on Alpha systems, operations that use REAL (KIND=16) and COMPLEX (KIND=16) data may encounter certain exceptional values even when /FLOAT=IEEE_FLOAT is not used.

If your program requires the G_float form of double precision for its correct operation (it uses a range larger than 10**38), you should use the /FLOAT qualifier in an OPTIONS statement in your source program.

You should not mix floating data type formats in routines that pass single-precision or double-precision quantities amongst themselves.

For More Information:

2.3.22 /GRANULARITY --- Control Shared Memory Access to Data

The /GRANULARITY qualifier controls the size of data that can be safely accessed from different threads. You do not need to specify this option for local data access by a single process, unless asynchronous write access from outside the user process might occur. The default is /GRANULARITY=QUADWORD.

The qualifier has the following form:

/GRANULARITY=
  • BYTE
  • LONGWORD
  • QUADWORD

Data that can be written from multiple threads must be declared as VOLATILE (so it is not held in registers). To ensure alignment in common blocks, derived types, and record structures, use the /ALIGNMENT qualifier.

BYTE

Requests that all data (one byte or greater) can be accessed from different threads sharing data in memory. This option will slow run-time performance.

LONGWORD

Ensures that naturally aligned data of four bytes or greater can be accessed safely from different threads sharing access to that data in memory. Accessing data items of three bytes or less and unaligned data may result in data items written from multiple threads being inconsistently updated.

QUADWORD

Ensures that naturally aligned data of eight bytes can be accessed safely from different threads sharing data in memory. Accessing data items of seven bytes or less and unaligned data may result in data items written from multiple threads being inconsistently updated. This is the default.

For More Information:

2.3.23 /IEEE_MODE --- Control IEEE Arithmetic Exception Handling

The /IEEE_MODE qualifier specifies the arithmetic exception handling used for floating-point calculations, such as for exceptional values. It also controls the precision of exception reporting (like /SYNCHRONOUS_EXCEPTIONS).

Exceptional values are associated with IEEE arithmetic and include Infinity (+ and -) values, Not-A-Number (NaN) values, invalid data values, and denormalized numbers (see Section 8.4.8).

Use the /IEEE_MODE qualifier to control:

This qualifier only applies to arithmetic calculations when:

The qualifier has the following form:

/IEEE_MODE=
  • FAST
  • UNDERFLOW_TO_ZERO
  • DENORM_RESULTS

The default, /IEEE_MODE=FAST, provides faster run-time performance than UNDERFLOW_TO_ZERO or DENORM_RESULTS. Specifying DENORM_RESULTS provides the slowest run-time performance.

FAST

Specifies that the program should stop if any exceptional values are detected. This is the default.

When the program encounters or calculates any exceptional values (infinity (+ or --), NaN, or invalid data) in a calculation, the program stops and displays a message. This allows the fastest run-time performance.

Denormalized values calculated in an arithmetic expression are set to zero. Denormalized values encountered as variables in an arithmetic expression (including constant values) are treated as invalid data (an exceptional value), which stops the program.

Exceptions are not reported until one or more instructions after the instruction that caused the exception. To have exceptions reported at the instruction that caused the exception when using /IEEE_MODE=FAST, also specify /SYNCHRONOUS_EXCEPTIONS.

Using FAST (default) allows fast run-time performance for those programs that do not generate exceptional values.

UNDERFLOW_TO_ZERO

Specifies that the program should continue if any exceptional values are detected and set calculated denormalized (underflow) values to zero.

When the program encounters an exceptional value (infinity (+ or --), NaN, invalid data) in an arithmetic expression, the program continues. It also continues when the result of a calculation is an exceptional value.

Calculated denormalized values are set to zero (0). This prevents the denormalized number from being used in a subsequent calculation (propagated).

Exceptions are reported at the instruction that caused the exception (same as /SYNCHRONOUS_EXCEPTIONS). This allows precise run-time reporting of exceptions for those programs that generate exceptional values, but this slows program run-time performance.

Using UNDERFLOW_TO_ZERO allows programs to handle exceptional values, but does not propagate numbers in the denormalized range.

To request run-time messages for arithmetic exceptions, specify the /CHECK=FP_EXCEPTIONS qualifier.

DENORM_RESULTS

Specifies that the program should continue if any exceptional values are detected and leave calculated denormalized values as is (allows underflow).

When the program encounters an exceptional value (infinity (+ or --), NaN, invalid data) in an arithmetic expression, the program continues. It also continues when the result of a calculation is an exceptional value.

Calculated denormalized values are left as denormalized values. When a denormalized number is used in a subsequent arithmetic expression, it requires extra software-assisted handling and slows performance. A program that generates denormalized numbers will be slower than the same program compiled using /IEEE_MODE=UNDERFLOW_TO_ZERO.

Exceptions are reported at the instruction that caused the exception (same as /SYNCHRONOUS_EXCEPTIONS). This allows precise run-time reporting of exceptions for those programs that generate exceptional values, but this slows program run-time performance.

Using DENORM_RESULTS allows programs to handle exceptional values, including allowing underflow of denormalized numbers.

To request run-time messages for arithmetic exceptions, specify the /CHECK=FP_EXCEPTIONS qualifier. To request run-time messages for only those arithmetic exceptions related to denormalized numbers, specify the /CHECK=UNDERFLOW qualifier.

For More Information:

2.3.24 /INCLUDE --- Add Directory for INCLUDE and Module File Search

The /INCLUDE qualifier specifies one or more additional directories for the Compaq Fortran compiler to search for:

If the INCLUDE statement specifies an explicit device and/or directory, only that directory is searched.

If you omit /INCLUDE, the compiler searches in the current directory for module files and either the current directory or the directory containing the source file specified on the FORTRAN command line for include files or text libraries:

The order of directory searching follows:

  1. The current directory (omit /ASSUME=SOURCE_INCLUDE) or the directory where the source file resides (specify /ASSUME=SOURCE_INCLUDE).
  2. One or more directories specified by the /INCLUDE qualifier.
  3. The location defined by the logical name FORT$INCLUDE (if defined). To prevent searching in this directory, specify /NOINCLUDE.

If you do not specify /INCLUDE or /NOINCLUDE, the compiler searches first in the current directory (or directory where the source file resides) and then the directory specified by FORT$INCLUDE (if defined).

To request that the compiler only search in the current directory (or directory where the source file resides), specify /NOINCLUDE. This prevents the compiler from searching the FORT$INCLUDE directory. If you use /NOINCLUDE, you cannot specify /INCLUDE.

To request that the compiler only search in the directory specified by FORT$INCLUDE, specify /INCLUDE=FORT$INCLUDE.

To control the searching for text libraries (not included files or modules), you can also use the logical name FORT$LIBRARY.

Like other OpenVMS logical names, it can specify the location for your process only or for multiple processes (including system-wide).

To specify the additional directories DISKA:[PROJ_MODULE.F90] and DISKB:[F_COMMON.F90] with the /INCLUDE qualifier, use a single /INCLUDE qualifier, as follows:


$ FORTRAN PROJ_M.F90 /INCLUDE=(DISKA:[PROJ_MODULE.F90],DISKB:[F_COMMON.F90])

If you specify multiple directories, the order of the directories (and their devices) in the /INCLUDE qualifier determines the directory search order.

For More Information:

2.3.25 /INTEGER_SIZE --- Integer and Logical Data Size

The /INTEGER_SIZE qualifier controls how the compiler interprets INTEGER or LOGICAL declarations that do not have a specified length. The default is INTEGER_SIZE=32.

The qualifier has the following form:

/INTEGER_SIZE=
  • 16
  • 32
  • 64

16

Indicates that INTEGER declarations are interpreted as INTEGER (KIND=2) and LOGICAL declarations as LOGICAL (KIND=2). Same as the obsolete /NOI4 qualifier.

32

Indicates that INTEGER declarations are interpreted as INTEGER (KIND=4) and LOGICAL declarations as LOGICAL (KIND=4). Same as the obsolete /I4 qualifier.

64

Indicates that INTEGER declarations are interpreted as INTEGER (KIND=8) and LOGICAL declarations as LOGICAL (KIND=8)

For performance reasons, use INTEGER (KIND=4) data instead of INTEGER (KIND=2) or INTEGER (KIND=1) and whenever possible. You must explicitly declare INTEGER (KIND=1) data.

Note

To improve performance, use /INTEGER_SIZE=32 rather than /INTEGER_SIZE=16 and declare variables as INTEGER (KIND=4) (or INTEGER (KIND=8)) rather than INTEGER (KIND=2) or INTEGER (KIND=1). For logical data, avoid using /INTEGER_SIZE=16 and declare logical variables as LOGICAL (KIND=4) rather than LOGICAL (KIND=2) or LOGICAL (KIND=1).

For More Information:

2.3.26 /LIBRARY --- Specify File as Text Library

The /LIBRARY qualifier specifies that a file is a text library file.

The qualifier has the following form:

text-library-file/LIBRARY

The /LIBRARY qualifier can be specified on one or more text library files in a list of files concatenated by plus signs (+). At least one of the files in the list must be a nonlibrary file. The default file type is TLB.

For More Information:

2.3.27 /LIST --- Request Listing File

The /LIST qualifier requests a source listing file. You can request additional listing information using the /MACHINE_CODE and /SHOW qualifiers.

The qualifier has the following form:

/LIST[=file-spec]

You can include a file specification for the listing file. If you omit the file specification, the listing file has the name of the first source file and a file type of LIS.

The default depth of a page in a listing file is 66 lines. To modify the default, assign the new number to the logical name SYS$LP_LINES, using the DCL command DEFINE. For example, the following DCL command sets the page depth at 88 lines:


$ DEFINE SYS$LP_LINES 88

The valid number of lines per page ranges from 30 to a maximum of 255. The definition can be applied to the entire system by using the command DEFINE/SYSTEM.

In interactive mode, the compiler does not produce a listing file unless you include the /LIST qualifier. In batch mode, the compiler produces a listing file by default. In either case, the listing file is not automatically printed; you must use the PRINT command to obtain a line printer copy of the listing file.

If a source line of length 1 contains a form-feed character, the source code listing begins a new page with the following line; the line containing the form-feed does not appear.

If a source line of length greater than 1 contains a form-feed character, that line is printed but the form-feed character is ignored (does not generate a new page).

Any other nonprinting ASCII characters encountered in Compaq Fortran source files are replaced by a space character, and a warning message appears.

You can request additional information in the listing file using the /MACHINE_CODE and /SHOW qualifiers.

The listing file includes the Compaq Fortran version number.

The /ANNOTATIONS qualifier controls whether an annotated listing showing optimizations is included with the listing file.

For More Information:

2.3.28 /MACHINE_CODE --- Request Machine Code in Listing File

Specifying /MACHINE_CODE requests that the listing file include a symbolic representation of the OpenVMS Alpha object code generated by the compiler. Generated code and data are represented in a form similar to a Assembly code listing. The code produced by the /MACHINE_CODE qualifier is for informational purposes only. It is not intended to be assembled and is not supported by the MACRO assembler.

If a listing file is not being generated, the /MACHINE_CODE qualifier is ignored.

The default is /NOMACHINE_CODE.

For More Information:

2.3.29 /MATH_LIBRARY --- Fast or Accurate Math Library Routines

If you omit /MATH_LIBRARY=FAST (and /FAST), the compiler uses the standard, very accurate math library routines for each Compaq Fortran intrinsic function, such as SQRT (default is /MATH_LIBRARY=ACCURATE).

Specify /MATH_LIBRARY=FAST to use a special version of certain math library routines that produce faster results, but with a slight loss of precision and less exception checking.

This qualifier applies only to IEEE data types (when you specify /FLOAT=IEEE_FLOAT). The qualifier has the following form:

/MATH_LIBRARY=
  • ACCURATE
  • FAST

ACCURATE

Using /MATH_LIBRARY=ACCURATE (default if you omit /FAST) produces the very accurate results and error checking expected of quality compiler products. It uses the standard set of math library routines for the applicable intrinsics.

The standard math library routines are designed to obtain very accurate "near correctly rounded" results and provide the robustness needed to check for IEEE exceptional argument values, rather than achieve the fastest possible run-time execution speed. Using /MATH_LIBRARY=ACCURATE allows user control of arithmetic exception handling with the /IEEE_MODE qualifier.

FAST

Specifying /MATH_LIBRARY=FAST (default if you specify /FAST) use versions of certain math library routines that perform faster computations than the standard, more accurate math library routines, but with slightly less fractional accuracy and less reliable arithmetic exception handling. Using /MATH_LIBRARY=FAST allows certain math library functions to get significant performance improvements when the applicable intrinsic function is used.

If you specify /MATH_LIBRARY=FAST, the math library routines do not necessarily check for IEEE exceptional values and the /IEEE_MODE qualifier is ignored.

When you use MATH_LIBRARY=FAST, you should carefully check the calculated output from your program. Check the program's calculated output to verify that it is not relying on the full fractional accuracy of the floating-point data type (see Section 8.4) to produce correct results or producing unexpected exceptional values (exception handling is indeterminate).

Programs that do not produce acceptable results with /MATH_LIBRARY=FAST and single-precision data might produce acceptable results with /MATH_LIBRARY=FAST if they are modified (or compiled) to use double-precision data.

The specific intrinsic routines that have special fast math routines depend on the version of the OpenVMS Alpha operating system in use. Allowed error bounds vary with each routine.

For More Information:

2.3.30 /MODULE --- Placement of Module Files

The /MODULE qualifier controls where module files (.F90$MOD) are placed. If you omit this qualifier or specify /NOMODULE, the .F90$MOD files are placed in your current default directory.

The qualifier has the following form

/MODULE=directory

If you specify this qualifier as shown, .F90$MOD files are placed in the directory location as indicated.

2.3.31 /NAMES --- Control Case of External Names

The /NAMES qualifier specifies how the Compaq Fortran compiler represents external (global) names to the linker.

The qualifier has the following form:

/NAMES=
  • UPPERCASE
  • LOWERCASE
  • AS_IS

UPPERCASE

Causes the compiler to ignore case differences in identifiers and to convert external names to uppercase. This is the default.

LOWERCASE

Causes the compiler to ignore case differences in identifiers and to convert external names to lowercase.

AS_IS

Causes the compiler to distinguish case differences in identifiers and to preserve the case of external names.

The default, /NAMES=UPPERCASE, means that Compaq Fortran converts external names to uppercase.

For More Information:

2.3.32 /OBJECT --- Specify Name or Prevent Object File Creation

The /OBJECT qualifier specifies the name of the object file or prevents object file creation.

The qualifier has the following form:

/OBJECT[=file-spec]

The default is /OBJECT. If you omit the file specification, the object file has the name of the first source file and a file type of OBJ.

Use the negative form, /NOOBJECT, to suppress object code (for example, when you want to test only for compilation errors in the source program).

For More Information:

On using the /OBJECT qualifier, see Section 2.2.5.

2.3.33 /OLD_F77 --- Use Old FORTRAN 77 Compiler

To use the Compaq Fortran 77 compiler, specify /OLD_F77 as the first qualifier on the FORTRAN command line. The default is to use the Compaq Fortran (90/95 language) compiler. The default Compaq Fortran compiler supports the FORTRAN 77 language as well as the Fortran 90 and Fortran 95 standards.

If you specify the /OLD_F77 qualifier, certain FORTRAN command qualifiers will be ignored, including qualifiers associated with Fortran 90 and Fortran 95 features, Fortran 90 and 95 standards checking, and certain optimization keywords.

2.3.34 /OPTIMIZE --- Specify Compiler Optimizations

The /OPTIMIZE qualifier requests that the compiler produce optimized code.

The qualifier has the following form:

/OPTIMIZE=
  • LEVEL=n
  • INLINE= NONE
  • MANUAL
  • SIZE
  • SPEED
  • ALL
  • NOINLINE
  • LOOPS
  • PIPELINE
  • TUNE= GENERIC
  • HOST
  • EV4
  • EV5
  • EV56
  • PCA6
  • EV6
  • EV67
  • UNROLL=n
[, ...]

The default is /OPTIMIZE, which is equivalent to /OPTIMIZE=LEVEL=4. Use the negative form, /NOOPTIMIZE or /OPTIMIZE=LEVEL=0, for a debugging session to ensure that the debugger has sufficient information to locate errors in the source program.

In most cases, using /OPTIMIZE will make the program execute faster. As a side effect of getting the fastest execution speeds, using /OPTIMIZE can produce larger object modules and longer compile times than /NOOPTIMIZE.

To allow full interprocedure optimization when compiling multiple source files, consider separating source file specifications with plus signs (+), so the files are concatenated and compiled as one program. Full interprocedure optimization can reduce overall program execution time (see Section 5.1.2). Consider not concatenating source files when the size of the source files is excessively large and the amount of memory or disk space is limited.

The /OPTIMIZE keywords follow:

LEVEL

You can specify the optimization level with /OPTIMIZE=LEVEL=n, where n is from 0 to 5, as follows:

INLINE

You can specify the level of inlining with /OPTIMIZE=INLINE=xxxxx, where xxxx is one of the following keywords:

NOINLINE

Same as INLINE=NONE.

LOOPS

Specifying /OPTIMIZE=LOOPS (or /OPTIMIZE=LEVEL=5) activates a group of loop transformation optimizations that apply to array references within loops. These optimizations can improve the performance of the memory system and usually apply to multiple nested loops. The loops chosen for loop transformation optimizations are always counted loops (which include DO or IF loops, but not uncounted DO WHILE loops).

Conditions that typically prevent the loop transformation optimizations from occurring include subprogram references that are not inlined (such as an external function call), complicated exit conditions, and uncounted loops.

The types of optimizations associated with /OPTIMIZE=LOOPS include the following:

The loop transformation optimizations are a subset of optimizations activated by /OPTIMIZE=LEVEL=5. Instead of specifying both LOOPS and PIPELINE, you can specify /OPTIMIZE=LEVEL=5.

To specify loop transformation optimizations without software pipelining, do one of the following:

To determine whether using /OPTIMIZE=LOOPS benefits your particular program, you should time program execution for the same program (or subprogram) compiled with and without loop transformation optimizations (such as with /OPTIMIZE=LOOPS and /OPTIMIZE=NOLOOPS).

PIPELINE

Specifying /OPTIMIZE=PIPELINE (or /OPTIMIZE=LEVEL=4) activates the software pipelining optimization. The software pipelining optimization applies instruction scheduling to certain innermost loops, allowing instructions within a loop to "wrap around" and execute in a different iteration of the loop. This can reduce the impact of long-latency operations, resulting in faster loop execution.

For this version of Compaq Fortran, loops chosen for software pipelining are always innermost loops and do not contain branches, procedure calls, or COMPLEX floating-point data.

Software pipelining can be more effective when you combine /OPTIMIZE=PIPELINE with the appropriate /OPTIMIZE=TUNE=xxxx keyword for the target Alpha processor generation (see the TUNE keyword in this section).

Software pipelining also enables the prefetching of data to reduce the impact of cache misses.

Software pipelining is a subset of the optimizations activated by /OPTIMIZE=LEVEL=4.

To specify software pipelining without loop transformation optimizations, do one of the following:

To determine whether using /OPTIMIZE=PIPELINE benefits your particular program, you should time program execution for the same program (or subprogram) compiled with and without software pipelining (such as with /OPTIMIZE=PIPELINE and /OPTIMIZE=NOPIPELINE).

For programs that contain loops that exhaust available registers, longer execution times may result with /OPTIMIZE=LEVEL=5, requiring use of /OPTIMIZE=UNROLL=n to limit loop unrolling (see the UNROLL keyword in this section).

TUNE

You can specify the types of processor-specific instruction tuning for implementations of the Alpha architecture using the /OPTIMIZE=TUNE=xxxx keywords. Regardless of the setting of /OPTIMIZE=TUNE=xxxx you use, the generated code runs correctly on all implementations of the Alpha architecture. Tuning for a specific implementation can improve run-time performance; it is also possible that code tuned for a specific target may run slower on another target.

The /OPTIMIZE=TUNE=xxxx keywords are as follows:

If /OPTIMIZE=TUNE=xxxx specifies a processor of less functionality than is specified by /ARCHITECTURE, code is optimized for the processor specified by /ARCHITECTURE.

If you omit /OPTIMIZE=TUNE=xxxx, HOST is used if /FAST is specified; otherwise GENERIC is used.

UNROLL

You can specify the number of times loops are unrolled with /OPTIMIZE= UNROLL=n, where n is a number from 0 to 16. If you omit the UNROLL keyword or specify UNROLL=0 (the default), the optimizer determines how many times loops are unrolled. Usually loops are unrolled four times, but code analysis may result in certain loops being unrolled two times (twice).

Compaq Fortran unrolls loops at /OPTIMIZE=LEVEL=3 or higher. When timings using LEVEL=5 show that performance has not improved, consider specifying UNROLL=1 with LEVEL=5, such the following:


$ FORTRAN /OPTIMIZE=(LEVEL=5,UNROLL=1) M_APP.F90+SUB.F90/NOLIST

For More Information:

2.3.35 /PAD_SOURCE --- Pad Source Lines with Spaces

Controls how the compiler treats fixed-form file source lines that are shorter than the statement field width (72 characters, or 132 characters if /EXTEND_SOURCE is in effect.) This determines how the compiler treats character and Hollerith constants that are continued across two or more source lines. This qualifier does not apply to free-form source files.

Specifying /PAD_SOURCE causes the compiler to treat short source lines as if they were padded with blanks out to the statement field width. This may be useful when compiling programs developed for non-Compaq compilers that assume that short source lines are blank-padded.

The default, /NOPAD_SOURCE, is compatible with current and previous Compaq Fortran compilers, which causes the compiler to not treat short source lines as padded with blanks so that the first character of a continuation line immediately follows the last character of the previous line.

If /NOPAD_SOURCE is in effect, the compiler issues an informational message if it detects a continued constant that might be affected by blank padding.

For More Information:

On /WARNINGS=USAGE qualifier, see Section 2.3.50.

2.3.36 /REAL_SIZE --- Floating-Point Data Size

The /REAL_SIZE qualifier controls how the compiler interprets floating-point declarations that do not have a specified length.

The qualifier has the following form:

/REAL_SIZE=
  • 32
  • 64
  • 128

32

Defines REAL declarations, constants, functions, and intrinsics as REAL (KIND=4) (single precision) and COMPLEX declarations, constants, functions, and intrinsics as COMPLEX (KIND=4) (single complex).

64

Defines REAL and COMPLEX declarations, constants, functions, and intrinsics as REAL (KIND=8) (double precision) and COMPLEX declarations, constants, functions, and intrinsics as COMPLEX (KIND=8) (double complex).

This also causes intrinsic functions to produce a double precision REAL (KIND=8) or COMPLEX (KIND=8) result instead of a single precision REAL (KIND=4) or COMPLEX (KIND=4) result, except if the argument is explicitly typed.

For instance, references to the CMPLX intrinsic produce DCMPLX results (COMPLEX (KIND=8)), except if the argument to CMPLX is explicitly typed as REAL (KIND=4) or COMPLEX (KIND=4), in which case the resulting data type is COMPLEX (KIND=4). Other affected intrinsic functions include CMPLX, FLOAT, REAL, SNGL, and AIMAG.

128

Specifying /REAL_SIZE=128 defines:

If you omit /REAL_SIZE=128, then:

Specifying /REAL_SIZE=128 causes REAL, DOUBLE PRECISION, COMPLEX, and DOUBLE COMPLEX intrinsic functions to produce REAL (KIND=16) or COMPLEX (KIND=16) results unless their arguments are typed with an explicit KIND type parameter.

For instance, a reference to the CMPLX intrinsic with /REAL_SIZE=128 produces a COMPLEX (KIND=16) result unless the argument is explicitly typed as REAL (KIND=4) or COMPLEX (KIND=4), in which case the result is COMPLEX (KIND=4).

The default is /REAL_SIZE=32.

For More Information:

2.3.37 /RECURSIVE --- Data Storage and Recursion

The /RECURSIVE qualifier requests that Compaq Fortran generate code and allocate data so that a subroutine or a function can be called recursively.

The /RECURSIVE qualifier:

Subprograms declared with the RECURSIVE keyword are always recursive (whether you specify or omit the /RECURSIVE qualifier).

Variables declared with the AUTOMATIC statement or attribute always use stack-based storage for all local variables (whether you specify or omit the /RECURSIVE or /AUTOMATIC qualifiers).

Specifying /RECURSIVE sets /AUTOMATIC.

For More Information:

On the RECURSIVE keyword, see the Compaq Fortran Language Reference Manual.

2.3.38 /REENTRANCY --- Specify Threaded or Asynchronous Reentrancy

The /REENTRANCY qualifier specifies whether code generated for the main program and any Fortran procedures it calls will be relying on threaded or asynchronous reentrancy. The default is /REENTRANCY=NONE.

The qualifier has the following form:

/REENTRANCY=
  • ASYNC
  • NONE
  • THREADED

ASYNC

Informs the Compaq Fortran run-time library that the program may contain asynchronous handlers that could call the RTL. The run-time library will guard against asynchronous interrupts inside its own critical regions.

NONE

Informs the Compaq Fortran run-time library that the program will not be relying on threaded or asynchronous reentrancy. The run-time library need not guard against such interrupts inside its own critical regions. Same as /NOREENTRANCY.

THREADED

Informs the Compaq Fortran run-time library that the program is multithreaded, such as programs using the DECthreads library. The run-time library will use thread locking to guard its own critical regions.

To use the kernel threads libraries, also specify the /THREADS_ENABLE qualifier on the LINK command (see the Guide to POSIX Threads Library).

Specifying NOREENTRANCY is equivalent to /REENTRANCY=NONE.

For More Information:

On writing multithreaded applications, see the Guide to POSIX Threads Library.

2.3.39 /ROUNDING_MODE --- Specify IEEE Floating-Point Rounding Mode

The /ROUNDING_MODE qualifier allows you to control how rounding occurs during calculations. This qualifier applies only to IEEE data types (when you specify /FLOAT=IEEE_FLOAT). Note that if you specify /FLOAT=G_FLOAT or /FLOAT=D_FLOAT, /IEEE_MODE must not also be specified.

The qualifier has the following form:

/ROUNDING_MODE=
  • NEAREST
  • CHOPPED
  • MINUS_INFINITY
  • DYNAMIC

NEAREST

This is the normal rounding mode, where results are rounded to the nearest representable value. If you omit the /ROUNDING_MODE qualifier, /ROUNDING_MODE=NEAREST is used.

CHOPPED

Results are rounded toward zero (representative value).

MINUS_INFINITY

Results are rounded toward the next smallest representative value.

The rounding mode applies to each program unit being compiled.

For More Information:

2.3.40 /SEPARATE_COMPILATION --- Control Compilation Unit Use in Object Files

Controls whether the Compaq Fortran compiler:

The default is /NOSEPARATE_COMPILATION.

When creating object modules for use in an object library, consider using /SEPARATE_COMPILATION to minimize the size of the routines included by the linker as it creates the executable image. In most cases, to allow more interprocedure optimizations, use the default /NOSEPARATE_COMPILATION.

For More Information:

2.3.41 /SEVERITY --- Specify Compiler Diagnostic Severity

The /SEVERITY qualifier changes one or both of the following:

The qualifier has the following form:

/SEVERITY=WARNINGS=
  • WARNING
  • ERROR
  • STDERROR

The default is that compiler diagnostic warning messages and standards checking messages have a severity of warning or /SEVERITY=(WARNINGS=WARNING).

You can specify one of the following:

For example, the following command line requests that compiler diagnostic messages have a severity of warning (default) and standards checking messages have a severity of error (and requests Fortran 95 standards checking)::


$ FORTRAN/SEVERITY=WARNINGS=STDERROR/STANDARD=F95 file.F90

For More Information:

2.3.42 /SHOW --- Control Source Content in Listing File

The /SHOW qualifier controls whether optionally listed source lines and a symbol map appear in the source listing. (Optionally listed source lines are text-module source lines.)

For the /SHOW qualifier to take effect, you must specify the /LIST qualifier.

The qualifier has the following form:

/SHOW =
    • [NO]INCLUDE
    • [NO]MAP
    [, ...]
    • ALL
    • NONE

ALL

Requests that all optionally listed source lines and a symbol map be included in the listing file. Specifying /SHOW is equivalent to /SHOW=ALL.

[NO]INCLUDE

Controls whether the source lines from any file or text module specified by INCLUDE statements are included in the source listing.

[NO]MAP

Controls whether the symbol map is included in the listing file.

NONE

Requests that no optionally listed source lines or a symbol map be included in the listing file. Specifying /NOSHOW is equivalent to /SHOW=NONE.

The /SHOW qualifier defaults are NOINCLUDE and MAP.

Specifying the qualifier /SHOW without any arguments is equivalent to specifying /SHOW=ALL; specifying /NOSHOW without any arguments is equivalent to specifying /SHOW=NONE.

For More Information:

On the /LIST qualifier, see Section 2.3.27.

2.3.43 /SOURCE_FORM --- Fortran 90/95 Source Form

The /SOURCE_FORM qualifier allows you to specify whether all Compaq Fortran source files on the FORTRAN command line are in fixed or free source form. The qualifier has the following form:

/SOURCE_FORM=
  • FIXED
  • FREE

FIXED

Specifying /SOURCE_FORM=FIXED indicates that the input source files will be in fixed source form, regardless of the file type. Source files with a file type of FOR or F (or any file type other than F90) are assumed to contain fixed source form.

FREE

Specifying /SOURCE_FORM=FREE indicates that the source form will be free form, regardless of the file type. Source files with a file type of F90 are assumed to contain free source form.

For More Information:

On column positions and source forms, see the Compaq Fortran Language Reference Manual.

2.3.44 /STANDARD --- Perform Fortran 90/95 Standards Checking

The /STANDARD qualifier instructs the compiler to generate informational messages for language elements that are not standard in the Fortran 90 or Fortran 95 language and that can be identified at compile-time. The default is /NOSTANDARD. If you specify /STANDARD with no value, the default is Fortran 95.

The qualifier has the following form:

/[NO]STANDARD=
  • F90
  • F95
  • NONE

The /STANDARD=F90 qualifier requests that the compiler issue informational messages for:

The /STANDARD=F95 qualifier (or /STANDARD) requests that the compiler issue informational messages for:

Specifying /STANDARD=NONE is equivalent to /NOSTANDARD.

If you specify the /NOWARNINGS qualifier, the /STANDARD qualifier is ignored.

If you omit the /STANDARD qualifier, the default is /NOSTANDARD.

To change the severity of standards checking warning messages to error severity, specify /SEVERITY=WARNINGS=SDTERROR (see Section 2.3.41).

Source statements that do not conform to Fortran 90 or Fortran 95 language standards are detected by the Compaq Fortran compiler under the following circumstances:

Given these circumstances, the compiler is able to detect most instances of nonconforming usage. It does not detect all instances because the /STANDARD qualifier does not produce checks for all nonconforming usage at compile time. In general, the unchecked cases of nonconforming usage arise from the following situations:

Most of the unchecked cases occur in the interface between calling and called subprograms. However, other cases are not checked, even within a single subprogram.

The following items are known to be unchecked:

For More Information:

On the Compaq Fortran language, see the Compaq Fortran Language Reference Manual.

2.3.45 /SYNCHRONOUS_EXCEPTIONS --- Report Exceptions More Precisely

The /SYNCHRONOUS_EXCEPTIONS qualifier associates an exception with the instruction that causes it. Specifying /SYNCHRONOUS_EXCEPTIONS slows program execution, so only specify it when debugging a specific problem, such as locating the source of an exception.

If you omit /SYNCHRONOUS_EXCEPTIONS, /NOSYNCHRONOUS_EXCEPTIONS is used where exceptions can be reported imprecisely one or more instructions after the instruction that caused the exception.

Specifying /IEEE_MODE=FAST (default) provides imprecise exception reporting (same as /NOSYNCHRONOUS_EXCEPTIONS). Specifying other /IEEE_MODE keywords (when you also specify /FLOAT=IEEE_FLOAT) provides precise exception reporting (same as /SYNCHRONOUS_EXCEPTIONS).

For More Information:

2.3.46 /SYNTAX_ONLY --- Do Not Create Object File

The /SYNTAX_ONLY qualifier requests that source file be checked only for correct syntax. If you specify the /SYNTAX_ONLY qualifier, no code is generated, no object file is produced, and some error checking done by the optimizer is bypassed (for example, checking for uninitialized variables with /WARNINGS=UNINITIALIZED). This qualifier allows you to do a quick syntax check of your source file, and is especially useful in conjunction with /WARNINGS=ARGUMENT_CHECKING.

For More Information:

2.3.47 /VERSION --- Display the Compaq Fortran Version Number

The /VERSION qualifier can be used alone on the FORTRAN command line to display the Compaq Fortran version number. If you specify /VERSION, compilation does not occur.

For example:


$ FORTRAN /VERSION
Compaq Fortran V7.n-nnn-nnnn
$ 

2.3.48 /TIE --- Enable Code for Shared Translated Images

The /TIE qualifier enables compiled code to be used with translated shared images, either because the code might call into a translated image or might be called from a translated image. Specifying /NOTIE, the default, indicates the compiled code will not be associated with a translated image.

If you specify /TIE, link the object module using the LINK command /NONATIVE_ONLY qualifier, and follow the guidelines provided in Section A.6.

For More Information:

On appropriate LINK command qualifiers, see Section 3.1.1 and Section A.6.

2.3.49 /VMS --- Request Compaq Fortran 77 for OpenVMS VAX Compatibility

The /VMS qualifier (default) specifies that the run-time system behave like Compaq Fortran 77 for OpenVMS VAX Systems (VAX FORTRANtm) in certain ways. To prevent this behavior, specify /NOVMS.

The /VMS qualifier specifies the following aspects of the run-time system:

To override the effects of the /VMS qualifier, specify /NOVMS.

For More Information:

On the OPEN statement, see the Compaq Fortran Language Reference Manual.

2.3.50 /WARNINGS --- Warning Messages and Compiler Checking

The /WARNINGS qualifier instructs the compiler to generate informational (I-level) and warning (W-level) diagnostic messages in response to informational and warning-level errors.

The following /WARNING keywords prevent the display of warning messages:

NOALIGNMENT (default is ALIGNMENT)
NOGENERAL (default is GENERAL)
NOGRANULARITY (default is GRANULARITY)
NOUNCALLED (default is UNCALLED)
NOUNINITIALIZED (default is UNINITIALIZED)
NOUSAGE (default is USAGE)

The following /WARNING keywords can display additional warning messages (request additional checking):

ARGUMENT_CHECKING (default is NOARGUMENT_CHECKING)
DECLARATIONS (default is NODECLARATIONS)
IGNORE_LOC (default is NOIGNORE_LOC)
TRUNCATED_SOURCE (default is NOTRUNCATED_SOURCE)
UNUSED (default is NOUNUSED)

If you omit /WARNINGS, the defaults are:

/WARNINGS=(ALIGNMENTS,NOARGUMENT_CHECKING,NODECLARATIONS, NOERRORS,FILEOPTS, GENERAL,GRANULARITY,NOIGNORE_LOC,NOSTDERRORS,NOTRUNCATED_SOURCE,UNCALLED , UNITIALIZED, NOUNUSED,USAGE)

The qualifier has the following form:

/WARNINGS =
    • [NO]ALIGNMENT
    • [NO]ARGUMENT_CHECKING
    • [NO]DECLARATIONS
    • [NO]GENERAL
    • [NO]GRANULARITY
    • [NO]IGNORE_LOC
    • [NO]TRUNCATED_SOURCE
    • [NO]UNCALLED
    • [NO]UNINITIALIZED
    • [NO]UNUSED
    • [NO]USAGE
    [, ...]
    • ALL
    • NONE

[NO]ALIGNMENT

Controls whether the compiler issues diagnostic messages when variables or arrays (created in COMMON or EQUIVALENCE statements) are declared in such a way that they cross natural boundaries for their data size. For example, a diagnostic message is issued if /WARNINGS=ALIGNMENT is in effect and the virtual address of a REAL (KIND=8) variable is not a multiple of 8.

The default is ALIGNMENT. To suppress diagnostic messages about unaligned data, specify NOALIGNMENT.

To control the alignment of fields in common blocks, derived types, and record structures, use the /ALIGNMENT qualifier (see Section 2.3.3).

[NO]ARGUMENT_CHECKING

Controls whether the compiler issues diagnostic messages for argument mismatches between caller and callee (when compiled together). The default is /WARNINGS=NOARGUMENT_CHECKING.

[NO]DECLARATIONS

Controls whether the compiler issues diagnostic messages for any untyped data item used in the program. DECLARATIONS acts as an external IMPLICIT NONE declaration. See the description of the IMPLICIT statement in the Compaq Fortran Language Reference Manual for information about the effects of IMPLICIT NONE.

The default is NODECLARATIONS.

[NO]GENERAL

Controls whether the compiler issues I-level and W-level diagnostic messages. An I-level message indicates that a correct Compaq Fortran statement may have unexpected results or contains nonstandard syntax or source form. A W-level message indicates that the compiler has detected acceptable, but nonstandard, syntax or has performed some corrective action; in either case, unexpected results may occur.

To suppress I-level and W-level diagnostic messages, specify the negative form of this qualifier (/WARNINGS=NOGENERAL).

The default is GENERAL.

[NO]GRANULARITY

Controls whether the compiler issues the compiler diagnostic message "Unable to generate code for requested granularity" to indicate when data access might not occur safely from different threads in a shared memory system (such as asynchronous write access from outside the user process). The default is /WARNINGS=GRANULARITY.

For more information on data granularity and controlling the size of data that can be safely accessed from different threads, see Section 2.3.22.

[NO]IGNORE_LOC

Requests that the compiler issue warnings when %LOC is stripped from an argument due to specification of the IGNORE_LOC attribute. The default is /WARNINGS=NOIGNORE_LOC (does not issue a warning for this condition).

[NO]TRUNCATED_SOURCE

Controls whether the compiler issues a warning diagnostic message (EXCCHASRC) when it reads a fixed-form source line with a statement field that exceeds the maximum column width. The maximum column width is column 72 or 132, depending whether /EXTEND_SOURCE qualifier was specified (or its OPTIONS statement qualifier).

This option has no effect on truncation; lines that exceed the maximum column width are always truncated.

The default is /WARNINGS=NOTRUNCATED_SOURCE.

[NO]UNCALLED

Suppresses the compiler warning diagnostic message when a statement function is never called. The default is /WARNINGS=UNCALLED.

[NO]UNINITIALIZED

Controls whether warning messages are issued when a variable is referenced before a value was assigned to it. Specify NOUNINITIALIZED to suppress such warning messages.

The default, UNINITIALIZED, issues warning messages when a variable is referenced before a value was assigned to it.

[NO]UNUSED

Requests warning messages for a variable that is declared but never used. The default is /WARNINGS=NOUNUSED.

[NO]USAGE

Specifying /WARNINGS=NOUSAGE suppresses informational messages about questionable programming practices and the use of intrinsic functions that use only two digits to represent years (such as 2000). The compiler allows such programming practices, although they are often an artifact of programming errors. For example, a continued character or Hollerith literal whose first part ends before the statement field and appears to end with trailing spaces.

The default is USAGE.

ALL

Causes the compiler to print all I-level and W-level diagnostic messages, including warning messages for any unaligned data and untyped data items. Specifying ALL is equivalent to /WARNINGS and has the effect of specifying /WARNINGS=(ALIGNMENT, DECLARATIONS, GENERAL, UNCALLED, UNINITIALIZED ).

NONE

Suppresses all I-level and W-level messages. Specifying /NOWARNINGS is equivalent to /WARNINGS=NONE.

For More Information:

2.4 Using Text Libraries

A text library contains library modules of source text. To include a library module from a text library in a program, use an INCLUDE statement.

Library modules within a text library are like ordinary text files, but they differ in the following ways:

Library modules in text libraries can contain any kind of text; this section only discusses their use when Compaq Fortran language source is used.

You should be aware of the difference between library modules that reside in text libraries and the Compaq Fortran post-compiled module files (.F90$MOD file type) that support use association (see Section 2.2.3).

Use the LIBRARY command (OpenVMS Librarian Utility) to create text libraries and insert, replace, delete, copy, or list library modules in text libraries. Text libraries have a default file type of TLB.

Figure 2-2 shows the creation of a text library and its use in compiling Compaq Fortran programs.

Figure 2-2 Creating and Using a Text Library


Creating and Using a Text Library

For More Information:

2.4.1 Using the LIBRARY Commands

Table 2-3 summarizes the commands that create libraries and provide maintenance functions. For a complete list of the qualifiers for the LIBRARY command and a description of other DIGITAL Command Language (DCL) commands listed in Table 2-3, see the Guide to Using OpenVMS Command Procedures or type HELP LIBRARY.

Table 2-3 Commands to Control Library Files
Function Command Syntax1
Create a library. LIBRARY/TEXT/CREATE library-name file-spec,...
Add one or more library modules to a library. LIBRARY/TEXT/INSERT library-name file-spec,...
Replace one or more library modules in a library. LIBRARY/TEXT/REPLACE library-name file-spec,... 2
Specify the names of library modules to be added to a library. LIBRARY/TEXT/INSERT library-name file-spec/MODULE=
module-name
Delete one or more library modules from a library. LIBRARY/TEXT/DELETE=(module-name,...) library-name
Copy a library module from a library into another file. LIBRARY/TEXT/EXTRACT=module-name/OUTPUT=
file-spec library-name
List the library modules in a library. LIBRARY/TEXT/LIST=file-spec library-name


1The LIBRARY command qualifier /TEXT indicates a text module library. By default, the LIBRARY command assumes an object module library.
2REPLACE is the default function of the LIBRARY command if no other action qualifiers are specified. If no library module exists with the given name, /REPLACE is equivalent to /INSERT.

2.4.2 Naming Text Library Modules

When the LIBRARY command adds a library module to a library, by default it uses the file name of the input file as the name of the library module. In the example in Figure 2-2, the LIBRARY command adds the contents of the files APPLIC.SYM and DECLARE.FOR to the library and names the library modules APPLIC and DECLARE.

Alternatively, you can name a module in a library with the /MODULE qualifier. For example:


$ LIBRARY/TEXT/INSERT FORFILES DECLARE.FOR /MODULE=EXTERNAL_DECLARATIONS

The preceding command inserts the contents of the file DECLARE.FOR into the library FORFILES under the name EXTERNAL_DECLARATIONS. This library module can be included in a Compaq Fortran source file during compilation with the following statement:


 INCLUDE 'FORFILES(EXTERNAL_DECLARATIONS)' 

For More Information:

2.5 Compiler Limits and Messages

The following sections discuss the compiler limits and error messages.

2.5.1 Compiler Limits

Table 2-4 lists the limits to the size and complexity of a single Compaq Fortran program unit and to individual statements contained in it.

The amount of data storage, the size of arrays, and the total size of executable programs are limited only by the amount of process virtual address space available, as determined by process quotas and system parameters.

Table 2-4 Compiler Limits
Language Element Limit
Actual number of arguments per CALL
or function reference
No limit
Arguments in a function reference
in a specification expression
No limit
Array dimensions 7
Array elements per dimension 9,223,372,036,854,775,807 or process limit
Constants; character and Hollerith 2000 characters
Constants; characters read in list-directed I/O 2048 characters
Continuation lines 511
DO and block IF statement nesting (combined) 128
DO loop index variable 9,223,372,036,854,775,807 or process limit
Format group nesting 8
Fortran source line length 132 characters
INCLUDE file nesting 20 levels
Labels in computed or assigned GOTO list 500
Lexical tokens per statement 3000
Parentheses nesting in expressions 40
Structure nesting 20
Symbolic-name length 63 characters

For More Information:

On relevant process quotas and system parameters, see Section 1.1.

2.5.2 Compiler Diagnostic Messages and Error Conditions

The Compaq Fortran compiler identifies syntax errors and violations of language rules in the source program.

If the compiler locates any errors, it writes messages to your default output device; so, if you enter the FORTRAN command interactively, the messages are displayed on your terminal. If the FORTRAN command is executed in a batch job, the messages appear in the log file for the batch job.

A sample message from the compiler as it would appear on a terminal screen follows:


   40    FORMAT (I3,) 
   ................^ 
   %F90-W-ERROR, An extra comma appears in the format list. 
   at line number 13 in file DISK$:[USER]SAMP_MESS.FOR;4 

This sample message consists of the following lines:

The message line has the following format:

%F90-s-ident, message-text

The facility, F90, follows the percent sign (%). The severity of the message (I for informational, W for warning, E for error, or F for fatal) replaces s. A mnemonic for that message replaces ident. The explanatory text of the message replaces message-text.

Diagnostic messages usually provide enough information for you to determine the cause of an error and correct it. If you compile using the /OPTIMIZE qualifier (the default) and have difficulty determining the cause of an error (possibly because of the optimizations), consider compiling using a lower optimization level or /NOOPTIMIZE.

If the compiler creates a listing file, it also writes the messages to the listing. The pointer (...1) and messages follow the statement that caused the error.

2.6 Compiler Output Listing Format

A compiler output listing produced by a FORTRAN command with the /LIST qualifier consists of the following sections:

Section 2.6.1 through Section 2.6.5 describe the compiler listing sections in detail.

For More Information:

2.6.1 Source Code Section

The source code section of a compiler output listing displays the source program as it appears in the input file, with the addition of sequential line numbers generated by the compiler. Example 2-1 shows a sample of a source code section of a free-form compiler output listing.

Example 2-1 Sample Listing of Source Code

 
RELAX2      Source Listing  19-DEC-2000 16:12:46  Compaq Fortran V7.x-xxxx        Page 1 
                            12-DEC-2000 10:41:04  F90$DISK:[TUCKER]LIST_EX.F90;3 
 
       1    SUBROUTINE RELAX2(EPS) 
       2      INTEGER, PARAMETER :: M=40 
       3      INTEGER, PARAMETER :: N=60 
       4      
       5      COMMON X (M,N) 
       6      
       7      LOGICAL DONE 
       8  10  DONE = .TRUE. 
       9      
      10      DO J=1,N-1 
      11        DO I=1,M-1 
      12          XNEW = (X(I-1,J)+X(I+1,J)+X(I,J-1)+X(I,J+1))/4 
      13          IF (ABS(XNEW-X(I,J)) > EPS) DONE = .FALSE. 
      14          X(I,J) = XNEW 
      15        END DO 
      16      END DO 
      17      
      18      IF (.NOT. DONE) GO TO 10 
      19      RETURN 
      20      END SUBROUTINE 

Compiler-generated line numbers appear in the left margin and are used with the %LINE prefix in debugger commands. These compiler-generated line numbers are displayed by compiler-generated messages and certain run-time error messages. (For more information on messages, see Appendix B.)

2.6.2 Machine Code Section

The machine code section of a compiler output listing provides a symbolic representation of the compiler-generated object code. The representation of the generated code and data is similar to that of a MACRO assembly listing.

The machine code section is optional. To receive a listing file with a machine code section, you must specify the following:


$ FORTRAN/LIST/MACHINE_CODE

Example 2-2 shows a sample of part of a machine code section of a compiler output listing.

Example 2-2 Sample Listing of Machine Code (Partial Listing)

 
RELAX2       Machine Code Listing      19-DEC-2000 16:12:46  Compaq Fortran V7.x-xxxx          Page 3 
                                       12-DEC-2000 10:41:04  F90$DISK:[TUCKER]LIST_EX.F90;3 
             .PSECT $CODE$, OCTA, PIC, CON, REL, LCL, SHR,- 
                  EXE, NORD, NOWRT 
 
      0000 RELAX2:: 
23DEFFC0     0000  LDA SP, -64(SP) 
80100000     0004  LDF F0, (R16)             ; 000013 
A41B0020     0008  LDQ R0, 32(R27)           ; 000012 
B77E0000     000C  STQ R27, (SP)             ; 000001 
B75E0008     0010  STQ R26, 8(SP) 
B7BE0010     0014  STQ FP, 16(SP) 
9C5E0018     0018  STT F2, 24(SP) 
9C7E0020     001C  STT F3, 32(SP) 
9C9E0028     0020  STT F4, 40(SP) 
9CBE0030     0024  STT F5, 48(SP) 
9CDE0038     0028  STT F6, 56(SP) 
47FE041D     002C  MOV SP, FP 
803B0028     0030  LDF F1, 40(R27)            ; 000012 
2FFE0000     0034  UNOP 
2FFE0000     0038  UNOP 
2FFE0000     003C  UNOP 
      0040 .10:                               ; 000008 
2FFE0000     0040  UNOP 
2FFE0000     0044  UNOP 
2FFE0000     0048  UNOP 
2FFE0000     004C  UNOP 
203FFFFF     0050  MOV -1, DONE             ; -1, R1 
47E77411     0054  MOV 59, var$0002         ; 59, R17        ; 000010 
47F41412     0058  MOV 160, R18             ; 000014 
2FFE0000     005C  UNOP 
      0060 lab$0004:                        ; 000010 
2FFE0000     0060  UNOP 
2FFE0000     0064  UNOP 
2FFE0000     0068  UNOP 
2FFE0000     006C  UNOP 
40120413     0070  ADDQ R0, R18, R19 
47E4F414     0074  MOV 39, var$0003    ; 39, R20        ; 000011 
2273FF5C     0078  LDA R19, -164(R19)                    ; 000012 
2FFE0000     007C  UNOP 
      0080 lab$0008:                                     ; 000011 
2FFE0000     0080  UNOP 
2FFE0000     0084  UNOP 
2FFE0000     0088  UNOP 
2FFE0000     008C  UNOP 
81530008     0090  LDF F10, 8(R19) 
8193FF64     0094  LDF F12, -156(R19) 
47FF0418     0098  CLR R24                    ; 000013 
81730000     009C  LDF F11, (R19)             ; 000012 
81B300A4     00A0  LDF F13, 164(R19) 
81D3000C     00A4  LDF F14, 12(R19) 
8213FF68     00A8  LDF F16, -152(R19) 
823300A8     00AC  LDF F17, 168(R19) 
82730010     00B0  LDF F19, 16(R19) 
82B3FF6C     00B4  LDF F21, -148(R19) 
82D300AC     00B8  LDF F22, 172(R19) 
82F30014     00BC  LDF F23, 20(R19) 
8333FF70     00C0  LDF F25, -144(R19) 
835300B0     00C4  LDF F26, 176(R19) 
83730018     00C8  LDF F27, 24(R19) 
. 
. 
. 
Routine Size: 1020 bytes,    Routine Base: $CODE$ + 0000 
 
 
    .PSECT $LINK$, OCTA, NOPIC, CON, REL, LCL,- 
     NOSHR, NOEXE, RD, NOWRT 
 
      0000  ; Stack-Frame invocation descriptor 
    Entry point:        RELAX2 
    Entry Length:          48 
    Registers used:        R0-R1, R16-R25, R27-FP, F0-F6, F10-F30 
    Registers saved:       FP, F2-F6 
    Fixed Stack Size:      64 
 
00000000     0020  .ADDRESS $BLANK 
00003F80     0028  .LONG X^3F80 ; .F_FLOATING 0.2500000 
 

The following list provides a detailed explanation of how generated code and data are represented in machine code listings.

2.6.3 Annotations Section

The annotations section of the compiler output listing describes special instructions used for optimizations such as prefetching, inlining, and loop unrolling. It is controlled by the /ANNOTATIONS qualifier. Refer to Section 2.3.5 for complete information.

Example 2-3 shows the list of annotations that is produced from the following source code:


1 2 3 4 5 6 7            287 work1=sqrt((xlatt*real(mindex,LONGreal)) 
                             **2+(ylatt*real(nindex,LONGreal))**2+(q-p)**2) 
8 9 10 11 12             288 work2=q-p 

Example 2-3 Sample Listing of Annotations (Partial Listing)

1. Software pipelining across 4 iterations; unrolling loop 2 times; 
   steady state estimated 180 cycles; 0 prefetch iterations 
2. Unrolling loop 6 times 
3. Prefetching MINDEX, 128 bytes ahead 
4. Prefetching NINDEX, 128 bytes ahead 
5. Prefetching Q, 128 bytes ahead 
6. Write-hinting WORK1, distance 128 
7. Prefetching P, 128 bytes ahead 
8. Software pipelining across 2 iterations; unrolling loop 2 times; 
   steady state estimated 17 cycles; 0 prefetch iterations 
9. Prefetching P, 192 bytes ahead 
10. Write-hinting WORK2, distance 128 
11. Unrolling loop 7 times 
12. Prefetching Q, 192 bytes ahead 

2.6.4 Storage Map Section

The storage map section of the compiler output listing is printed after each program unit, or library module. It is not generated when a fatal compilation error is encountered.

The storage map section summarizes information in the following categories:

A heading for an information category is printed in the listing only when entries are generated for that category.

Example 2-4 shows an example of a storage map section.

Example 2-4 Sample Storage Map Section

 
RELAX2   Source Listing                  19-DEC-2000 16:12:46  Compaq Fortran V7.x-xxxx          Page 1 
                                         12-DEC-2000 10:41:04  F90$DISK:[TUCKER]LIST_EX.F90;3 
PROGRAM SECTIONS 
 
    Name     Bytes   Attributes 
 
  1 $CODE$                                1020   PIC CON REL LCL   SHR   EXE NORD NOWRT OCTA 
  2 $LINK$                                  44 NOPIC CON REL LCL NOSHR NOEXE   RD NOWRT OCTA 
  3 $BLANK                                9600 NOPIC OVR REL GBL NOSHR NOEXE   RD   WRT OCTA 
 
    Total Space Allocated                10664 
 
 
ENTRY POINTS 
 
 Address      Name  
                    
  1-00000000  RELAX2 
 
 
VARIABLES 
 
 Address  Type  Name  Address  Type Name Address Type  Name  Address Type  Name  Address      Type  Name 
                                                                                                                            
      **  L*4   DONE       **  R*4  EPS       ** I*4   I          ** I*4   J          **      R*4   XNEW 
 
 
ARRAYS 
 
 Address      Type  Name        Bytes  Dimensions 
 
  3-00000000  R*4   X            9600  (40, 60) 
 
 
LABELS 
 
 Address      Label 
                   
  1-00000040  10   
 
 

As shown in Example 2-4, a section size is specified as a number of bytes, expressed in decimal. A data address is specified as an offset from the start of a program section, expressed in hexadecimal.

2.6.5 Compilation Summary Section

The final entries on the compiler output listing are the compiler qualifiers and compiler statistics.

The body of the compilation summary contains information about OPTIONS statement qualifiers (if any), FORTRAN command line qualifiers, and compilation statistics.

"Compiler Statistics" shows the machine resources used by the compiler.

Example 2-5 shows a sample compilation summary.

Example 2-5 Sample Compilation Summary

COMMAND QUALIFIERS 
 
  /ALIGNMENT=(COMMONS=(NONATURAL,PACKED,NOSTANDARD,NOMULTILANGUAGE),RECORDS=NATURAL,NOSEQUENCE) 
  /ANNOTATIONS=(CODE,DETAIL,FEEDBACK,INLINING,LOOP_TRANSFORMS,LOOP_UNROLLING, 
  PREFETCHING,SHRINKWRAPPING,SOFTWARE_PIPELINING,TAIL_CALLS) 
  /ARCHITECTURE=GENERIC 
  /ASSUME=(ACCURACY_SENSITIVE,ALTPARAM,NOBUFFERED_IO,NOBYTERECL, 
  NODUMMY_ALIASES, NOFP_CONSTANT, NOINT_CONSTANT, NOMINUS0, 
           PROTECT_CONSTANTS,NOUNDERSCORE,NO2UNDERSCORES,NOSOURCE_INCLUDE) 
  /NOAUTOMATIC 
  /NOBY_REF_CALL 
  /CCDEFAULT=DEFAULT 
  /CHECK=(NOARG_TEMP_CREATED,NOBOUNDS,FORMAT,NOFP_EXCEPTIONS, 
  OUTPUT_CONVERSION, NOOVERFLOW, POWER, NOUNDERFLOW) 
  /CONVERT=NATIVE 
  /DEBUG=(NOSYMBOLS,TRACEBACK) 
  /NODEFINE 
  /DOUBLE_SIZE=64 
  /NOD_LINES 
  /ERROR_LIMIT=30 
  /NOEXTEND_SOURCE 
  /F77 
  /NOFAST 
  /FLOAT=G_FLOAT 
  /GRANULARITY=QUADWORD 
  /IEEE_MODE=FAST 
  /INTEGER_SIZE=32 
  /MACHINE_CODE 
  /MATH_LIBRARY=ACCURATE 
  /NOMODULE 
  /NAMES=UPPERCASE 
  /OPTIMIZE=(INLINE=SPEED,LEVEL=4,NOLOOPS,PIPELINE,TUNE=GENERIC,UNROLL=0) 
  /NOPAD_SOURCE 
  /REAL_SIZE=32 
  /NORECURSIVE 
  /REENTRANCY=NONE 
  /ROUNDING_MODE=NEAREST 
  /NOSEPARATE_COMPILATION 
  /SEVERITY=(WARNING=WARNING) 
  /SHOW=(NOINCLUDE,MAP) 
  /SOURCE_FORM=FREE 
  /STANDARD=NONE 
  /NOSYNCHRONOUS_EXCEPTIONS 
  /NOSYNTAX_ONLY 
  /NOTIE 
  /VMS 
  /WARNINGS=(ALIGNMENT,NOARGUMENT_CHECKING,NODECLARATIONS,GENERAL, 
  GRANULARITY,NOIGNORE_LOC,NOHPF,NOTRUNCATED_SOURCE,UNCALLED,UNINITIALIZED,NOUNUSED,USAGE) 
 
  /NOANALYSIS_DATA 
  /NODIAGNOSTICS 
  /INCLUDE=FORT$INCLUDE: 
  /LIST=F90$DISK:[ETZEL]LIST_EX.LIS;9 
  /OBJECT=F90$DISK:[ETZEL]LIST_EX.OBJ;6 
  /NOLIBRARY 
 
 
COMPILER: Compaq Fortran V7.x-xxxx 
 
COMPILATION STATISTICS 
 
 CPU time:          n.nn seconds 
 Elapsed time:      n.nn seconds 
 Pagefaults:         nnn 
 I/O Count:           nn 


Previous Next Contents Index