FORTRAN
*Conan The Librarian (sorry for the slow response - running on an old VAX)
|
VMS Help FORTRAN *Conan The Librarian (sorry for the slow response - running on an old VAX) |
|
Invokes the Compaq Fortran 77 for OpenVMS VAX Systems compiler. This
command is described in detail in your user manual.
Format of the FORTRAN command line:
FORTRAN[/qualifiers] file-spec-list[/qualifiers]
Most command qualifiers that can accept options can also accept
either ALL (which includes all required and optional components) or
NONE (which includes none of the optional components).
If you specify more than one option, separate them by commas and
enclose the list in parentheses.
Context-sensitive online help on language syntax and intrinsic
routines is also available from within the DEC Language-Sensitive
Editor (an optional product).
If you are using OpenVMS VAX Version 6.0 or later, help on Fortran
compiler and run-time messages is available using the HELP/MESSAGE
command. See the Compaq Fortran 77 Release Notes for further
information.
| 1 - Parameters |
file-spec-list Specifies the source files containing the program units to be compiled. If you do not specify a file type, the compiler uses the default file type of FOR, unless /LIBRARY is specified in which case the default file type is TLB. You can specify more than one input file. If source file specifications are separated by commas (,), the programs are compiled separately and an object module is produced for each file. If source file specifications are separated by plus signs (+), the files are concatenated and compiled as a single input file, producing one object file and, if /LIST is specified, one listing file. For complete information on these command line parameters, see your user manual.
| 2 - Qualifiers |
Indicate either special actions to be performed by the compiler or special properties of input or output files. Compiler qualifiers can apply to either the FORTRAN command or the specification of the file being compiled. When a qualifier follows the FORTRAN command, it applies to all the files listed. When a qualifier follows the file specification, it applies only to the file immediately preceding it. You can override some qualifiers specified on the command line by using the OPTIONS statement. For more information on the OPTIONS statement, see STATEMENTS OPTION in this Help file.
3 - /ALIGNMENT
/[NO]ALIGNMENT=p D=/ALIGN=(COMM=(PACK,NOMULTI),RECO=PACK)
Controls whether the Compaq Fortran 77 compiler naturally aligns fields
in records or data items in common blocks, or whether the compiler
packs those fields and data items together on arbitrary byte
boundaries.
For performance reasons, Compaq Fortran 77 always aligns local data items
on natural boundaries. However, EQUIVALENCE, COMMON, RECORD, and
STRUCTURE data declaration statements can force misaligned data.
Use the /ALIGNMENT qualifier to control the alignment of fields
associated with COMMON and RECORD statements.
The /ALIGNMENT qualifier is especially useful for applications which
are to be compiled on both VAX and Alpha systems, as performance on
Alpha systems greatly benefits from properly aligned data. Note that
Compaq Fortran 77 on Alpha systems defaults to /ALIGN=RECORDS=NATURAL,
whereas the VAX default is /ALIGN=RECORDS=PACKED.
NOTE
Misaligned data can increase the time it takes to
execute a program, depending on the number of misaligned
fields encountered. Specifying /ALIGNMENT=ALL (same
as /ALIGNMENT=NATURAL minimizes misaligned data.
Vector code requires aligned data. For more information
on alignment and data sizes, see your user manual.
To obtain compiler messages when misaligned data is encountered,
use the /WARNING=ALIGNMENT qualifier.
Parameter "p" is a specifier with one of the following forms:
[class =] rule
(class = rule,...)
ALL
NONE
class
Is one of the following keywords:
COMMONS (for common blocks)
RECORDS (for records)
STRUCTURES (in FORTRAN, a synonym for RECORDS)
rule
Is one of the following keywords:
PACKED
Packs fields in records or data items in common blocks on
arbitrary byte boundaries.
NATURAL
Naturally aligns fields in records and data items in common
blocks on up to 64-bit boundaries (inconsistent with the
FORTRAN-77 standard).
If you specify NATURAL, the compiler will naturally align all
data in a common block, including INTEGER*8, REAL*8, and all
COMPLEX data.
STANDARD
Naturally aligns data items in common blocks on up to 32-bit
boundaries (consistent with the FORTRAN-77 standard).
The compiler will not naturally align REAL*8, and
COMPLEX*16 data declarations. Such data declarations should be
planned so they fall on natural boundaries. Specifying
/ALIGNMENT=COMMONS=STANDARD alone means that the default for
record structures is used.
Note that this keyword only applies to common blocks; therefore,
you can specify /ALIGNMENT=COMMONS=STANDARD, but you cannot
specify /ALIGNMENT=STANDARD.
[NO]MULTILANGUAGE
Controls whether the compiler pads the size of COMMON Program
sections (psects) to a multiple of the psect alignment (as specified
by a CDEC$ PSECT ALIGN= directive or the default of quadword
alignment.)
If /ALIGNMENT=COMMON=MULTILANGUAGE is specified, the compiler
rounds up the size of the COMMON psect to a multiple of the
psect alignment, with a maximum of octaword (16 byte) alignment.
The default is /ALIGNMENT=COMMON=NOMULTILANGUAGE which does not
round up the size of the COMMON psect.
This keyword is provided for compatibility with Compaq Fortran 77 for
OpenVMS Alpha Systems; it is generally not useful on VAX systems.
Note that this keyword only applies to common blocks; therefore,
you can specify /ALIGNMENT=COMMONS=[NO]MULTILANGUAGE, but you
cannot specify /ALIGNMENT=[NO]MULTILANGUAGE.
ALL
Is equivalent to /ALIGNMENT, /ALIGNMENT=NATURAL, and
/ALIGNMENT=(COMMONS=(NATURAL,NOMULTILANGUAGE),RECORDS=NATURAL).
NONE
Is equivalent to /NOALIGNMENT, /ALIGNMENT=PACKED, and
/ALIGNMENT=(COMMONS=(PACKED,NOMULTILANGUAGE),RECORDS=PACKED).
If you do not specify /ALIGNMENT, the default is
/ALIGNMENT=(COMMONS=(PACKED,NOMULTILANGUAGE),RECORDS=PACKED).
Note that this is different from the Compaq Fortran 77 for Alpha Systems
default which is RECORDS=NATURAL.
If you specify /ALIGNMENT=class=rule, the rule only applies to that
class, the other class gets aligned according to the default; for
example:
1. /ALIGNMENT=COMMONS=STANDARD
In this case, RECORDS=PACKED by default.
2. /ALIGNMENT=RECORDS=NATURAL
In this case, COMMONS=PACKED by default.
To request aligned data in a record structure, specify
/ALIGNMENT=RECORDS=NATURAL, or consider placing source data
declarations for the record so that the data is naturally aligned
without the need for padding.
To request aligned data in common blocks, specify
/ALIGNMENT=COMMONS=STANDARD (for data items up to 32 bits in
length) or /ALIGNMENT=COMMONS=NATURAL (for data items up to 64 bits
in length), or place source data declarations within the common
block carefully so that each data field is naturally aligned.
The /ALIGNMENT and /WARN=ALIGNMENT qualifiers can be used together
in the same command line.
You can override the alignment specified on the command line by
using a CDEC$ OPTIONS directive, as described in your language
reference manual.
4 - /ANALYSIS_DATA
/[NO]ANALYSIS_DATA[=file-spec] D=/NOANALYSIS_DATA Directs the compiler to produce an analysis data file that contains cross-reference and static-analysis information about the source code being compiled. The default file name is the name of the primary source file; the default file type is ANA (that is, filename.ANA). Analysis data files are reserved for use with Compaq products such as, but not limited to, the DEC Source Code Analyzer (SCA). 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. If you request the /DESIGN=COMMENTS qualifier along with the /ANALYSIS_DATA qualifier, the compiler places additional information in the SCA analysis data file. The /DESIGN=COMMENTS qualifier causes the compiler to scan for program design information in comment text and include this information in the SCA analysis data file. Also, the /DESIGN=PLACEHOLDERS qualifier causes the compiler to put information about placeholders used into the SCA file. You can then use SCA and LSE commands to retrieve the design information from the file.
5 - /ASSUME
/ASSUME=(option[,...]) D=/ASSUME=(ACCU,NOBYTERECL,NODUMM) Specifies what the compiler can assume about program behavior without affecting correct results when it optimizes code.
5.1 - ACCURACY_SENSITIVE
Controls whether code transformations that affect the results of floating-point operations are allowed. These changes can affect the correctness of the program's results. If you specify NOACCURACY_SENSITIVE, the compiler is free to reorder floating-point operations, based on algebraic identities (inverses, associativity, and distribution). This allows the compiler to generate optimized forms of sum reductions (such as dot products) and to move divide operations outside loops, improving performance. The default, ACCURACY_SENSITIVE, directs the compiler to use only naive scalar rules for calculations. This setting can prevent some optimizations.
5.2 - BYTERECL
Controls the unit value for the RECL= keyword in an OPEN or INQUIRE statement for unformatted files. If BYTERECL is specified, the RECL value is in units of bytes; if NOBYTERECL is specified, the RECL value is in units of four-byte longwords. NOBYTERECL is the default and is compatible with the default used by Compaq's Fortran products. NOBYTERECL may be used to provide compatibility with non-Compaq platforms. To run an application which uses /ASSUME=BYTERECL, OpenVMS VAX V7.0 or installation of a compatible Run-Time Library is required. For more information, see the Compaq Fortran 77 Release Notes.
5.3 - DUMMY_ALIASES
Controls whether dummy (formal) arguments that share memory locations with other dummy arguments or COMMON block variables affect program results. This option is provided because many important opportunities for optimizing are lost when the compiler is forced to assume that this type of memory sharing occurs in a source program. If DUMMY_ALIASES is specified, program semantics require frequent recomputations on expressions involving dummy arguments or COMMON block variables. It assures correct results but inhibits some vectorization and some scalar optimizations, thus slowing performance. With the default, NODUMMY_ALIASES, program semantics allow optimizations on expressions involving dummy arguments and COMMON block variables. It results in higher performance but can cause programs to fail if they depend on such aliases. It should only be used for source programs that strictly obey FORTRAN-77 rules for overlapping memory references in dummy arguments. If you compile a program containing dummy aliasing with NODUMMY_ALIASES in effect, the run-time behavior of the program will be unpredictable. The run-time behavior 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.
5.4 - ALL
Same interpretation as /ASSUME=(ACCURACY_SENSITIVE,BYTERECL, DUMMY_ALIASES).
5.5 - NONE
Same interpretation as /ASSUME=(NOACCURACY_SENSITIVE,NOBYTERECL,NODUMMY_ALIASES).
6 - /BLAS
/[NO]BLAS=(option[,...]) D=/BLAS=(INLINE,MAPPED)
Controls whether Compaq Fortran 77 recognizes and inlines or maps Basic
Linear Algebraic Subroutines (BLAS), Level 1 (Basic or Extended
Set).
The default is /BLAS=(INLINE,MAPPED), equivalent to /BLAS=ALL.
This qualifier can also be specified on the OPTIONS statement.
For more information on these routines, see your language reference
manual or Intrinsic_Functions in this Help file.
The BLAS Level 1 routines are as follows:
+---------------------+---------------------+
| Basic Set | Extended Set |
+---------------------+---------------------+
| IxAMAX xNRM2 | IxAMIN xNORM2 |
| xASUM xROT | IxMAX xNRSQ |
| xAXPY xROTG | IxMIN xSET |
| xCOPY xSCAL | xAMAX xSUM |
| xDOTx xSWAP | xAMIN xVCAL |
| | xMAX xZAXPY |
| | xMIN |
+---------------------+---------------------+
Note that the Compaq Extended Math Library product may be needed
to resolve references to BLAS Extended Set routines that are not
expanded inline by the compiler.
NOTE
You should not overlap output arrays with input
scalars passed to BLAS routines. This can cause
incorrect results.
6.1 - INLINE
Controls whether inline code can be generated for references to the BLAS Level 1 routines, as long as Compaq Fortran 77 can determine that it is safe. If INLINE is specified, but Compaq Fortran 77 cannot generate inline code, it maps the call to the appropriate VMS Math Library or Compaq Extended Math Library routine. If NOINLINE is specified, no inline code is generated; references can only be mapped to the OpenVMS Math Library (unless NOMAPPED is in effect).
6.2 - MAPPED
Controls whether the Basic BLAS routines can be mapped to the appropriate OpenVMS Math Library or Compaq Extended Math Library routine, if the reference is not inlined or NOINLINE is in effect. If both NOINLINE and NOMAPPED are specified, Compaq Fortran 77 does not recognize BLAS routines as intrinsics. If INLINE and NOMAPPED are specified, references that are not expanded inline cause the unmapped external routine name to be called. For the Extended BLAS routines, the unmapped external routine name is always used if the reference is not expanded inline.
6.3 - ALL
Same interpretation as (INLINE,MAPPED). This is the default.
6.4 - NONE
Same interpretation as (NOINLINE,NOMAPPED).
7 - /CHECK
/[NO]CHECK[=(option[,...])] D=/CHECK=(NOALI,NOASS,NOBOU,OVERFL,NOUND) Controls whether the compiler produces extra code to check for certain error conditions at run time. The default is /CHECK=OVERFLOW. This qualifier can also be specified on the OPTIONS statement. The qualifiers /CHECK and /CHECK=ALL are equivalent, as are /NOCHECK and /CHECK=NONE.
7.1 - ALIGNMENT
Enables or disables recovery for exceptions caused by access of unaligned data by vector instructions. If /CHECK=ALIGNMENT is specified, the compiler establishes an exception handler for the program; this handler prevents vector alignment exceptions from terminating the program and allows continued execution at the cost of decreased performance. At the end of program execution, a message is displayed giving the total number of vector alignment exceptions handled.
7.2 - ASSERTIONS
Enables or disables assertion checking. Assertions give the
compiler information that can resolve ambiguous data dependences.
If /CHECK=ASSERTIONS is specified, the compiler will generate the
appropriate run-time code to evaluate the asserted expression. If
the assertion tests false at run time, the program is stopped and
an error message is issued.
If /CHECK=NOASSERTIONS is specified, the compiler is free to use
the information in the assertions in its optimizations and
transformations, but no code is generated to test the validity of
the assertions at run time. Assertions can be coded as statements
or general compiler directives:
CDEC$ ASSERT (e)
ASSERT (e)
Where e is a logical expression.
7.3 - BOUNDS
Enables or disables bounds checking. If /CHECK=BOUNDS is specified, each dimension of an array reference or substring subscript reference is checked to determine whether it is within the range of the dimension specified by the array or character variable declaration. /CHECK=NOBOUNDS specifies no checking and presumes that no subscripts exceed their declared bounds. /CHECK=BOUNDS is not supported when /VECTOR or /PARALLEL=AUTOMATIC is in effect.
7.4 - OVERFLOW
Enables or disables integer overflow traps. If /CHECK=OVERFLOW is specified, fixed-point calculations involving BYTE, INTEGER*2, and INTEGER*4 data types are checked for arithmetic overflow. 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 /CHECK=NOOVERFLOW is specified.
7.5 - UNDERFLOW
Enables or disables floating underflow exceptions. If /CHECK=UNDERFLOW is specified, error messages are issued for the first two floating underflows. Regardless of the setting of the UNDERFLOW qualifier, zero is stored as the result that underflowed and the program continues.
7.6 - ALL
Same interpretation as /CHECK=(ALIGNMENT, ASSERTIONS, BOUNDS, OVERFLOW, UNDERFLOW). (/CHECK=ALL is equivalent to /CHECK.)
7.7 - NONE
Same interpretation as /CHECK=(NOALIGNMENT, NOASSERTIONS, NOBOUNDS, NOOVERFLOW, NOUNDERFLOW). (/CHECK=NONE is equivalent to /NOCHECK.)
8 - /CONTINUATIONS
/CONTINUATIONS=n D=19 (Obsolete, see below) Specifies the number of continuation lines allowed in a source program statement, where n is a decimal integer in the range 19 through 99. If the /DML qualifier is not also specified, /CONTINUATIONS is obsolete and is ignored. The compiler will accept statements with at least 99 continuation lines by default. If /STANDARD=SYNTAX is also in effect, a diagnostic will be issued if more than 19 continuation lines are seen. If the /DML qualifier is specified, indicating that the Fortran Data Manipulation Language (FDML) preprocessor, a component of the Oracle DBMS product, is to be used to process the source, /CONTINUATIONS must be specified if a source program contains statements with more than 19 continuation lines. This qualifier is still used by FDML.
9 - /CONVERT
/[NO]CONVERT=option D=/CONVERT=NATIVE Specifies a nonnative numeric format for unformatted data. By default, an unformatted file containing numeric data is assumed to be in the little endian floating-point or integer format used for memory representation (/CONVERT=NATIVE or /NOCONVERT). There are other ways to specify numeric format for unformatted files: you can specify a VMS logical name, OPEN (CONVERT=) or OPTIONS/CONVERT. The order of precedence is VMS logical name, OPEN (CONVERT=), OPTIONS/CONVERT, and then compiler option /CONVERT. The /CONVERT compiler option and OPTIONS/CONVERT affect all unit numbers used by the program, while logical names and OPEN (CONVERT=) affect specific unit numbers. The /CONVERT compiler option specifies a default data-conversion type for all logical units opened in the program unit, either explicitly by an OPEN statement or implicitly by a READ, WRITE or other I/O statement (with the exception of DEFINE FILE). You can override the default data-conversion type by specifying the CONVERT= keyword in the OPEN statement or by defining a logical name of the form FOR$CONVERTnnn, where "nnn" is the logical unit number (including leading zeros if necessary). For more information on using unformatted data files, using VMS logical names to specify CONVERT options, and information about the ranges of the various data types, see your user manual.
9.1 - BIG_ENDIAN
Specifies that numeric data in unformatted files is in big endian integer data of the appropriate size (INTEGER*1, INTEGER*2, or INTEGER*4) and IEEE floating-point data of the appropriate size and type (REAL*4, REAL*8, COMPLEX*8, or COMPLEX*16). INTEGER*1 data is the same for little endian and big endian.
9.2 - CRAY
Specifies that numeric data in unformatted files is in big endian integer data of the appropriate size (INTEGER*1, INTEGER*2, or INTEGER*4) and CRAY floating-point data of size REAL*8 or COMPLEX*16. REAL*4, REAL*16, and COMPLEX*8 data is not converted.
9.3 - FDX
Specifies that numeric data in unformatted files is in little endian integer data of the appropriate size (INTEGER*1, INTEGER*2, or INTEGER*4), VAX F_floating for REAL*4 and COMPLEX*8, VAX D_floating for REAL*8 and COMPLEX*16, and little-endian IEEE X_floating for REAL*16.
9.4 - FGX
Specifies that numeric data in unformatted files is in little endian integer data of the appropriate size (INTEGER*1, INTEGER*2, or INTEGER*4), VAX F_floating for REAL*4 and COMPLEX*8, VAX G_floating for REAL*8 and COMPLEX*16, and little-endian IEEE X_floating for REAL*16.
9.5 - IBM
Specifies that numeric data in unformatted files is in big endian integer data of the appropriate size (INTEGER*1, INTEGER*2, or INTEGER*4) and IBM System\370 floating-point data of size REAL*4 or COMPLEX*8 (IBM short 4) and size REAL*8 or COMPLEX*16 (IBM long 8). REAL*16 data is not converted.
9.6 - LITTLE_ENDIAN
Specifies that numeric data in unformatted files is in little endian integer data of the appropriate size (INTEGER*1, INTEGER*2, or INTEGER*4) and IEEE floating-point data of the appropriate size and type (REAL*4, REAL*8, REAL*16, COMPLEX*8, or COMPLEX*16). INTEGER*1 data is the same for little endian and big endian.
9.7 - NATIVE
Specifies that format for numeric data in unformatted files is determined by the floating-point format representation in memory; no conversion is performed. This is the default.
9.8 - VAXD
Specifies that numeric data in unformatted files is in little endian integer data of the appropriate size (INTEGER*1, INTEGER*2, or INTEGER*4) and Compaq VAX floating-point data of format F_floating for size REAL*4 or COMPLEX*8, and D_floating for size REAL*8 or COMPLEX*16, and H_floating for REAL*16.
9.9 - VAXG
Specifies that numeric data in unformatted files is in little endian integer data of the appropriate size (INTEGER*1, INTEGER*2, or INTEGER*4) and Compaq VAX floating-point data of format F_floating for size REAL*4 or COMPLEX*8, and G_floating for size REAL*8 or COMPLEX*16, and H_floating for REAL*16.
10 - /CROSS_REFERENCE
/[NO]CROSS_REFERENCE D=/NOCROSS_REFERENCE Controls whether the storage-map section of the listing file includes information about the use of symbolic names. The cross-reference contains the numbers of the lines in which the symbols are defined and referenced. The default is /NOCROSS_REFERENCE. The /CROSS_REFERENCE qualifier is ignored unless /LIST is specified, either explicitly or by default.
11 - /D_LINES
/[NO]D_LINES D=/NOD_LINES Controls whether the compiler reads and compiles lines that have a "D" in column 1 of the source program. If you specify /D_LINES, lines that have a "D" in column 1 are compiled. The default is /NOD_LINES, which means the compiler assumes that lines beginning with a "D" are comments and does not compile them.
12 - /DEBUG
/[NO]DEBUG[=(option[,...])] D=/DEBUG=(PARAM=USED,NOSYMBOLS,TRACEBACK) Controls whether the compiler makes local symbol table and traceback information available to the debugger and the run-time error traceback mechanism, and whether the debugger is given information about all PARAMETER constants defined in the program unit or only those that are actually used. By default, if you omit the /DEBUG qualifier, the compiler produces only an address correlation table (equivalent to /DEBUG=(PARAMETERS=USED,NOSYMBOLS,TRACEBACK)). If you specify /DEBUG without any options, the default is /DEBUG=(PARAMETERS=USED,SYMBOLS,TRACEBACK). /DEBUG=ALL is equivalent to /DEBUG=(PARAMETERS=ALL,SYMBOLS,TRACEBACK.) Compaq recommends that /NOOPTIMIZE also be used when debugging Fortran programs. Optimizations performed by the compiler can cause several different kinds of unexpected behavior when using the OpenVMS Debugger. See your performance guide for more information on this subject. The compiler will issue an informational message recommending /NOOPTIMIZE if /DEBUG is used without the /NOOPTIMIZE qualifier. To disable this message, specify /OPTIMIZE explicitly. For details on how to debug a Compaq Fortran 77 program with the OpenVMS Symbolic Debugger, see your user manual. /NODEBUG is equivalent to /DEBUG=NONE.
12.1 - PARAMETERS
Controls how PARAMETER constant definitions are communicated to the debugger, subject to the setting of SYMBOLS. PARAMETERS=USED, the default, specifies that only those PARAMETER constants that are actually used in the program unit are made known to the debugger. PARAMETERS=ALL specifies that all PARAMETER constants are made known to the debugger. If many PARAMETER constants are defined, this can greatly increase the size of the object module and executable image.
12.2 - SYMBOLS
Controls whether the debugger receives local symbol definitions for user-defined variables, arrays, (including dimension information), structures, PARAMETER constants, and labels of executable statements. Unless /DEBUG=PARAMETERS=ALL is in effect, only those PARAMETER constants actually used in the program unit are made known to the debugger.
12.3 - TRACEBACK
Controls the production of 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.
12.4 - ALL
Same interpretation as (PARAMETERS=ALL,SYMBOLS,TRACEBACK).
12.5 - NONE
Same interpretation as (PARAMETERS=USED,NOSYMBOLS,NOTRACEBACK).
13 - /DESIGN
/[NO]DESIGN[=(option[,...])] D=/NODESIGN Controls whether the compiler analyzes the source code for program design information in comment text and Language Sensitive Editor (LSE) placeholders. If you omit the /DESIGN qualifier entirely, the default is /DESIGN=(NOCOMMENTS,NOPLACEHOLDERS) (equivalent to /DESIGN=NONE or /NODESIGN). However, if you specify /DESIGN without any options, the default is /DESIGN (COMMENTS,PLACEHOLDERS) (equivalent to /DESIGN=ALL). In addition, if /ANALYSIS_DATA is also specified, information about design information in comments and placeholders is added to the analysis data file.
13.1 - COMMENTS
Controls whether the compiler analyzes the text of each comment (either a full-line or end-of-line comment) for program design information. Comment text is scanned for tags that are defined in the current DEC Language Sensitive Editor environment file. Certain tags are predefined by LSE; however, you can add, change, or remove tags as desired. See the DEC Language Sensitive Editor documentation for details. If you also specify the /ANALYSIS_DATA qualifier, the SCA analysis data file includes information about tags found, text of tagged and untagged comments, and their locations in the source file. You can then use SCA and LSE commands to retrieve the design information. At compile time, the compiler reports any errors detected by comment analysis routines. If LSE and SCA are not installed or if a severe error is reported by the comment analysis routines, the compilation is aborted. Groups of full-line comments are identified by the compiler as "comment blocks", including lines that consist of whitespace followed by a "!" comment introducer. Differences in indentation of full-line comments are ignored for the purposes of grouping comments into blocks. A comment block ends when a completely blank line or a line which is not a full-line comment is detected. End-of-line comments, where non-blank text is followed by a "!" comment introducer, are treated as self-contained comment blocks. Comments from source that is included with the INCLUDE or DICTIONARY statements are also analyzed for design information. The end of an INCLUDE module or DICTIONARY definition, by itself, does not end a comment block. Comments beginning with a "D" or "d" in column 1 are not examined for program design information.
13.2 - PLACEHOLDERS
Controls whether the compiler accepts DEC Language-Sensitive Editor
placeholders (in well-defined contexts) as valid program syntax.
Compaq Fortran 77 recognizes five types of placeholders defined by LSE:
{required-placeholder}
{required-list-placeholder}...
[optional-placeholder]
[optional-list-placeholder]...
«pseudocode-placeholder»
An alternative syntax which uses 7-bit ASCII character set
delimiters for a pseudocode placeholder is also accepted by Compaq
Fortran 77:
<<pseudocode-placeholder>>
There is no list form of pseudocode placeholder.
A placeholder must be terminated before the end of the line, and
the closing delimiter must correspond to the opening delimiter.
For example, the following placeholder is invalid:
[invalid-delimiter}
Any text can appear inside a delimiter except for the closing
delimiter. There is no ability to "quote" a closing delimiter in
order to allow its inclusion as text. Nesting of delimiters is not
supported.
If you also specify the /ANALYSIS_DATA qualifier, information about
placeholders and their use is included in the SCA analysis data
file.
If placeholder analysis is performed on a compilation unit that
contains placeholders in valid contexts, the compiler does not
generate an object file. An object file is generated, however, if
no placeholders are found in the compilation unit undergoing
placeholder analysis.
If LSE placeholders are present in the source file and you do not
specify the /DESIGN=PLACEHOLDER qualifier, the compiler treats the
placeholders as invalid syntax and generates an error message.
Allowed Contexts for Placeholders:
A placeholder can be used to replace either an entire Fortran
statement or a part of a statement. As a replacement for an entire
statement, there are no restrictions on where a placeholder can
appear. Otherwise, as a replacement for a portion of a statement,
a placeholder is generally treated as an undeclared identifier
whose implicit type is INTEGER. This implicit typing is unaffected
by the IMPLICIT or IMPLICIT NONE statements, but is affected by the
/[NO]I4 command qualifier or the OPTIONS statement qualifier.
Each occurrence of a placeholder is considered as a unique instance
and is unaffected by earlier uses of a syntactically identical
placeholder. For example, in the following code sequence, each
occurrence of "[abc]" is considered to be a never-before-seen
identifier:
INTEGER [abc]
REAL [abc]
The implicit typing of placeholders as INTEGER allows them to be
used in most reasonable contexts, but if they are used in contexts
where an integer identifier would not be allowed, semantic error
messages are generated. For example, the following statement is
invalid because of the type mismatch:
CHAR__VAR = CHAR__VAR // [placeholder]
Like any other undeclared variable, placeholders are considered
scalars and cannot be used in a context that requires the variable
to be declared as an array.
Given the above restrictions, placeholders can appear in the
following contexts:
o As a variable name in a type specification, AUTOMATIC, COMMON,
DATA, DIMENSION, EQUIVALENCE, POINTER, RECORD, SAVE, STATIC, or
VOLATILE statement, and CPAR$ CONTEXT_SHARED or CPAR$ PRIVATE
directives.
o As the symbolic name in an EXTERNAL or PARAMETER statement.
o As an integer expression.
o As the target of an assignment statement.
o As the name of subroutine in a CALL statement.
o As the name of a function in a function reference.
o As an integer variable in an ASSIGN or assigned GOTO statement.
o As the control variable in a DO statement or implied DO list in
an I/O statement.
o As the lock variable in a CPAR$ LOCKON or CPAR$ LOCKOFF
directive (the placeholder is treated as LOGICAL*4 in these
contexts only).
o As an integer variable in an I/O statement other than the unit
or format specifier.
Placeholders are not allowed in the following contexts:
o As the symbolic name in a BLOCK DATA, ENTRY, FUNCTION,
INTRINSIC, PROCEDURE, or PROGRAM statement.
o As formal (dummy) argument names in an ENTRY, FUNCTION, or
PROCEDURE statement.
o As the name of a common block.
o As a structure name.
o In a NAMELIST statement, either as the group name or as one of
the variables to be included in the group.
o As the unit or format specifier in an I/O statement.
13.3 - ALL
Same interpretation as (COMMENTS,PLACEHOLDERS).
13.4 - NONE
Same interpretation as (NOCOMMENTS,NOPLACEHOLDERS).
14 - /DIAGNOSTICS
/[NO]DIAGNOSTICS[=file-spec] D=/NODIAGNOSTICS Controls whether the compiler produces a file containing compiler messages and diagnostic information. 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 layered products such as the DEC Language Sensitive Editor (LSE). See also HELP on /SHOW=DATA_DEPENDENCES, which affects the .DIA output.
15 - /DIRECTIVES
/[NO]DIRECTIVES=(option[,...]) D=/DIRECTIVES=DEPENDENCE Controls whether specified compiler directives are used at compilation.
15.1 - DEPENDENCE
Specifies whether Compaq Fortran 77 uses the CDEC$ INIT_DEP_FWD and CDEC$ NOVECTOR directives. The CDEC$ INIT_DEP_FWD directive specifies that all data dependences in the succeeding loop are uniform and do not have a backward direction. The CDEC$ NOVECTOR directive directs the compiler to avoid vectorizing an indicated DO loop.
15.2 - ALL
Same interpretation as /DIRECTIVES=DEPENDENCE.
15.3 - NONE
Same interpretation as /DIRECTIVES=NODEPENDENCE.
16 - /DML
/[NO]DML D=/NODML
Invokes the Fortran Data Manipulation Language (DML) preprocessor
before the compiler. The preprocessor preprocessor produces an
intermediate file of Compaq Fortran 77 source code in which Fortran DML
commands are expanded into Compaq Fortran 77 statements. The compiler
is then automatically invoked to compile this intermediate file.
The default is not to invoke the DML preprocessor.
Use the /SHOW=PREPROCESSOR qualifier with the /DML qualifier to
cause the preprocessor-generated source code to be included in the
listing file. For more information on the DML preprocessor, see
the Oracle DBMS Programming Reference Manual.
Any switches preceding the /DML qualifier in the command line are
ignored.
NOTE
Unless you specify the /DEBUG qualifier, the
intermediate file is deleted by the Fortran DML
preprocessor immediately after compilation is
complete, and the Language Sensitive Editor and the
Source Code Analyzer cannot access the source
program when you use the /DML qualifier. The
results with the /DEBUG qualifier reflect the
intermediate source.
17 - /ERROR_LIMIT
/[NO]ERROR_LIMIT[=n] D=/ERROR_LIMIT=30 Specifies the maximum number of E-level or F-level compiler errors allowed for a given compilation unit. Error counts are not accumulated across a sequence of compilation units. If you specify /ERROR_LIMIT=n, each compilation unit can have up to n - 1 errors without terminating the compilation. When the error limit is reached within a compilation unit, compilation of that unit is terminated, but compilation of following units continues. The /ERROR_LIMIT=0 option is equivalent to ERROR_LIMIT=1. 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 for a given compilation unit upon the occurrence of the 30th E-level or F-level error within that unit (equivalent to /ERROR_LIMIT=30).
18 - /EXTEND_SOURCE
/[NO]EXTEND_SOURCE D=/NOEXTEND_SOURCE Indicates whether the compiler will treat columns 7 through 72 or 7 through 132 as the statement field in Fortran source code lines. This qualifier can also be specified on the OPTIONS statement. The default is /NOEXTEND_SOURCE (which treats source columns 7 through 72 as the statement field). If the source line extends beyond the end of the statement field, the extra characters are ignored. /WARNINGS=TRUNCATED_SOURCE can be used to cause the compiler to issue a warning if source lines longer than the statement field length are encountered.
19 - /F77
/[NO]F77 D=/F77 Controls whether FORTRAN-77 interpretation rules are used for those statements that have a meaning that is incompatible with FORTRAN-66. This qualifier can also be specified with the OPTIONS statement. The default is /F77. If you specify /NOF77, the compiler selects FORTRAN-66 interpretations in cases of incompatibility. For an explanation of the incompatibilities, see your user manual.
20 - /G_FLOATING
/[NO]G_FLOATING D=/NOG_FLOATING
Controls how the compiler implements REAL*8, COMPLEX*16, DOUBLE
PRECISION, and DOUBLE COMPLEX declarations and constants.
This qualifier can also be specified on the OPTIONS statement. The
default is /NOG_FLOATING, which directs the compiler to implement
double-precision quantities using the VAX D_floating data type.
The /G_FLOATING qualifier directs the compiler to implement such
quantities using the VAX G_floating data type.
If your program requires the G_floating form of double precision
for its correct operation (that is, it uses a range larger than
10**38), you should use the /G_FLOATING qualifier in an OPTIONS
statement in your source program. The implementation of REAL*8 in
Compaq Fortran 77 is further discussed in your language reference manual.
NOTE
You should not mix the D_floating and G_floating
data types in routines that pass double-precision
quantities between themselves.
21 - /I4
/[NO]I4 D=/I4 Controls how the compiler interprets INTEGER and LOGICAL declarations that do not specify a length. This qualifier can also be specified on the OPTIONS statement. The default is /I4, which directs the compiler to interpret INTEGER and LOGICAL declarations as INTEGER*4 and LOGICAL*4. If you specify /NOI4, the compiler interprets them as INTEGER*2 and LOGICAL*2, respectively.
22 - /LIBRARY
/LIBRARY Indicates that an input file is a text library. (The INCLUDE statement in a Fortran program allows you to extract modules from text libraries.) 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. The FORT$LIBRARY logical name may also be used to specify default text libraries. See the FORTRAN Logical_Names help topic for more information. For more information on text libraries, see your user manual.
23 - /LIST
/[NO]LIST[=file-spec] D=/NOLIST
Controls whether a listing file is produced. You can request
additional listing information using the /CROSS_REFERENCE and
/MACHINE_CODE qualifiers.
In interactive mode, the compiler does not produce a listing file
unless you specify /LIST. 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.
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.
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 1 contains a Ctrl/Z character, the
source code listing contains a blank line in place of the Ctrl/Z
character.
Any other nonprinting ASCII characters encountered in Fortran
source files are replaced by a space character and a warning
message appears.
For more information on the format of listing files, see your user
manual.
24 - /MACHINE_CODE
/[NO]MACHINE_CODE D=/NOMACHINE_CODE Controls whether the listing file includes a symbolic representation of the object code generated by the compiler. Generated code and data are represented in a form similar to a VAX MACRO assembly 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 VAX MACRO assembler. The default is /NOMACHINE_CODE, which omits machine language code in the listing. The /MACHINE_CODE qualifier is ignored if /LIST is not specified, either explicitly or by default. For more information on the format of a machine code listing, see your user manual.
25 - /MATH_LIBRARY
/[NO]MATH_LIBRARY=(option[,...]) D=/MATH_LIBRARY=(ACCURATE,NOV5) Specifies the selection of math library routines used to implement mathematical intrinsic functions. The qualifier is not negatable and a value must be specified. If the ACCURATE and FAST keywords are both specified, the last keyword is used.
25.1 - ACCURATE
Directs the compiler to select the standard version of the math library routines used to implement vectorized references to the ATAN, COS, EXP, LOG, LOG10, SIN, SQRT and TAN intrinsics as well as the exponentiation operator ** for real data types. This version gives the most accurate result. For certain ranges of input values, the selected routine can execute more slowly than the alternate version specified by FAST. This keyword is not negatable.
25.2 - FAST
Directs the compiler to select the Fast Vector Math version of library routines used to implement vectorized references to the ATAN, COS, EXP, LOG, LOG10, SIN, SQRT and TAN intrinsics as well as the exponentiation operator ** for real data types. This version gives the highest execution performance. For certain ranges of input values, the selected routine may not give a result that is as accurate as the version specified by ACCURATE. Accuracy reduction will be at most 2 bits for single-precision routines, and at most 4 bits for double-precision routines. This keyword is not negatable.
25.3 - V5
Controls whether the compiler restricts its use of math library routines to those provided in OpenVMS VAX V5.4. If V5 is specified, the compiler does not use optimized versions of the math library routines for scalar references to the AMOD, ATAN, ATAN2, CABS, CCOS, CEXP, CLOG, COSH, CSIN, CSQRT, SIGN, SINH and TANH intrinsic functions nor does it vectorize references to the ATAN2, CCOS, CEXP, COSH, CSIN, CSQRT, MOD, SINH and TANH intrinsic functions. The default is NOV5 which enables the above optimizations and vectorizations, making use of new math library routines which are provided with the Compaq Fortran 77 product but which are not present in OpenVMS VAX versions V5.4 through V6.0.
26 - /OBJECT
/[NO]OBJECT[=file-spec] D=/OBJECT Controls whether the compiler produces an object file. If you omit the file specification, the object file has the name of the first source file and a file type of OBJ. Specify /NOOBJECT to suppress the generation of object code (for example, when you want to test only for compilation errors in the source program).
27 - /OPTIMIZE
/[NO]OPTIMIZE=(option[,...]) D=/OPTIMIZE=(LEVEL=3) Selects compiler optimizations to be applied to the generated code. Specifying /OPTIMIZE without any options is the same as specifying /OPTIMIZE=(LEVEL=3) and is the default. Specifying /NOOPTIMIZE is the same as /OPTIMIZE=(LEVEL=0). /NOOPTIMIZE (or LEVEL=0) cannot be specified if /VECTOR or /PARALLEL=AUTOMATIC is also specified. If /DEBUG is specified, Compaq recommends that /NOOPTIMIZE also be specified, if applicable, so that generated code is not rearranged which can make it more difficult to follow program execution in a debugging session. The compiler will issue an informational message recommending /NOOPTIMIZE if /DEBUG is used without the /NOOPTIMIZE qualifier. To disable this message, specify /OPTIMIZE explicitly. See your performance guide for information on optimizations performed by the Compaq Fortran 77 for OpenVMS VAX Systems compiler.
27.1 - LEVEL
Controls the level of optimization performed by the compiler. LEVEL=0 is the same as /NOOPTIMIZE and suppresses all optional optimizations. LEVEL=3 is the default optimization level and provides all optional optimizations except memory blocking. LEVEL=4 provides all optimizations including memory blocking, which can improve performance for non-vectorized applications that operate on large arrays. See the performance guide for more details. LEVEL=4 cannot be specified if /CHECK=BOUNDS is in effect.
28 - /PAD_SOURCE
/[NO]PAD_SOURCE D=/NOPAD_SOURCE Controls how the compiler treats program source lines which are shorter than the statement field width (72 characters, or 132 characters if /EXTEND_SOURCE is in effect.) This option has an effect on how the compiler treats character, Hollerith and RAD50 constants which are continued across two or more source lines. 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 platforms which may assume that short source lines are blank-padded. The default is /NOPAD_SOURCE, compatible with current and previous Compaq Fortran 77 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 will issue an informational diagnostic if it detects a continued constant which may be affected by blank padding. See the Release Notes for further details.
29 - /PARALLEL
/[NO]PARALLEL=(option[,...]) D=/PARALLEL=(NOAUT,NOMAN) or /NOPAR Controls whether the compiler performs special processing for parallel-processing applications. Specifying /NOPARALLEL or /PARALLEL=(NOAUTOMATIC,NOMANUAL) has the same effect as omitting the /PARALLEL qualifier. Compiler directives relating to parallel processing (CONTEXT_SHARED, DO_PARALLEL, LOCKON, LOCKOFF, PRIVATE, and SHARED) are treated as comments and no object code is generated to support execution of parallel DO loops. Specifying /PARALLEL without any options has the same effect as specifying /PARALLEL=(MANUAL,AUTOMATIC).
29.1 - AUTOMATIC
Controls whether the compiler automatically decomposes DO loops to run in parallel mode on multiprocessor systems. /PARALLEL=AUTOMATIC cannot be used with /CHECK=BOUNDS and /NOOPTIMIZE.
29.2 - MANUAL
Controls whether the compiler parses CPAR$ directives and generates parallel code for loops preceded by CPAR$ DO_PARALLEL.
29.3 - ALL
Same interpretation as /PARALLEL=(MANUAL, AUTOMATIC) (or /PARALLEL).
29.4 - NONE
Same interpretation as /PARALLEL=(NOMANUAL, NOAUTOMATIC) (or /NOPARALLEL).
30 - /RECURSIVE
/[NO]RECURSIVE D=/NORECURSIVE
Directs the compiler to generate code and allocate data so that a
subroutine or a function can be called recursively.
/RECURSIVE cannot be specified with /PARALLEL.
The /RECURSIVE qualifier has the following effects:
o Changes the default allocation class for all local variables
from STATIC to AUTOMATIC, except for variables that are
data-initialized or named in a SAVE statement.
o Causes storage for descriptors and argument lists to be
allocated on the stack rather than in static storage.
o Permits reference to a routine name from inside the routine.
The /RECURSIVE qualifier, as well as /NORECURSIVE, can be specified
on an OPTIONS statement. There, it overrides the command line
specification for the duration of the program unit in which it is
contained.
31 - /SHOW
/SHOW[=(option[,...])] D=/SHO=(NODAT,NODIC,NOINC,NOL,MAP,NOPRE,SIN) Controls listing file options. The /SHOW qualifier is ignored if /LIST is not specified, either explicitly or by default. The /SHOW=NOMAP qualifier is ignored if /CROSS_REFERENCE is specified.
31.1 - DATA_DEPENDENCES
Controls whether the listing file includes diagnostics about loops that are ineligible for dependence analysis, and loops that inhibit vectorization or autodecomposition. The DEC Language Sensitive Editor must be used to view the dependence diagnostic information. See your performance guide for additional information.
31.2 - DICTIONARY
Controls whether the listing file includes source representations of any CDD records referenced by DICTIONARY statements.
31.3 - INCLUDE
Controls whether the listing file includes source lines from files or text modules specified in INCLUDE statements. The [NO]LIST option on the INCLUDE statement overrides the /SHOW=[NO]INCLUDE qualifier on the FORTRAN command line.
31.4 - LOOPS
Controls whether the listing file includes loop structure and statement execution order chosen by dependence analysis, automatic decomposition, and vectorization. The reported loop structures can be scalar, vector, parallel section, parallel chunk, or serial. The loop summary listing is described in greater detail in your performance guide.
31.5 - MAP
Controls whether the listing file includes the symbol map. If the /CROSS_REFERENCE qualifier is specified, MAP is ignored.
31.6 - PREPROCESSOR
Controls whether the listing file includes preprocessor-generated source lines.
31.7 - SINGLE
Controls whether cross-reference listings include the symbolic names of PARAMETER constants, even if they are not referenced outside the PARAMETER statements in which they are declared. The negative form, NOSINGLE, specifies that names of parameter constants be suppressed if they are only declared and not referenced elsewhere. This is useful for cross-reference listings of small programs that specify INCLUDE declarations but use only a few of the parameter constant names that have been declared.
31.8 - ALL
Requests that all optionally listed source lines and a symbol map be included in the listing file. This is the same as specifying /SHOW without any arguments.
31.9 - NONE
Requests that no optionally listed source lines or a symbol map be included in the listing file. This is the same as specifying /NOSHOW. The default for the /SHOW qualifier is /SHOW=(NODATA_DEPEND, NODICT, NOINCLU, NOLOOP, MAP, NOPREPROCESS, SINGLE).
32 - /STANDARD
/[NO]STANDARD[=(option[,...])] D=/NOSTANDARD Controls whether the compiler produces informational diagnostics for extensions to ANSI X3.9-1978 (FORTRAN-77) that can be determined at compile-time. If you specify /STANDARD with no arguments, it is equivalent to /STANDARD=(NOMIA,SEMANTIC,NOSOURCE_FORM,SYNTAX). The /STANDARD qualifier has effect only if you specify /WARNINGS, either explicitly or by default. Note the difference between the /STANDARD and /F77 qualifiers. The /STANDARD qualifier causes diagnostics to be produced for non-standard features. The /F77 qualifier causes the FORTRAN-77 interpretation to be chosen for constructs that mean different things in FORTRAN-77 and previous versions of VAX FORTRAN and Compaq Fortran 77. /NOSTANDARD is equivalent to /STANDARD=NONE.
32.1 - MIA
Controls whether the compiler produces informational messages for extensions to the MIA standard, which is a superset of FORTRAN-77. (For more information on MIA extensions, see your user manual.) Specifying MIA checking enables SYNTAX checking to be performed.
32.2 - SEMANTIC
Controls whether the compiler produces informational messages for ANSI standard conforming statements that become nonstandard because of the way in which they are used. Data type information and statement locations are considered when determining semantic extensions. Specifying SEMANTIC checking enables SYNTAX checking to be performed.
32.3 - SOURCE_FORM
Controls whether the compiler produces informational diagnostics for statements that contain lowercase characters, use tab formatting, or are CDEC$ or CPAR$ directives.
32.4 - SYNTAX
Controls whether the compiler produces informational diagnostics for syntax extensions to the current ANSI standard. SYNTAX extensions include nonstandard statements and language constructs.
32.5 - ALL
Requests that informational messages be issued for semantic, source form, and syntax extensions to the current ANSI standard. Note that if you also want messages for MIA extensions, you must specify /STANDARD=(ALL,MIA).
32.6 - NONE
Same as specifying /NOSTANDARD.
33 - /SYNCHRONOUS_EXCEPTIONS
/[NO]SYNCHRONOUS_EXCEPTIONS D=/NOSYNCHRONOUS_EXCEPTIONS Controls whether vector arithmetic exceptions (such as floating overflow on a vector add instruction) are reported immediately after the instruction is executed that caused them and before operations continue. If the vector emulator is being used, exceptions are reported after the instruction that caused them, regardless of which qualifier was specified (/NOSYNCHRONOUS_EXCEPTIONS or /SYNCHRONOUS_EXCEPTIONS). If vector hardware is being used, the exception is reported immediately only if the /SYNCHRONOUS_EXCEPTIONS qualifier was specified. If /NOSYNCHRONOUS_EXCEPTIONS was specified, exceptions can be reported several instructions after the instruction that caused the error. If the default (/NOSYNCHRONOUS_EXCEPTIONS) is in effect, exceptions are reported at any point after completion of the operation and before execution of the next vector instruction, always in the procedure containing the error condition. This setting allows uninterrupted completion of the vector operation, but it also makes it more difficult to isolate the location of any exceptions. The default behavior does not apply to special entry points used for the Run-Time Library (RTL) routines that are implementing the Fortran intrinsic functions.
34 - /TERMINAL
/[NO]TERMINAL[=option[,...])] D=/NOTERMINAL Controls whether the compiler issues a message to the terminal or a log file at the completion of each program unit compilation.
34.1 - STATISTICS
Controls whether the compiler displays the program unit name and the number of code bytes generated when it completes processing that program unit.
34.2 - ALL
Same interpretation as /TERMINAL=STATISTICS.
34.3 - NONE
Same interpretation as /TERMINAL=NOSTATISTICS.
35 - /VECTOR
/[NO]VECTOR D=/NOVECTOR Controls whether the compiler analyzes source code for dependences and includes vector instructions in the generated code. The default setting is /NOVECTOR. /VECTOR does not support /CHECK=BOUNDS and /NOOPTIMIZE. The setting of the /VECTOR qualifier affects the default setting for the /ASSUME qualifier: o If /NOVECTOR, /ASSUME=(ACCURACY_SENSITIVE,DUMMY_ALIASES) o If /VECTOR, /ASSUME=(ACCURACY_SENSITIVE,NODUMMY_ALIASES) The setting of the /VECTOR qualifier does not affect the default for the /SYNCHRONOUS_EXCEPTIONS qualifier.
36 - /WARNINGS
/[NO]WARNINGS[=(option[,...])] D=/WARNINGS=(GEN,UNCAL,UNINI,UNREA,UNUS,USAGE) Controls whether the compiler generates certain classes of optional diagnostic messages. Specifying /WARNINGS without arguments has the same effect as specifying /WARNINGS=ALL; specifying /NOWARNINGS has the same effect as specifying /WARNINGS=NONE. The default is: /WARNINGS=(NOALIGNMENT, NOAlpha, NODECLARATIONS, GENERAL, NOINLINE, NOTRUNCATED_SOURCE, NOULTRIX, UNCALLED, UNINITIALIZED, UNREACHABLE, UNUSED, USAGE, NOVAXELN).
36.1 - ALIGNMENT
Controls whether the compiler produces 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*8 variable is not a multiple of 8. The default is /WARNINGS=NOALIGNMENT. It is recommended that you specify /WARNINGS=ALIGNMENT if data in COMMON blocks (or which appears in EQUIVALENCE declarations) is to be used in a vectorized program. Eliminating unaligned data can improve performance on VAX and is very important for applications being migrated to the Alpha architecture. Alignment warnings for specific STRUCTURE and COMMON declarations can be controlled using the /WARNINGS=ALIGNMENT qualifier on the CDEC$ OPTIONS directive.
36.2 - Alpha
Controls whether the compiler generates diagnostics for language features not supported by Compaq Fortran 77 on Alpha systems.
36.3 - DECLARATIONS
Controls whether the compiler issues diagnostic messages for any untyped data items used in the program. This option acts as an external IMPLICIT NONE declaration. See your language reference manual for more information on IMPLICIT NONE.
36.4 - GENERAL
Controls whether the compiler issues diagnostic messages for W-level (warning) and I-level (informational) conditions. To suppress I-level and W-level diagnostic messages, specify the negative form of this qualifier (/WARNINGS=NOGENERAL).
36.5 - INLINE
Controls whether the compiler prints informational diagnostic messages when it is unable to generate inline code for a reference to an intrinsic routine. This option only applies to the BLAS intrinsics for which inline expansion is supported (all except xNRM2 and xROTG), and only if /BLAS=INLINE is in effect.
36.6 - TRUNCATED_SOURCE
Controls whether the compiler issues a warning diagnostic message (EXCCHASRC) when it reads a source line with a statement field that exceeds the maximum column width. The maximum column width is either 72 or 132 characters, depending on the value of the /EXTEND_SOURCE qualifier or the OPTIONS statement qualifier in effect. This option has no effect on truncation; lines that exceed the maximum column width are always truncated.
36.7 - ULTRIX
Controls whether the compiler generates diagnostics for language features not supported by DEC Fortran on ULTRIX RISC systems.
36.8 - UNCALLED
Controls whether the compiler generates informational diagnostics for statement functions that are defined but not called.
36.9 - UNINITIALIZED
Controls whether the compiler generates diagnostics for uses of variables that the compiler believes do not have a defined value.
36.10 - UNREACHABLE
Controls whether the compiler generates diagnostics for unreachable code.
36.11 - UNUSED
Controls whether the compiler generates informational diagnostics for variables that are declared but not used.
36.12 - USAGE
Controls whether the compiler generates informational diagnostics
for questionable programming practices which, though allowed, often
are the result of programming errors.
The current set of questionable usages that the compiler detects
are:
o A branch into a DO loop or IF block from outside the loop or
block. (Note that use of the Fortran 66 "extended range of a
DO loop" feature will result in a diagnostic.)
o Passing an identifier, which had previously been used as an
intrinsic routine, as an actual argument without naming that
identifier in an INTRINSIC statement.
o Use of the DATE or IDATE intrinsics which may cause problems
after the year 2000.
o Having a COMMON block with the same name as another global
entity such as a SUBROUTINE, FUNCTION, ENTRY or EXTERNAL.
36.13 - VAXELN
Controls whether the compiler issues diagnostics for language features not supported by Compaq Fortran 77 on a VAXELN system.
36.14 - ALL
Causes the compiler to print all informational and warning messages, including warning messages for any untyped data items.
36.15 - NONE
Suppresses all informational and warning messages.
| 37 - Examples |
1. $ FORTRAN MYPROG
In this example, the default Fortran compiler is invoked to
compile the source file MYPROG.FOR, resulting in the object
file MYPROG.OBJ. No listing file is produced unless the
command is invoked from a batch job, in which case the listing
file MYPROG.LIS is also produced.
2. $ FORTRAN/DEBUG/NOOPT/LIST/CROSS_REFERENCE V6PROG
In this example, the Compaq Fortran 77 compiler is invoked to compile
the source file V6PROG.FOR, producing an object file V6PROG.OBJ
and a listing file V6PROG.LIS. The object file includes
symbolic debugging information and the listing file includes
cross-reference information. The object code is not optimized,
for aid in debugging.
3. $ FORTRAN/VECTOR/ASSUME=NOACCURACY_SENSITIVE VECPROG
In this example, the Compaq Fortran 77 compiler is invoked to compile
the source file VECPROG.FOR, producing the object file
VECPROG.OBJ. The compiled code contains VAX vector
instructions for vectorizable constructs, and the compiler has
assumed that arithmetic calculations can be reordered to
improve performance.
| 38 - Release Notes |
For Compaq Fortran 77 release notes, refer to the following file:
SYS$HELP:FORTvvp.RELEASE_NOTES.
The "vv" and "p" are the major and minor version numbers of the
product. For example, Version 6.6 would be "066".
Use the following command to get a list of all available Compaq
Fortran 77 release notes:
$ DIRECTORY SYS$HELP:FORT*.RELEASE_NOTES
Release notes are also available in PostScript and Bookreader
formats in the following files:
SYS$HELP:FORTvvp_RELEASE_NOTES.PS
SYS$HELP:FORTvvp_RELEASE_NOTES.DECW$BOOK
| 39 - Built-in Functions |
39.1 - %DESCR
%DESCR (arg) Forces an actual argument in a CALL statement or function reference to be passed by descriptor: the address of a descriptor of the argument is passed to the subprogram. By default, Fortran passes all character values by descriptor.
39.2 - %LOC
%LOC (arg) Returns the actual storage address of a data element. The argument can be any data value. The result is an INTEGER*4 data type. In the case of global symbols, %LOC returns the value of the symbol rather than its address. The %LOC built-in function serves the same purpose as the LOC intrinsic.
39.3 - %REF
%REF (arg) Forces an actual argument in a CALL statement or function reference to be passed by reference: the address of the argument is passed to the subprogram. By default, Fortran passes all numeric values by reference.
39.4 - %VAL
%VAL (arg) Forces an actual argument in a CALL statement or function reference to be passed by value: the actual value of the argument is passed to the subprogram. The argument must be 32 bits in size or less. If the argument is less than 32 bits in size, it is sign-extended to that size.
| 40 - Character Sets |
Compaq Fortran supports the following characters:
o The Fortran character set, which consists of those ASCII
characters that can appear in Compaq Fortran language syntax. The
Fortran character set is a superset of the FORTRAN-77 standard
character set; it includes space and tab characters.
o Other printable characters, which can appear in comments and
character and Hollerith constants.
o Nonprintable characters.
40.1 - ASCII
The following table represents the ASCII character set (characters
with decimal values 0 through 127). Except for SP and HT, the
characters with names are nonprintable.
To determine the hexadecimal value of an ASCII character, combine
the values in the column (0-7) and the row (0-F) that relate to the
character. For example, the value of the character representing
the equal sign is 3D(hex).
+------------------------------------------+
| 0 1 2 3 4 5 6 7 |
+---+--------------------------------------+
| 0 | NUL DLE SP 0 @ P ` p |
| 1 | SOH DC1 ! 1 A Q a q |
| 2 | STX DC2 " 2 B R b r |
| 3 | ETX DC3 # 3 C S c s |
| 4 | EOT DC4 $ 4 D T d t |
| 5 | ENQ NAK % 5 E U e u |
| 6 | ACK SYN & 6 F V f v |
| 7 | BEL ETB ' 7 G W g w |
| 8 | BS CAN ( 8 H X h x |
| 9 | HT EM ) 9 I Y i y |
| A | LF SUB * : J Z j z |
| B | VT ESC + ; K [ k { |
| C | FF FS , < L \ l | |
| D | CR GS - = M ] m } |
| E | SO RS . > N ^ n ~ |
| F | SI US / ? O _ o DEL |
+---+--------------------------------------+
The characters with names are defined as follows:
NUL Null DC1 Device Control 1(XON)
SOH Start of DC2 Device Control 2
Heading
STX Start of Text DC3 Device Control 3(XOFF)
ETX End of Text DC4 Device Control 4
EOT End of NAK Negative Acknowledge
Transmission
ENQ Enquiry SYN Synchronous Idle
ACK Acknowledge ETB End of Transmission
Block
BEL Bell CAN Cancel
BS Backspace EM End of Medium
HT Horizontal Tab SUB Substitute
LF Line Feed ESC Escape
VT Vertical Tab FS File Separator
FF Form Feed GS Group Separator
CR Carriage Return RS Record Separator
SO Shift Out US Unit Separator
SI Shift In SP Space
DLE Data Link DEL Delete
Escape
40.2 - DEC Multinational
The ASCII character set comprises the first half of the DEC
Multinational Character Set. The following table represents the
second half of the DEC Multinational Character Set (characters with
decimal values 128 through 255). These characters cannot be output
on some older terminals and printers. Note that the characters
with names are nonprintable.
To determine the hexadecimal value of an ASCII character, combine
the values in the column (8-F) and the row (0-F) that relate to the
character. For example, the value of the character representing
the pound sterling sign is A3(hex).
+------------------------------------------+
| 8 9 A B C D E F |
+---+--------------------------------------+
| 0 | DCS ° Ŕ ŕ |
| 1 | PU1 ˇ ± Á Ń á ń |
| 2 | PU2 ˘ ˛ Â Ň â ň |
| 3 | STS Ł ł Ă Ó ă ó |
| 4 | IND CCH Ä Ô ä ô |
| 5 | NEL MW Ą µ Ĺ Ő ĺ ő |
| 6 | SSA SPA ¶ Ć Ö ć ö |
| 7 | ESA EPA § · Ç × ç ÷ |
| 8 | HTS ¨ Č Ř č ř |
| 9 | HTJ © ą É Ů é ů |
| A | VTS Ş ş Ę Ú ę ú |
| B | PLD CSI « » Ë Ű ë ű |
| C | PLU ST Ľ Ě Ü ě ü |
| D | RI OSC ˝ Í Ý í ý |
| E | SS2 PM Î î |
| F | SS3 APC ż Ď ß ď |
+---+--------------------------------------+
The characters with names are defined as follows:
IND Index PU1 Private Use 1
NEL Next Line PU2 Private Use 2
SSA Start of STS Set Transmit State
Selected Area
ESA End of Selected CCH Cancel Character
Area
HTS Horizontal Tab MW Message Waiting
Set
HTJ Horizontal SPA Start of Protected
Tab Set with Area
Justification
VTS Vertical Tab EPA End of Protected
Set Area
PLD Partial Line CSI Control Sequence
Down Introducer
PLU Partial Line Up ST String Terminator
RI Reverse Index OSC Operating System
Command
SS2 Single Shift 2 PM Privacy Message
SS3 Single Shift 3 APC Application
DCS Device Control
String
40.3 - FORTRAN 77 Standard
The character set specified by the FORTRAN-77 Standard consists of
the uppercase letters A through Z, the digits 0 through 9, and the
following special characters:
SP (space) , (comma)
$ (dollar sign) - (minus sign)
' (apostrophe) . (period)
( (left parenthesis) / (slash)
) (right parenthesis) : (colon)
* (asterisk) = (equal sign)
+ (plus sign)
40.4 - FORTRAN
The Fortran character set includes the entire FORTRAN-77 Standard
set plus the lowercase letters a through z (uppercase and lowercase
letters are equivalent) and the following special characters:
! (exclamation mark) <Tab> (tab)
" (quotation mark) < (left angle bracket)
% (percent sign) > (right angle bracket)
& (ampersand) _ (underscore)
All printable characters (those in the range 20(hex) through
7E(hex), or A1(hex) through FE(hex)) can appear in comments,
character constants, and Hollerith constants.
40.5 - Printable Characters
Printable characters include the tab character (09 hex), those ASCII characters with codes in the range 20(hex) through 7E(hex), and those characters in the DEC Multinational Extension to the ASCII Character Set with codes in the range A1(hex) through FE(hex). Note that printable characters that are not in the Fortran character set (see Character_Set subtopic FORTRAN) can only appear in comments and character and Hollerith constants.
40.6 - Nonprintable Characters
If nonprintable characters appear anywhere in a Fortran source line
or comment, the compiler issues a warning diagnostic and the
nonprintable character is replaced with a blank in both the
compiled source and the listing, except for the following special
cases:
o The form-feed character (0C hex) is treated as a blank without
causing a diagnostic message to be issued. In addition, a
source record of length 1 containing a form-feed character
causes the compilation source listing to begin a new page.
o A source record of length 1 containing a Ctrl-Z character (1A
hex) is treated as a blank line. Such a record is created by
the ENDFILE statement.
If you must use a nonprintable character in a character constant,
use the CHAR intrinsic function (with the concatenation operator,
if necessary). For example:
CHARACTER*(*) ESC_BRACKET
PARAMETER (ESC_BRACKET = CHAR(27)//'[')
| 41 - Compatibility Features |
Compaq Fortran provides the following language features to aid compatibility with other versions of Fortran: o The DEFINE FILE, ENCODE, DECODE, and FIND statements o A NOF77 interpretation of the EXTERNAL statement o Octal forms of integer constants o An alternative syntax for the PARAMETER statement o The VIRTUAL statement o An alternative syntax for bit constants o An alternative syntax for a record specifier These language features are particularly useful in transporting older Fortran programs to a VAX system. However, you should avoid using them in new programs on these systems, and in new programs for which portability to other FORTRAN-77 implementations is important.
41.1 - DEFINE_FILE
The DEFINE FILE statement establishes the size and structure of
files with relative organization and associates them with a logical
unit number. The DEFINE FILE statement is comparable to the OPEN
statement (in situations where you can use the OPEN statement, it
is the preferable mechanism for creating and opening files).
Statement format:
DEFINE FILE u(m, n, U, asv) [,u(m, n, U, asv)]...
u Is an integer constant or variable that specifies the
logical unit number.
m Is an integer constant or variable that specifies the
number of records in the file.
n Is an integer constant or variable that specifies the
length of each record in 16-bit words (2 bytes).
U Specifies that the file is unformatted (binary); this
is the only acceptable entry in this position.
asv Is an integer variable, called the associated variable
of the file. At the end of each direct access I/O
operation, the record number of the next higher numbered
record in the file is assigned to "asv"; "asv" must not
be a dummy argument.
The DEFINE FILE statement specifies that a file containing "m"
fixed-length records, each composed of n 16-bit words, exists (or
is to exist) on the specified logical unit. The records in the
file are numbered sequentially from 1 through "m".
A DEFINE FILE statement must be executed before the first direct
access I/O statement referring to the specified file, even though
the DEFINE FILE statement does not itself open the file. The file
is actually opened when the first direct access I/O statement for
the unit is executed.
If this I/O statement is a WRITE statement, a new relative
organization file is created. If it is a READ or FIND statement,
an existing file is opened, unless the specified file does not
exist. If a file does not exist, an error occurs.
41.2 - ENCODE and DECODE
The ENCODE and DECODE statements transfer data between variables or
arrays in internal storage. The ENCODE statement translates data
from internal (binary) form to character form. Inversely, the
DECODE statement translates data from character to internal form.
These statements are comparable to using internal files in
formatted sequential WRITE and READ statements, respectively.
Statement format:
ENCODE (c,f,b [,IOSTAT=ios] [,ERR=s]) [list]
DECODE (c,f,b [,IOSTAT=ios] [,ERR=s]) [list]
c Is an integer expression. In the ENCODE statement,
"c" is the number of characters (in bytes) to be
translated to character form. In the DECODE statement,
"c" is the number of characters to be translated to
internal form.
f Is a format identifier. An error occurs if more than
one record is specified.
b Is a scalar or array reference. If b is an array
reference, its elements are processed in the
order of subscript progression. The data type of "b"
determines the number of characters that ENCODE or
DECODE can process.
In the ENCODE statement, "b" receives the characters
after translation to external form. If less than "c"
characters are received, the remaining character
positions are filled with blank characters.
In the DECODE statement, "b" contains the characters
to be translated to internal form.
ios Is an integer scalar memory reference that is defined
as a positive integer if an error occurs, and zero
if no error occurs.
s Is the label of an executable statement.
list Is an I/O list.
In the ENCODE statement, the "list" contains the data
to be translated to character form. In the DECODE
statement, the "list" receives the data after
translation to internal form.
The interaction between the format specifier and the
I/O list is the same as for a formatted I/O statement.
41.3 - FIND
The FIND statement positions a direct access file at a particular
record and sets the associated variable of the file to that record
number. It is comparable to a direct access READ statement with no
I/O list, and can open an existing file. No data transfer takes
place. Statement format:
FIND (u'r [,ERR=s] [,IOSTAT=ios])
FIND ([UNIT=]u, REC=r [,ERR=s] [,IOSTAT=ios])
u Is a logical unit number. It must refer to a
relative organization file.
r Is the direct access record number. It cannot
be less than one or greater than the number of
records defined for the file.
s Is the label of the executable statement that
receives control if an error occurs.
ios Is an integer variable or integer array element
that is defined as a positive integer if an error
occurs, and as a zero if no error occurs.
41.4 - NOF77_EXTERNAL
If you specify the /NOF77 qualifier, you get an interpretation of
the EXTERNAL statement that aids compatibility with older versions
of Fortran. (The ANSI FORTRAN-77 interpretation is incompatible
with the previous standard and previous Compaq implementations.)
The NOF77 interpretation combines the functionality of the
INTRINSIC statement with that of the EXTERNAL statement discussed
under the Help topic: Statements EXTERNAL.
The NOF77 EXTERNAL statement lets you use subprograms as arguments
to other subprograms. The subprograms to be used as arguments can
be either user-supplied procedures or Fortran library functions.
Statement format:
EXTERNAL [*]v [,[*]v]...
v Is the symbolic name of a subprogram or the name of
a dummy argument associated with the symbolic name
of a subprogram.
* Specifies that a user-supplied function is to be used
instead of a Fortran library function having the same
name.
The NOF77 EXTERNAL statement declares that each symbolic name in
its list is an external procedure name. Such a name can then be
used as an actual argument to a subprogram, which in turn can use
the corresponding dummy argument in a function reference or CALL
statement.
However, used as an argument, a complete function reference
represents a value, not a subprogram name.
41.5 - Octal Notation
Octal forms of integer constants allow compatibility with PDP-11
FORTRAN. Statement format:
"nn
nn Is a string of digits in the range 0 to 7 (for
example "107).
Integer constants in octal form have integer data type and are
treated as integers.
41.6 - PARAMETER
This statement is similar to the one discussed in Help topic:
Statements PARAMETER; they both assign a symbolic name to a
constant. However, this PARAMETER statement differs from the other
one in the following two ways: its list is not bounded with
parentheses; and the form of the constant, rather than implicit or
explicit typing of the symbolic name, determines the data type of
the variable. Statement format:
PARAMETER p=c [,p=c]...
p Is a symbolic name.
c Is a constant, the symbolic name of a constant, or a
compile-time constant expression.
41.7 - VIRTUAL
The VIRTUAL statement is included for compatibility with PDP-11 FORTRAN. It has the same form and effect as the DIMENSION statement (see Help Topic: Statements DIMENSION).
41.8 - Bit Constant Syntax
In Compaq Fortran, you can use the following alternative syntax for
binary, octal, and hexadecimal constants:
Alternative Syntax Equivalent
------------------ ----------
Binary B'0..1' '0..1'B
Octal O'0..7' '0..7'O
Hexadecimal X'0..F' or Z'0..F' '0..F'X or '0..F'Z
41.9 - Record Specifier Syntax
In Compaq Fortran, you can specify the following form for a record
specifier:
'r
r Is a numeric expression with a value that represents
the position of the record to be accessed using direct
access I/O. The value must be greater than or equal to 1,
and less than or equal to the maximum number of records
allowed in the file. If necessary, a record number is
converted to integer data type before being used.
| 42 - Data |
Each constant, variable, array, expression, or function reference in a Fortran statement represents typed data. The data type of these items can be inherent in their constructions, implied by convention, or explicitly declared. The data types available in Fortran are integer, REAL (REAL*4), DOUBLE PRECISION (REAL*8), REAL*16, COMPLEX (COMPLEX*8), DOUBLE COMPLEX (COMPLEX*16), BYTE (equivalent to LOGICAL*1 and INTEGER*1), logical, character, and Hollerith. Constants, variables, arrays, scalar fields, aggregate fields, character substrings, and expressions can be specified in many places in a Fortran program. Fortran statements and expressions have individual restrictions governing which of these items can used in them and in what form. Thus, to avoid repeatedly enumerating lists of the various items that can be specified with the various statements and expressions, the items are divided into four general categories: scalar reference, scalar memory reference, array name reference, and aggregate reference. The names of these categories are used throughout the "DEC Fortran Language Reference Manual" to identify what can be included in a particular statement or expression.
42.1 - Aggregate Reference
An aggregate reference resolves itself to a reference to a
structured data item (a record structure or substructure). For
example:
Data Declarations:
STRUCTURE /STRA/
INTEGER INTFLD, INTFLDARY (10)
END STRUCTURE
. . .
STRUCTURE /STRB/
CHARACTER*20 CHARFLD
INTEGER INTFLD, INTFLDARY (10)
STRUCTURE STRUCFLD
COMPLEX CPXFLD, CPXFLDARY (10)
END STRUCTURE
RECORD /STRA/ RECFLD, RECFLDARY (10)
END STRUCTURE
. . .
RECORD /STRB/ REC, RECARY (10)
Reference Examples:
REC --- Is a record name.
RECARY(1) --- Is a record array reference.
REC.RECFLD --- Is a reference to a substructure.
REC.RECFLDARY(1) --- Is a reference to a substructure
array element.
RECARY(1).RECFLD --- Is a reference to a substructure
in a record array element.
RECARY(1).RECFLDARY(1) --- Is a reference to a substructure
array element in a record array.
42.2 - Arrays
An array is a group of contiguous storage locations associated with a single symbolic name, the array name. The individual storage locations, called array elements, are referred to by a subscript appended to the array name. An array can have from 1 to 7 dimensions. The Fortran statements that establish arrays are: type declaration statements, the DIMENSION statement, and the COMMON statement. The data type of an array is specified in the same way as the data type of a variable; either implicitly by the first letter of the name or explicitly by a type declaration statement.
42. 2.1 - Declarators
An array declarator specifies the symbolic name that identifies an
array within a program unit and indicates the properties of the
array. It has the form:
a(d[,d]...) a is the name of the array
d specifies the bounds of the array in the form:
[dl:]du dl is the lower bound
du is the upper bound
42. 2.2 - Subscripts
A subscript qualifies an array name. A subscript is a list of
expressions, called subscript expressions, enclosed in parentheses,
that determine which element in the array is referred to. The
subscript is appended to the array name it qualifies. A subscript
has the form:
(s[,s]...) s is a subscript expression
A one-dimensional array is stored with its first element in the
first storage location and its last element in the last storage
location of the sequence. A multidimensional array is stored so
that the leftmost subscripts vary most rapidly.
42.3 - Array Name Reference
An array name reference resolves itself to the name of an array
with no subscripts after the array name. For example:
Data Declarations:
INTEGER INT, INTARY (10)
. . .
STRUCTURE /STRA/
INTEGER INTFLD, INTFLDARY (10)
END STRUCTURE
. . .
STRUCTURE /STRB/
CHARACTER*20 CHARFLD
INTEGER INTFLD, INTFLDARY (10)
STRUCTURE STRUCFLD
COMPLEX CPXFLD, CPXFLDARY (10)
END STRUCTURE
RECORD /STRA/ RECFLD, RECFLDARY (10)
END STRUCTURE
. . .
RECORD /STRB/ REC, RECARY (10)
Reference Examples:
INTARY --- Is a numeric or character array.
RECARY --- Is an array of records.
REC.INTFLDARY --- Is a numeric or character array field of
a record.
REC.RECFLDARY --- Is an array of substructures within a record.
RECARY(1).INTFLDARY --- Is a numeric or character array field of
a record array element.
RECARY(1).RECFLDARY --- Is an array of substructures within a
record array element.
42.4 - Constants
A constant is a fixed value. The value of a constant can be a numeric value, a logical value, or a character string. There are seven types of constants: integer, real, complex, bit, logical, character, and Hollerith. Bit and Hollerith constants have no data type; they assume a data type that conforms to the context in which they are used.
42. 4.1 - Bit
A bit constant is a binary, octal, or hexadecimal constant. You
can use this type of constant wherever numeric constants are
allowed and it assumes a numeric data type according to its
context.
A binary constant has the form:
'c1c2c3...cn'B c is a 0 or 1
An octal constant has the form:
'c1c2c3...cn'O c is a digit in the range 0 - 7
A hexadecimal constant has the form:
'c1c2c3...cn'X c is a digit in the range 0 - 9, or a letter
or in the range A - F, or a - f
'c1c2c3...cn'Z
Bit constants are "typeless" numeric constants. They assume data
types based on their usage, according to the following rules:
o When the constant is used with a binary operator, including the
assignment operator, the data type of the constant is the data
type of the other operand.
o When a specific data type is required, that type is assumed for
the constant.
o When the constant is used as an actual argument, no data type
is assumed; however, a length of 4 bytes is always used.
o When the constant is used in any other context, an INTEGER*4
data type is assumed.
Note that on VAX systems, the following example causes a
data-typing problem:
I = 80 * '01000000'X
The quantity '01000000'X is typeless and assumes the data type of
operand 80. The compiler treats 80 as an INTEGER*2 quantity (since
its value is within the range -32768 to 32767), and tries to
convert '01000000'X to INTEGER*2. Since '01000000'X is too large
for the INTEGER*2 type, you get an error message.
You can avoid this problem by giving the constant an INTEGER*4 type
in a PARAMETER statement, as follows:
INTEGER*4 K
PARAMETER (K = '01000000'X)
42. 4.2 - Character
A character constant is a string of printable ASCII characters
enclosed by apostrophes. A character constant has the form:
'c1,c2,c3...cn' c is a printable character.
The length of the character constant is the number of characters
between the apostrophes, except that two consecutive apostrophes
represent a single apostrophe. The length of a character constant
must be in the range 1 to 2000.
42. 4.3 - Complex
A complex constant consists of a pair of real or integer constants.
The two constants are separated by a comma and enclosed in
parentheses. The first constant represents the real part of the
number and the second constant represents the imaginary part.
Compaq Fortran supports COMPLEX*8 and COMPLEX*16 complex constants.
A COMPLEX*8 has the form:
(c,c) c is an integer or REAL*4 constant
A COMPLEX*16 has the form:
(c,c) c is an integer, REAL*4, or REAL*8 constant
(at least one of the pair must be a
REAL*8 constant)
42. 4.4 - Hollerith
A Hollerith constant is a string of printable characters preceded
by a character count and the letter H. It is used only in numeric
expressions and has the form:
nHc1c2c3...cn
n Is an unsigned, nonzero integer constant stating the
number of characters in the string (including tabs and spaces).
c Is a printable character.
A Hollerith constant can be a string of 1 to 2000 characters and is
stored as a byte string, one character per byte.
Hollerith constants have no data type, but assume a numeric data
type according to the context in which they are used.
42. 4.5 - Integer
An integer constant is a whole number with no decimal point. It
can have a leading sign and is interpreted as a decimal number. It
has the form:
snn s is an optional sign
nn is a string of decimal digits
The value of the integer constant must be in the range -2147483648
to 2147483647.
You can use integer constants to assign values to data. The
integer data types have the following ranges:
BYTE Same range as LOGICAL*1 and INTEGER*1
INTEGER*1 Signed integers: -128 to 127 (-2**7 to 2**7-1)
(1 byte) Unsigned integers: 0 to 255 (2**8-1)
INTEGER*2 Signed integers: -32768 to 32767
(2 bytes) (-2**15 to 2**15-1)
Unsigned integers: 0 to 65535 (2**16-1)
INTEGER*4 Signed integers: -2147483648 to 2147483647
(4 bytes) (-2**31 to 2**31-1)
Integer constants in an octal form are preceded by a quotation mark
and must use only the digits 0-7.
42. 4.6 - Logical
The logical constants are .TRUE. and .FALSE.
42. 4.7 - REAL_4
A REAL*4 constant can be a basic real constant (with or without a
decimal exponent) or an integer constant followed by a decimal
exponent. A basic real constant has one of these forms:
s.nn s is an optional sign
snn.nn nn is a string of decimal digits
snn.
A decimal exponent has the form:
Esnn s is an optional sign
nn is an integer constant
42. 4.8 - REAL_8
A REAL*8 constant can be a basic real constant or an integer
constant followed by a decimal exponent. A decimal exponent has
the form:
Dsnn s is an optional sign
nn is a string of decimal digits
There are two implementations of the REAL*8 constant: D_floating
and G_floating. G_floating requires the /G_FLOATING command
qualifier.
42. 4.9 - REAL_16
A REAL*16 constant can be a basic real constant or an integer
constant followed by a decimal exponent. A decimal exponent has
the form:
Qsnn s is an optional sign
nn is a string of decimal digits
42.5 - Expressions
An expression represents a single value. An expression can consist
of a single constant, variable, record element, array element, or
function reference; or combinations of these data items plus
certain other elements, called operators. Operators specify
computations to be performed on the values of the data items and a
single result is obtained.
Expressions are classified as arithmetic, character, relational, or
logical. Arithmetic expressions produce numeric values; character
expressions produce character values; and relational and logical
expressions produce logical values.
The data components of an expression must be compatible and must be
joined by compatible operators. Expressions are evaluated one
operator at a time according to the rules of precedence. The
ranking assigned to each data type is as follows:
Data Type Ranking
--------- -------
BYTE, LOGICAL*1, INTEGER*1 1 (lowest)
LOGICAL*2 2
LOGICAL*4 3
INTEGER*2 4
INTEGER*4 5
REAL*4 (REAL) 6
REAL*8 (DOUBLE PRECISION) 7
REAL*16 8
COMPLEX*8 (COMPLEX) 9
COMPLEX*16 (DOUBLE COMPLEX) 10 (highest)
42. 5.1 - Arithmetic
Arithmetic expressions contain numeric data such as variables,
record elements, array elements, constants, function references,
and arithmetic expressions enclosed in parentheses. The expression
evaluates to a numeric value. The numeric operators are as
follows:
OPERATOR RANK DESCRIPTION
** 1 exponentiation (evaluated
right to left)
* 2 multiplication
/ 2 division
+ 3 addition
- 3 subtraction
You can use parentheses to force an order of evaluation.
42. 5.2 - Character
Character expressions consist of character elements and character
operators. Evaluation of a character expression yields a single
value of character data type. A character element can be a
constant, variable, record element, array element, substring,
expression (optionally enclosed in parentheses), or a function
reference.
A character expression has the form:
character element[//character element]...
The concatenation operator (//) is the only character operator.
Concatenation is from left to right.
42. 5.3 - Logical
Logical expressions can contain logical and integer data such as
variables, record elements, array elements, constants, function
references, expressions enclosed in parentheses, and relational
expressions. The expression evaluates to a logical value using the
following operators:
OPERATOR PRECEDENCE
** First (Highest)
*,/ Second
+,-,// Third
Relational
Operators Fourth
.NOT. Fifth
.AND. Sixth
.OR. Seventh
.XOR. Eighth (Lowest)
.NEQV. Eighth
.EQV. Eighth
42. 5.4 - Relational
Relational expressions consist of either two arithmetic or two
character expressions separated by relational operators. The
expression is reduced to a logical value (true or false).
OPERATOR DESCRIPTION
.LT. Less than
.LE. Less than or equal to
.EQ. Equal to
.NE. Not equal to
.GT. Greater than
.GE. Greater than or equal to
Expressions of COMPLEX data type can use only .EQ. and .NE.
operators.
42.6 - Records
The Compaq Fortran record handling capability enables you to declare and operate on multi-field records. A Compaq Fortran record is a named data entity, consisting of one or more fields, that you create in your program. Creating a record requires both a structure declaration (to describe the fields in the record) and a RECORD statement to establish the record in memory.
42. 6.1 - Examples
Structure APPOINTMENT:
Structure /APPOINTMENT/
RECORD /DATE/ APP_DATE
STRUCTURE /TIME/ APP_TIME (2)
LOGICAL*1 HOUR, MINUTE
END STRUCTURE
CHARACTER*20 APP_MEMO (4)
LOGICAL*1 APP_FLAG
END STRUCTURE
The following statement results in the creation of both a variable
named NEXT_APP and a 10-element array named APP_LIST. Both the
variable and each element of the array have the form of the
structure APPOINTMENT.
RECORD /APPOINTMENT/ NEXT_APP,APP_LIST(10)
The following examples show aggregate and scalar field references.
Aggregate:
NEXT_APP ! The record NEXT_APP
NEXT_APP.APP_TIME(1) ! An array field of the variable
! NEXT_APP
APP_LIST(3).APP_DATE ! A 4-byte array field in the record array
! APP_LIST(3)
Scalar:
NEXT_APP.APP_FLAG ! A LOGICAL field of the record
! NEXT_APP
NEXT_APP.APP_MEMO(1)(1:1)
! The first character of APP_MEMO(1),
! a character*20 field of the record
! NEXT_APP
42. 6.2 - Field References
Fields within a record can be accessed collectively or
individually. Record references are either qualified or
unqualified.
A qualified reference refers to a typed data item and can be used
wherever an ordinary variable is allowed. Type conversion rules
are the same as for variables. Its form is:
rname[.cfname...cfname].afname
Unqualified references refer to a record structure or substructure
and can be used (in most cases) like arrays.
rname[.cfname...cfname]
rname The name used in the RECORD statement to
identify a record.
cfname A substructure field name within the record
identified by record-name.
afname The name of a typed data item within a structure
declaration.
42.7 - Scalar Reference
A scalar reference is a scalar variable, scalar record field, array
element, constant, character substring, or expression that resolves
into a single, typed data item. For example:
Data Declarations:
INTEGER INT, INTARY (10)
. . .
STRUCTURE /STRA/
INTEGER INTFLD, INTFLDARY (10)
END STRUCTURE
. . .
STRUCTURE /STRB/
CHARACTER*20 CHARFLD
INTEGER INTFLD, INTFLDARY (10)
STRUCTURE STRUCFLD
COMPLEX CPXFLD, CPXFLDARY (10)
END STRUCTURE
RECORD /STRA/ RECFLD, RECFLDARY (10)
END STRUCTURE
. . .
RECORD /STRB/ REC, RECARY (10)
Reference Examples:
INT --- Is a numeric variable.
INTARY(1) --- Is a numeric array element.
REC.INTFLD --- Is a numeric field.
REC.INTFLDARY(1) --- Is a numeric element of an array field.
CHARVAR(5:10) --- Is a substring expression of a character
variable.
REC.CHARFLD(5:10) --- Is a substring expression of a character
field.
Note: A scalar memory reference is the same as a scalar reference,
excluding constants and expressions.
42.8 - Substrings
A character substring is a contiguous segment of a character
variable, character array element, or character field reference.
It has one of the following forms:
v([e1]:[e2]) OR a(s[,s]...)([e1]:[e2])
v Is a character variable name.
a Is a character array name.
s Is a subscript expression.
e1 Is a numeric expression specifying the leftmost
character position of the substring.
e2 Is a numeric expression specifying the rightmost
character position of the substring.
NOTE:
1 .LE. e1 .LE. e2 .LE. length-of-v must hold true
42.9 - Types
The Fortran data types are as follows:
o Integer - A whole number
o REAL (REAL*4) - A single-precision floating-point number
(a whole number or a decimal fraction or
a combination)
o DOUBLE PRECISION (REAL*8) - A double-precision floating-point
number (like REAL*4, but with twice the
degree of accuracy in its representation)
o REAL*16 - A quad-precision floating-point number (like REAL*4,
but with four times the degree of accuracy in its
representation.)
o COMPLEX (COMPLEX*8) - A pair of REAL*4 values representing
a complex number (the first part of the number is
the real part, the second is the imaginary part)
o COMPLEX*16 (DOUBLE COMPLEX) - Similar to complex, but with
twice the degree of accuracy in its representation
(its real or imaginary part must be a REAL*8)
o Logical - A logical value, .TRUE. or .FALSE.
o Character - A sequence of characters
42. 9.1 - Character
A character string is a contiguous sequence of bytes in memory. A character string is specified by two attributes: the address of the first byte of the string and the length of the string in bytes. The length of the string must be in the range 1 through 65535. Hollerith constants are stored internally, one character per byte.
42. 9.2 - COMPLEX
Real and complex numbers are floating-point representations. COMPLEX*8 (F_floating) data is eight contiguous bytes aligned on an arbitrary byte boundary. The low-order four bytes contain REAL*4 data that represents the real part of the complex number. The high-order four bytes contain REAL*4 data that represents the imaginary part of the complex number. COMPLEX*16 (D_floating) data is 16 contiguous bytes aligned on an arbitrary byte boundary. The low-order bytes contain REAL*8 (D_floating) data that represents the real part of the complex data. The high-order eight bytes contain REAL*8 (D_floating) data that represents the imaginary part of the complex data. COMPLEX*16 (G_floating) data is 16 contiguous bytes aligned on an arbitrary byte boundary. The low-order bytes contain REAL*8 (G_floating) data that represents the real part of the complex data. The high-order eight bytes contain REAL*8 (G_floating) data that represents the imaginary part of the complex data.
42. 9.3 - Integer
Integer values are stored in two's complement form; INTEGER*2 uses two contiguous bytes and must be in the range -32768 to 32767. INTEGER*4 uses four contiguous bytes and must be in the range -2147483648 to 2147483647. If the value is in the range of an INTEGER*2, then the first word can be referenced as an INTEGER*2 value.
42. 9.4 - Logical
Logical values start on an arbitrary byte boundary and are stored in one, two, or four contiguous bytes. The low-order bit (bit 0) determines the value. If bit 0 is set, the value is .TRUE.; if bit 0 is clear, the value is .FALSE. The remaining bits are undefined.
42. 9.5 - REAL
Real and complex numbers are floating-point representations. The exponent for REAL*4 and REAL*8 (D_floating) formats is stored in binary excess 128 notation. Binary exponents from -127 to 127 are represented by the binary equivalents of 1 through 255. The exponent for the REAL*8 (G_floating) format is stored in binary excess 1024 notation. The exponent for the REAL*16 format is stored in binary excess 16384 notation. In REAL*8 (G_floating) format, binary exponent from -1023 to 1023 are represented by the binary equivalents of 1 through 2047. In REAL*16 format, binary exponents from -16383 to 16383 are represented by the binary equivalents of 1 through 32767. For each floating-point format, fractions are represented in sign-magnitude notation, with the binary radix point to the left of the most significant bit. Fractions are assumed to be normalized, and therefore the most significant bit is not stored. This bit is assumed to be 1 unless the exponent is 0., in which case the value represented is either zero or is a reserved operand. REAL*4 (F_floating) numbers occupy four contiguous bytes and the precision is approximately one part in 2**23, that is, typically 7 decimal digits. REAL*8 (D_floating) numbers occupy eight contiguous bytes and the precision is approximately one part in 2**55, that is, typically 16 decimal digits. REAL*8 (G_floating) numbers occupy eight contiguous bytes the precision is approximately one part in 2**52, that is, typically 15 decimal digits. REAL*16 (H_floating) numbers occupy sixteen contiguous bytes and the precision is approximately 2**112, that is, typically 33 decimal digits.
42.10 - Variables
A variable is represented by a symbolic name that is associated with a storage location. The value of the variable is the value currently stored in that location; the value can be changed by assigning a new value to the variable. Variables, like constants, are classified by data type. When data of any type is assigned to a variable, it is converted, if necessary, to the data type of the variable. You can establish the data type of a variable by type declaration statements, IMPLICIT statements, or predefined typing rules.
42. 10.1 - Implication
In the absence of either IMPLICIT statements or explicit type statements, all variables with names beginning with I, J, K, L, M, or N are assumed to be integer variables. Variables beginning with any other letter are assumed to be REAL*4 variables.
42. 10.2 - Specification
Type declaration statements explicitly define the data type of
variables.
Numeric type declaration statements have the form:
type v[/clist][,v[/clist]]...
type Is any data type except CHARACTER.
v Is the name of a constant, variable, array, statement
function or function subprogram, or array declarator.
clist Is a list of constants.
Character type declaration statements have the form:
CHARACTER[*len[,]] v[*len] [/clist/] [,v[*len] [/clist/]]...
len Is an unsigned integer constant, an integer constant
expression enclosed in parentheses, or an asterisk
enclosed in parentheses.
The value of len specifies the length of the character
data elements.
v Is the symbolic name of a constant, variable, array,
statement or function subprogram, or array declarator.
The name can optionally be followed by a data type
length specifier (*n). For character entities, the length
specifier can be *len or *(*).
clist Is an initial value or values to be assigned to the
immediately preceding variable or array element.
| 43 - Error Messages |
43.1 - Compilation Errors
A diagnostic message issued by the compiler describes the detected
error and, in some cases, contains an indication of the action
taken by the compiler in response to the error.
Besides reporting errors detected in source program syntax, the
compiler issues messages indicating errors that involve the
compiler itself, such as I/O errors.
The severity-level classes of compilation error messages, in order
of greatest to least severity, are as follows:
Code Description
---- -----------
F Fatal; must be corrected before the program can
be compiled. No object file is produced.
E Error; should be corrected. An object file is
produced, but the output or program result may
be incorrect.
W Warning; should be investigated by checking the
statements to which warning diagnostic messages
refer. Warnings are issued for statements that
use acceptable, but nonstandard, syntax and for
statements corrected by the compiler. An object
file is produced, but the program results may be
incorrect. (If you specify /NOWARNINGS on the
FORTRAN command line, you will not receive these
messages.)
I Information; not an error message and does not call
for corrective action. However, the informational
message informs you that either a correct Compaq Fortran
statement may have unexpected results or you have
used a Compaq Fortran extension to FORTRAN-77.
The following examples show how compilation messages are displayed:
%FORT-W-FMTEXTCOM, Extra comma in format list
[FORMAT (I3,)] in module MORTGAGE at line 13
%FORT-F-UNDSTALAB, Undefined statement label
[66] in module MORTGAGE at line 19
43. 1.1 - ADJARRBOU
SEVERITY: F MESSAGE TEXT: Adjustable array bound contains invalid data item EXPLANATION: An adjustable array dimension declarator expression contained an operand that was not one of the following: o A constant o A variable in a common block o A variable associated with a subprogram dummy argument
43. 1.2 - ADJARRUSE
SEVERITY: F MESSAGE TEXT: Adjustable array used in invalid context EXPLANATION: A reference to an adjustable array was made in a context where such a reference is not allowed.
43. 1.3 - ADJLENUSE
SEVERITY: F MESSAGE TEXT: Passed-length character name used in invalid context EXPLANATION: A reference to a passed-length character array or variable was made in a context where such a reference is not allowed.
43. 1.4 - AGGREFSIZ
SEVERITY: F MESSAGE TEXT: Aggregate reference exceeds 65535 bytes per element EXPLANATION: Any aggregate reference larger than 65535 bytes cannot be used in an I/O list or as an actual or dummy argument.
43. 1.5 - ALNNOMAT
SEVERITY: W
MESSAGE TEXT: A lignment settings of common block are inconsistent with
previous declaration
EXPLANATION: Occurs when using CDEC$ OPTIONS/ALIGN (or /WARN=ALIGN)
if the same COMMON is declared in multiple places within a single
compilation unit and /ALIGN or /WARN=ALIGN has changed between
places. For example:
CDEC$ OPTIONS /ALIGN=COMMON=NATURAL
COMMON /COM1/ A,B ! common elements are naturally aligned
CDEC$ END OPTIONS
CDEC$ OPTIONS /ALIGN=COMMON=PACKED
COMMON /COM1/ C,D ! common elements are packed
CDEC$ END OPTIONS
Note that COMMON declarations can also take place in SAVE and
VOLATILE statements and in CDEC$ PSECT, CPAR$ PRIVATE and CPAR$
SHARED directives. All declarations must be in the scope of a
consistent setting for alignment and alignment warnings.
USER ACTION: Modify the program to remove inconsistent alignment directives.
43. 1.6 - ALTRETLAB
SEVERITY: F MESSAGE TEXT: Alternate return label used in invalid context EXPLANATION: An alternate return argument cannot be used in a function reference.
43. 1.7 - ALTRETOMI
SEVERITY: E
MESSAGE TEXT: Alternate return omitted in SUBROUTINE or ENTRY
statement
EXPLANATION: An asterisk is missing in the argument list of a
subroutine for which an alternate return is specified. Examples:
1. SUBROUTINE XYZ(A,B)
. . .
RETURN 1
2. ENTRY ABC(Q,R)
. . .
RETURN I+4
43. 1.8 - ALTRETSPE
SEVERITY: F
MESSAGE TEXT: Alternate return specifier invalid in FUNCTION
subprogram
EXPLANATION: The argument list of a FUNCTION declaration contains
an asterisk or a RETURN statement in a function subprogram
specifies an alternate return. Examples:
1. INTEGER FUNCTION TCB(ARG,*,X)
2. FUNCTION IMAX
. . .
RETURN I+J
END
43. 1.9 - ARGLISEXE
SEVERITY: F MESSAGE TEXT: IARGCOUNT/IARGPTR used in non-executable statement EXPLANATION: One of the argument list inquiry functions, IARGCOUNT or IARGPTR, was used in a non-executable statement such as a statement function declaration.
43. 1.10 - ARIVALREQ
SEVERITY: F MESSAGE TEXT: Character expression where arithmetic value required EXPLANATION: An expression that must be arithmetic (INTEGER, REAL, LOGICAL, or COMPLEX) was of type CHARACTER.
43. 1.11 - ASFUNUSED
SEVERITY: I MESSAGE TEXT: Statement function was defined but not used EXPLANATION: The specified statement function was defined but never used. This message can be suppressed with /WARNINGS=NOUNCALLED.
43. 1.12 - ASSARRUSE
SEVERITY: F MESSAGE TEXT: Assumed size array name used in invalid context EXPLANATION: An assumed size array name was used where the size of the array was also required, for example, in an I/O list.
43. 1.13 - ASSDOVAR
SEVERITY: W MESSAGE TEXT: Assignment to DO variable within loop EXPLANATION: The control variable of a DO loop has been altered within the range of the DO statement.
43. 1.14 - ATTRIERR
SEVERITY: I
MESSAGE TEXT: COMMON attributes conflict, using the default
attribute
EXPLANATION: This error only occurs with the CDEC$ PSECT compiler
directive statement and under any of the following circumstances:
o A common block is declared as both GBL (global) and LCL
(local), both WRT (write) and NOWRT (nowrite), or both SHR
(shared) and NOSHR (noshared).
o More than one alignment (ALIGN=) to the COMMON block is
specified.
o The following combination of compiler directive statements
occurs:
CPAR$ SHARED com_blk
and
CDEC$ PSECT /com_blk/ ATTRI=something-not-page-alignment
o An alignment value exceeding the legal range is specified. The
alignment attribute can only take the value of 0 through 9.
43. 1.15 - AUTDATINI
SEVERITY: W MESSAGE TEXT: Variable is data-initialized; AUTOMATIC ignored EXPLANATION: A variable was declared as AUTOMATIC but was also data-initialized in a DATA or type-specification statement. AUTOMATIC variables cannot be data-initialized. The AUTOMATIC attribute was ignored.
43. 1.16 - AUTSAVALL
SEVERITY: W MESSAGE TEXT: SAVE of all variables specified; AUTOMATIC ignored EXPLANATION: A variable was declared as AUTOMATIC in a program unit which contained a SAVE statement that, by omitting a list of names of variables to be SAVEd, specified that all variables should be SAVEd. The AUTOMATIC attribute was ignored.
43. 1.17 - BADALIGN
SEVERITY: W MESSAGE TEXT: Variable not naturally aligned EXPLANATION: A variable or array was declared in such a way that it crossed a natural boundary for its data size.
43. 1.18 - BADEND
SEVERITY: F MESSAGE TEXT: END [STRUCTURE|UNION|MAP] must match top EXPLANATION: A STRUCTURE, UNION, or MAP statement did not have a corresponding END STRUCTURE, END UNION, or END MAP statement, respectively.
43. 1.19 - BADFIELD
SEVERITY: F MESSAGE TEXT: Field name not defined for this structure EXPLANATION: A field name not defined in a record structure was used in a record reference.
43. 1.20 - BADRECREF
SEVERITY: F MESSAGE TEXT: Aggregate reference where scalar reference required EXPLANATION: An aggregate record reference was used where a scalar record reference was required.
43. 1.21 - BADVALUE
SEVERITY: F MESSAGE TEXT: "keyword-value" is an invalid keyword value EXPLANATION: The specified FORTRAN command line contained a keyword "keyword-value" that is not recognized as a valid keyword value.
43. 1.22 - BRNCHINTOBLK
SEVERITY: I MESSAGE TEXT: Questionable branch into loop or block EXPLANATION: A branch into a DO loop or IF block was detected. Although this might be valid if the FORTRAN 66 "extended range of a DO loop" feature was being used, it generally indicates a programming error. A common case involves two or more DO loops which share a common termination. In such cases, the shared termination statement is considered to belong to the innermost DO loop. This message can be suppressed with /WARNINGS=NOUSAGE.
43. 1.23 - BUGCHECK
SEVERITY: F MESSAGE TEXT: Internal consistency failure EXPLANATION: The compiler detected an internal error and the compilation was terminated. Please report the problem to Compaq (by means of a Software Performance Report (SPR)) and include all information necessary to reproduce the error.
43. 1.24 - CDDALNARY
SEVERITY: I MESSAGE TEXT: CDD description specifies an aligned array (unsupported) EXPLANATION: The CDD description contained an array field whose elements have an alignment that Compaq Fortran cannot accommodate. When this error is encountered, the array is replaced by a structure of the appropriate size.
43. 1.25 - CDDBITSIZ
SEVERITY: F MESSAGE TEXT: CDD field specifies a bit size or alignment. EXPLANATION: The CDD's bit datatype and bit alignment are not supported by Compaq Fortran.
43. 1.26 - CDDERROR
SEVERITY: I MESSAGE TEXT: CDD description extraction condition EXPLANATION: The Compaq Fortran compiler encountered an error while extracting a structure definition from the Common Data Dictionary (CDD). See the accompanying messages for more information.
43. 1.27 - CDDINIVAL
SEVERITY: I MESSAGE TEXT: CDD description contains Initial Value attribute (ignored) EXPLANATION: A field that specified an initial value was present in the CDD description being expanded. When this error is encountered, the initial value is ignored.
43. 1.28 - CDDNOTSTR
SEVERITY: F MESSAGE TEXT: CDD record is not a structure EXPLANATION: Compaq Fortran requires structure definitions (elementary field descriptions in CDDL). The data described by the CDD is not a structure.
43. 1.29 - CDDRECDIM
SEVERITY: F MESSAGE TEXT: CDD record is dimensioned EXPLANATION: Compaq Fortran does not support dimensioned structures, for example, arrays of structures.
43. 1.30 - CDDSCALED
SEVERITY: W MESSAGE TEXT: CDD description specifies a scaled data type EXPLANATION: Compaq Fortran does not support scaled data types. The data described by the CDD specifies a scaled component.
43. 1.31 - CDDTOOBIG
SEVERITY: F MESSAGE TEXT: Attributes for some member of CDD record description exceed implementation's limit for member complexity EXPLANATION: Some member of the Common Data Dictionary record description had too many attributes and created a program that was too large. Change the CDD description to make the field description smaller.
43. 1.32 - CDDTOODEEP
SEVERITY: F MESSAGE TEXT: Attributes for CDD record description exceed implementation's limit for record complexity EXPLANATION: The CDD record description contained structures that were nested too deeply. Modify the CDD description to reduce the level of nesting in the record description.
43. 1.33 - CHACONCONTD
SEVERITY: I
MESSAGE TEXT: Character, Hollerith or RAD50 constant continued
across lines; may be non-portable
EXPLANATION: A character, Hollerith or RAD50 constant was continued
across two or more source lines. This is potentially non-portable
as some implementations pad source lines with blanks and others,
including Compaq Fortran, do not, which can result in different constant
values. This diagnostic is issued only if one or more of the source
lines which made up the statement was shorter than the statement field
width (72 or 132 columns, depending on /EXTEND_SOURCE), and can be
suppressed with /WARNINGS=NOUSAGE.
USER ACTION: For character constants, use the concatenation
operator to build up long values. Replace Hollerith or
RAD50 constants with character constants if feasible or
ensure that they are complete on one line. For character
constants used for data initialization, PARAMETER constants
must be used to maintain FORTRAN-77 standard conformance.
For example:
CHARACTER*(*) CHRCON
PARAMETER (CHRCON = 'This is a continued '//
1 'character value')
CHARACTER*80 CHRVAL
DATA CHRVAL /CHRCON/
43. 1.34 - CHANAMINC
SEVERITY: E
MESSAGE TEXT: Character name incorrectly initialized with numeric
value
EXPLANATION: Character data with a length greater than one was
initialized with a numeric value in a DATA statement. Example:
CHARACTER*4 A
DATA A/14/
43. 1.35 - CHASBSLIM
SEVERITY: F
MESSAGE TEXT: Character substring limits out of order
EXPLANATION: The first character position of a substring
expression was greater than the last character position. Example:
C(5:3)
43. 1.36 - CHAVALREQ
SEVERITY: F MESSAGE TEXT: Arithmetic expression where character value required EXPLANATION: An expression that must be of type CHARACTER was of another data type.
43. 1.37 - CLOSEIN
SEVERITY: F MESSAGE TEXT: Error closing "file-spec" as input EXPLANATION: Unable to close the file "file-spec".
43. 1.38 - CLOSEOUT
SEVERITY: F MESSAGE TEXT: Error closing "file-spec" as output EXPLANATION: Unable to close the file "file-spec".
43. 1.39 - COMALNERR
SEVERITY: F MESSAGE TEXT: COMMON alignment error, too small for variable EXPLANATION: A field in the COMMON block is larger than the size of alignment requested by the CDEC$ PSECT directive. USER ACTION: Specify a larger alignment value in the CDEC$ PSECT directive for the COMMON block.
43. 1.40 - COMVARDECL
SEVERITY: F MESSAGE TEXT: Common variable cannot be declared SHARED or PRIVATE EXPLANATION: A variable within a common block cannot be specified in a CONTEXT_SHARED or PRIVATE compiler directive statement. Entire common blocks can be declared shared or private, but individual elements within them cannot be declared context-shared or private.
43. 1.41 - CONMEMEQV
SEVERITY: E MESSAGE TEXT: Conflicting memory attributes in an equivalenced group EXPLANATION: By means of an EQUIVALENCE statement, certain memory locations were given conflicting memory attributes (shared or context-shared and private).
43. 1.42 - COMNAMCONF
SEVERITY: I MESSAGE TEXT: COMMON block name conflicts with other global entity - usage is non-standard and non-portable EXPLANATION: The name of a COMMON block is not allowed to be the same as the name of any other global entity (program unit, external procedure) (F77 standard 18.1.1). Such a conflict may cause incorrect execution on other platforms. USER ACTION: Change the name of either the COMMON block or the other global entity to remove the conflict. This message can be suppressed by /WARNINGS=NOUSAGE.
43. 1.43 - CONSIZEXC
SEVERITY: E MESSAGE TEXT: Constant size exceeds variable size in data initialization EXPLANATION: A constant used for data initialization is larger than its corresponding variable.
43. 1.44 - DBGOPT
SEVERITY: I MESSAGE TEXT: The NOOPTIMIZE qualifier is recommended with the DEBUG qualifier EXPLANATION: Optimizations performed by the compiler can cause several different kinds of unexpected behavior when using OpenVMS DEBUG. For more information about compiler optimizations, see the Compaq Fortran Performance Guide for OpenVMS VAX Systems.
43. 1.45 - DEFSTAUNK
SEVERITY: I MESSAGE TEXT: Default STATUS='UNKNOWN' used in OPEN statement EXPLANATION: The OPEN statement default STATUS='UNKNOWN' can cause an old file to be inadvertently modified.
43. 1.46 - DEPENDITEM
SEVERITY: I MESSAGE TEXT: CDD description contains Depends Item attribute (ignored) EXPLANATION: Fortran does not support the Common Data Dictionary Depend Item attribute.
43. 1.47 - DESCOMABORT
SEVERITY: F MESSAGE TEXT: /DESIGN=COMMENTS processing has been aborted due to an internal error EXPLANATION: The design processing routines have detected an internal error; subsequent messages provide more detail. Please report the problem to Compaq.
43. 1.48 - DESCOMERR
SEVERITY: W MESSAGE TEXT: Error in processing design information EXPLANATION: The comment analysis routines have detected an error in the text of a comment, such as an undefined keyword in a structured tag. Additional messages relating to the error are also displayed.
43. 1.49 - DESCOMNOLSE
SEVERITY: F MESSAGE TEXT: /DESIGN=COMMENTS requires installation of DEC Language Sensitive Editor EXPLANATION: To use /DESIGN=COMMENTS, the Language Sensitive Editor (part of DECset) needs to be installed on this system. Omit /DESIGN=COMMENTS, attempt the compilation on another system where the Language Sensitive Editor is installed, or install the Language Sensitive Editor and retry.
43. 1.50 - DESCOMSEVERR
SEVERITY: F MESSAGE TEXT: A serious error has occurred processing /DESIGN=COMMENTS EXPLANATION: The comment analysis routines have detected a severe error that prevents further comment analysis in the current compilation. Additional messages relating to the error are also displayed. The compilation is aborted.
43. 1.51 - DESIGNTOOOLD
SEVERITY: F MESSAGE TEXT: /DESIGN=COMMENTS processing routines are too old for the compiler EXPLANATION: The version of the comment analysis routines present on the system is not supported by this version of Compaq Fortran. Install a newer version of the Language Sensitive Editor to obtain the newer comment analysis routines.
43. 1.52 - DICTABORT
SEVERITY: F MESSAGE TEXT: DICTIONARY processing of CDD record description aborted EXPLANATION: The Compaq Fortran compiler is unable to process the Common Data Dictionary record description. See the accompanying messages for further information.
43. 1.53 - DIRSTRREQ
SEVERITY: I MESSAGE TEXT: Directive requires string constant, directive ignored EXPLANATION: This error only occurs with the use of the CDEC$ compiler directive statements: TITLE, SUBTITLE, and IDENT. String values for the TITLE, SUBTITLE, and IDENT directives cannot be more than 31 characters. Any other values, including PARAMETER statement constants that are defined to be strings, are invalid on these directives.
43. 1.54 - ENDOPTMIS
SEVERITY: W MESSAGE TEXT: No matching CDEC$ END OPTIONS for CDEC$ OPTIONS EXPLANATION: A CDEC$ OPTIONS directive must be terminated by CDEC$ END OPTIONS. USER ACTION: Make sure that each CDEC$ OPTIONS directive is properly terminated by a CDEC$ END OPTIONS directive.
43. 1.55 - ENTDUMVAR
SEVERITY: F MESSAGE TEXT: ENTRY dummy variable previously used in executable statement EXPLANATION: The dummy arguments of an ENTRY statement must not have been used previously in an executable statement in the same program unit.
43. 1.56 - EQVEXPCOM
SEVERITY: F MESSAGE TEXT: EQUIVALENCE statement incorrectly expands a common block EXPLANATION: A common block cannot be extended beyond its beginning by an EQUIVALENCE statement.
43. 1.57 - EQVSAVCOM
SEVERITY: E MESSAGE TEXT: EQUIVALENCE may not be used to put a SAVE variable into COMMON EXPLANATION: An EQUIVALENCE group was found which included a COMMON variable and a variable named in a SAVE statement. SAVE variables can not be placed in COMMON, although an entire COMMON block can be named in a SAVE statement.
43. 1.58 - ERRLIMEXC
SEVERITY: F MESSAGE TEXT: Error limit exceeded; compilation terminated EXPLANATION: The limit on the number of E or F level errors specified by the /ERROR_LIMIT qualifer was exceeded for this compilation unit. Compilation of this unit was terminated, but compilation continued for other units, if any.
43. 1.59 - EXCCHATRU
SEVERITY: E MESSAGE TEXT: Non-blank characters truncated in string constant EXPLANATION: A character constant or Hollerith constant was converted to a data type that was not large enough to contain all the significant characters.
43. 1.60 - EXCDIGTRU
SEVERITY: E MESSAGE TEXT: Non-zero digits truncated in constant EXPLANATION: A Hollerith, character literal or typeless constant was converted to a data type that was not large enough to contain all the significant digits.
43. 1.61 - EXCNAMDAT
SEVERITY: E MESSAGE TEXT: Number of names exceeds number of values in data initialization EXPLANATION: The number of constants specified in a DATA statement must match the number of variables or array elements to be initialized. When a mismatch occurs, any extra variables or array elements are not initialized.
43. 1.62 - EXCVALDAT
SEVERITY: E MESSAGE TEXT: Number of values exceeds number of names in data initialization EXPLANATION: The number of variables or array elements to be initialized must match the number of constants specified in data initialization. When a mismatch occurs, any extra constant values are ignored.
43. 1.63 - EXPSTAOVE
SEVERITY: F MESSAGE TEXT: Compiler expression stack overflow EXPLANATION: An expression was too complex or there were too many actual arguments in a subprogram reference. A maximum of 255 actual arguments can be compiled. You can subdivide a complex expression or reduce the number of arguments.
43. 1.64 - EXTARYUSE
SEVERITY: I
MESSAGE TEXT: Extension to FORTRAN-77: Nonstandard use of array
EXPLANATION: One of the following extensions was detected:
o An array was used as a FILE specification in an OPEN statement.
o The file name of an INQUIRE statement was a numeric scalar
reference or a numeric array name reference
43. 1.65 - EXTBADCONT
SEVERITY: I MESSAGE TEXT: Extension to FORTRAN-77: nonstandard continuation character EXPLANATION: A nonstandard character was used as a continuation indicator.
43. 1.66 - EXTCATDARG
SEVERITY: I MESSAGE TEXT: Extension to FORTRAN-77: Concatenation of dummy argument EXPLANATION: A character dummy argument appeared as an operand in a concatenation operation.
43. 1.67 - EXTCHAFOL
SEVERITY: E MESSAGE TEXT: Extra characters following a valid statement EXPLANATION: Superfluous text was found at the end of a syntactically correct statement. Check for typing or syntax errors.
43. 1.68 - EXTCHARREQ
SEVERITY: I MESSAGE TEXT: Extension to FORTRAN-77: Character required EXPLANATION: A character variable was initialized with a noncharacter value by means of a DATA statement.
43. 1.69 - EXTCHASOU
SEVERITY: W MESSAGE TEXT: Extra characters in source line were truncated EXPLANATION: A source line was read that was longer than the statement field width and /WARNINGS=TRUNCATED_SOURCE was specified. The source line was truncated to the statement field width; 72 or 132 characters, depending on the value of the /EXTEND_SOURCE command or OPTIONS statement qualifier in effect.
43. 1.70 - EXTCHRARG
SEVERITY: I MESSAGE TEXT: Extension to FORTRAN-77: CHARACTER*(*) argument used as function EXPLANATION: A formal argument used as a function was declared CHARACTER*(*). The FORTRAN-77 standard requires the length to be an integer constant.
43. 1.71 - EXTCOMPARNAM
SEVERITY: I MESSAGE TEXT: Extension to FORTRAN-77: COMMON block has same name as PARAMETER constant EXPLANATION: A COMMON blocks was declared to have the same name as a PARAMETER constant, a PARAMETER constant was declared to have the same name as a previously declared COMMON block.
43. 1.72 - EXTCONT19
SEVERITY: I MESSAGE TEXT: Extension to FORTRAN-77: more than 19 continuation lines EXPLANATION: More than 19 continuation lines were defined for the statement.
43. 1.73 - EXTDATACOM
SEVERITY: I
MESSAGE TEXT: Extension to FORTRAN-77: Nonstandard DATA
initialization
EXPLANATION: One of the following extensions occurred:
o An element in a blank common block was data initialized.
o An element of a named common block was data initialized outside
of the BLOCK DATA program unit.
43. 1.74 - EXTDATORD
SEVERITY: I MESSAGE TEXT: Extension to FORTRAN-77: DATA statement out of order EXPLANATION: A DATA statement occurred before a declaration statement. All DATA statements must occur after the declaration section of a program.
43. 1.75 - EXTILDOCNT
SEVERITY: I MESSAGE TEXT: Extension to FORTRAN-77: Negative implied-Do iteration count EXPLANATION: The iteration count of an implied DO was negative.
43. 1.76 - EXTINTRIN
SEVERITY: I MESSAGE TEXT: Extension to FORTRAN-77: nonstandard intrinsic function EXPLANATION: A nonstandard intrinsic function was used.
43. 1.77 - EXTLSTINF
SEVERITY: I MESSAGE TEXT: Extension to FORTRAN-77: nonstandard list directed internal EXPLANATION: A nonstandard list directed internal read or write statement was used.
43. 1.78 - EXTMISSUB
SEVERITY: I MESSAGE TEXT: Extension to FORTRAN-77: Missing array subscripts EXPLANATION: Only one subscript was used to reference a multi-dimensional array in an EQUIVALENCE statement.
43. 1.79 - EXTMIXCOM
SEVERITY: I MESSAGE TEXT: Extension to FORTRAN-77: Mixed numeric and character elements in COMMON EXPLANATION: A common block must not contain both numeric and character data.
43. 1.80 - EXTMIXEQV
SEVERITY: I MESSAGE TEXT: Extension to FORTRAN-77: Mixed numeric and character elements in EQUIVALENCE EXPLANATION: A numeric variable or numeric array element cannot be equivalenced to a character variable or character array element.
43. 1.81 - EXTOPERAT
SEVERITY: I
MESSAGE TEXT: Extension to FORTRAN-77: Nonstandard operation
EXPLANATION: One of the following operations was detected:
o A logical operand and a nonlogical operand were used in the
same operation.
o A real type expression and a complex type expression were used
in the same statement.
o A character operand and a noncharacter operand were used in the
same operation.
o A nonlogical expression was assigned to a logical variable.
o A noncharacter expression was assigned to a character variable.
o A character dummy argument appeared in a concatenation
operation and the result of the expression was not assigned to
a character variable.
o Logical operators were used with nonlogical operands.
o Arithmetic operators were used with nonnumeric operands.
43. 1.82 - EXTRECUSE
SEVERITY: I MESSAGE TEXT: Extension to FORTRAN-77: Nonstandard use of field reference EXPLANATION: A record reference (for example, record-name.field-name) was used in a program compiled with the /STANDARD=[SYNTAX|ALL] qualifier in the FORTRAN command.
43. 1.83 - EXTUSECCON
SEVERITY: I MESSAGE TEXT: Extension to FORTRAN-77: Nonstandard use of character constant EXPLANATION: A character constant was used in an assignment statement where a numeric value is required.
43. 1.84 - EXT_ARIREQ
SEVERITY: I MESSAGE TEXT: Extension to FORTRAN-77: Arithmetic expression required EXPLANATION: A logical expression was used in an arithmetic IF statement.
43. 1.85 - EXT_ASFARGNAM
SEVERITY: I MESSAGE TEXT: Extension to FORTRAN-77: Statement function argument name same as non-variable EXPLANATION: A statement function dummy argument had the same name as an entity other than a variable or a common block (for example, a PARAMETER constant).
43. 1.86 - EXT_COM
SEVERITY: I MESSAGE TEXT: Extension to FORTRAN-77: nonstandard comment EXPLANATION: FORTRAN-77 allows only the characters "C" and "*" to begin a comment line; "c", "D", "d", and "!" are extensions to FORTRAN-77.
43. 1.87 - EXT_CONST
SEVERITY: I
MESSAGE TEXT: Extension to FORTRAN-77: nonstandard constant
EXPLANATION: The following constant forms are extensions to
FORTRAN-77:
Form Example
--------- ------------------
Hollerith nH.....
Typeless 'nnnn'B, B'nnnn',
'nnnn'X, X'nnnn',
'nnnn'O, O'nnnn',
'nnnn'Z, Z'nnnn'
Binary B'nn'
Octal "oooo or Ooooo
Hexadecimal Znnnn
Radix-50 nR.....
Complex with
PARAMETER components
COMPLEX*16 (www.xxxDn, yyy.zzzDn)
REAL*16 yyy.zzzQn
43. 1.88 - EXT_DOEXPR
SEVERITY: I MESSAGE TEXT: Extension to FORTRAN-77: Nonstandard loop expression EXPLANATION: The upper bound expression, lower bound expression, or increment expression of a DO loop was not of type integer, real, or double precision.
43. 1.89 - EXT_FMT
SEVERITY: I
MESSAGE TEXT: Extension to FORTRAN-77: nonstandard FORMAT
statement item
EXPLANATION: The following format field descriptors are extensions
to FORTRAN-77:
$,O,Z All forms
A,L,I,F,E,G,D Default field width forms
P Without scale factor
43. 1.90 - EXT_INTREQ
SEVERITY: I MESSAGE TEXT: Extension to FORTRAN-77: Integer expression required EXPLANATION: One of the following items was not of type integer: o A logical unit number o The record specifier, REC=recspec o The arithmetic expression of a computed GOTO statement o The RETURN [I] o A subscript expression o Array dimension bounds o Character substring bounds expressions
43. 1.91 - EXT_INVINTARG
SEVERITY: I MESSAGE TEXT: Extension to FORTRAN-77: Nonstandard use of intrinsic function as actual argument EXPLANATION: The FORTRAN-77 standard does not permit the use of type conversion (INT, DBLE, etc.), lexical relationship (LGE, LGT, etc.), or minimum or maximum functions (MIN, MAX, etc.) as actual arguments.
43. 1.92 - EXT_KEY
SEVERITY: I MESSAGE TEXT: Extension to FORTRAN-77: nonstandard keyword EXPLANATION: A nonstandard keyword was used.
43. 1.93 - EXT_KEYCONF
SEVERITY: I
MESSAGE TEXT: Extension to FORTRAN-77: nonstandard combination of
keywords/values
EXPLANATION: A statement included a nonstandard combination of
keywords or keyword values, for example:
o In an OPEN statement, FILE= specified when STATUS='SCRATCH'
43. 1.94 - EXT_LEX
SEVERITY: I
MESSAGE TEXT: Extension to FORTRAN-77: nonstandard lexical item
EXPLANATION: One of the following nonstandard lexical items was
used:
o An alternate return specifier with an ampersand (&) in a CALL
statement
o The apostrophe (') form of record specifier in a direct access
I/O statement
o A variable format expression
43. 1.95 - EXT_LOGREQ
SEVERITY: I
MESSAGE TEXT: Extension to FORTRAN-77: Logical expression
required
EXPLANATION: One of the following syntax extensions was detected:
o A numeric expression was used in a logical IF statement.
o A numeric expression was used in a block IF statement.
o A value other than .TRUE. or .FALSE. was assigned to a
logical variable.
o A logical variable was initialized with a nonlogical value by
means of a DATA statement.
43. 1.96 - EXT_NAME
SEVERITY: I MESSAGE TEXT: Extension to FORTRAN-77: nonstandard name EXPLANATION: A name longer than six characters or containing a dollar sign ($) or an underscore (_) was used.
43. 1.97 - EXT_OPER
SEVERITY: I MESSAGE TEXT: Extension to FORTRAN-77: nonstandard operator EXPLANATION: The operators .XOR., %VAL, %REF, %DESCR, and %LOC are extensions to FORTRAN-77. The standard form of .XOR. is .NEQV. The % operators are extensions provided to allow access to non-Fortran parts of the VMS environment.
43. 1.98 - EXT_RETTYP
SEVERITY: I MESSAGE TEXT: Extension to FORTRAN-77: Nonstandard function return type EXPLANATION: One of the following conditions was detected: o The function was not declared with a standard data type. o The entry point was not declared with a standard data type.
43. 1.99 - EXT_SOURC
SEVERITY: I MESSAGE TEXT: Extension to FORTRAN-77: tab indentation or lowercase source EXPLANATION: The use of tab indention or lowercase letters in source code is an extension to FORTRAN-77.
43. 1.100 - EXT_STMT
SEVERITY: I MESSAGE TEXT: Extension to FORTRAN-77: nonstandard statement type EXPLANATION: A nonstandard statement type was used.
43. 1.101 - EXT_SYN
SEVERITY: I
MESSAGE TEXT: Extension to FORTRAN-77: nonstandard syntax
EXPLANATION: One of the following syntax extensions was specified:
o PARAMETER name = value
Error: Typeless syntax without parentheses
o type name/value/
Error: Data initialization in type declaration
o DATA (ch(exp:exp),v=e2)/values/
Error: Substring initialization with implied-DO in
DATA statement
o CHARACTER FUNCTION NAME*n
Error: Character function length after name
o INCLUDE '(module)'
Error: Library-based INCLUDE (only if /STANDARD=MIA)
o CALL name(arg2,,arg3)
Error: Null actual argument
o READ (...),iolist
Error: Comma between I/O control and element lists
o PARAMETER (name2=ABS(name1))
Error: Function use in PARAMETER
o e1 ** -e2
Error: Two consecutive operators
43. 1.102 - EXT_TYPE
SEVERITY: I
MESSAGE TEXT: Extension to FORTRAN-77; nonstandard data type
specification
EXPLANATION: The following DATA type specifications are extensions
to FORTRAN-77. The FORTRAN-77 equivalent is given where available.
This message is issued when these types are used in the IMPLICIT
statement or in a numeric type statement.
Extension Standard
--------- --------
BYTE -
LOGICAL*1 -
LOGICAL*2 LOGICAL (with /NOI4 specified only)
LOGICAL*4 LOGICAL
INTEGER*1 -
INTEGER*2 INTEGER (with /NOI4 specified only)
INTEGER*4 INTEGER
REAL*4 REAL
REAL*8 DOUBLE PRECISION
REAL*16 -
COMPLEX*8 COMPLEX
COMPLEX*16 -
DOUBLE COMPLEX -
43. 1.103 - FEANOTSUP
SEVERITY: E MESSAGE TEXT: Feature not supported on this platform EXPLANATION: Detected a language feature supported on other Compaq Fortran platforms that is not suported on this platform.
43. 1.104 - FEAUNSAXP
SEVERITY: W MESSAGE TEXT: Feature not supported on Alpha systems EXPLANATION: Detected a language feature supported on this platform that is not supported on Alpha systems.
43. 1.105 - FLDMISALN
SEVERITY: W MESSAGE TEXT: Record contains one or more misaligned fields EXPLANATION: One or more fields are not naturally aligned in a RECORD structure. If the record is or contains a record array, one or more of the array elements may not be naturally aligned. Specifying /NOALIGN or /ALIGN=RECORDS=PACKED, the default, causes Compaq Fortran to pack the fields within records instead of naturally aligning them. USER ACTION: Consider specifying the /ALIGN qualifier or rearrange fields so that they fall on natural boundaries.
43. 1.106 - FLDNAME
SEVERITY: F MESSAGE TEXT: Structure field is missing a field name EXPLANATION: Unnamed fields are not allowed. The effect of an unnamed field can be achieved by using %FILL in place of a field name in a typed data declaration.
43. 1.107 - FMTEXTCOM
SEVERITY: W MESSAGE TEXT: Extra comma in format list EXPLANATION: A format list contained an extra comma. Example: FORMAT(I4,)
43. 1.108 - FMTEXTNUM
SEVERITY: E MESSAGE TEXT: Extra number in format list EXPLANATION: A format list contained an extraneous number. Example: FORMAT (I4,3)
43. 1.109 - FMTINVCHA
SEVERITY: E MESSAGE TEXT: Format item contains meaningless character EXPLANATION: An invalid character or a syntax error was detected in a FORMAT statement.
43. 1.110 - FMTINVCON
SEVERITY: E MESSAGE TEXT: Constant in format item out of range EXPLANATION: A numeric value in a FORMAT statement exceeds the allowable range. For information about range limits, see the DEC Fortran Language Reference Manual.
43. 1.111 - FMTMISNUM
SEVERITY: E MESSAGE TEXT: Missing number in format list EXPLANATION: An expected number was missing from a format list. Example: FORMAT (F6.)
43. 1.112 - FMTMISSEP
SEVERITY: E MESSAGE TEXT: Missing separator between format items EXPLANATION: A required separator character was omitted between fields in a FORMAT statement.
43. 1.113 - FMTNEST
SEVERITY: E MESSAGE TEXT: Format groups nested too deeply EXPLANATION: Format groups cannot be nested beyond eight levels.
43. 1.114 - FMTPAREN
SEVERITY: E MESSAGE TEXT: Unbalanced parentheses in format list EXPLANATION: The number of right parentheses does not match the number of left parentheses.
43. 1.115 - FMTSIGN
SEVERITY: E MESSAGE TEXT: Format item cannot be signed EXPLANATION: A signed constant is valid only with the P format code.
43. 1.116 - FUNVALUND
SEVERITY: W MESSAGE TEXT: Function value undefined at end of routine EXPLANATION: A function did not have its return value defined at the end of the routine.
43. 1.117 - HOLCOURED
SEVERITY: E MESSAGE TEXT: Count of Hollerith or Radix-50 constant too large, reduced EXPLANATION: The value specified by the integer preceding the H or R was greater than the number of characters remaining in the source statement.
43. 1.118 - IDOINVOP
SEVERITY: F
MESSAGE TEXT: Invalid operation in implied-DO list
EXPLANATION: An invalid operation was attempted in an implied-DO
list in a DATA statement; for example, a function reference in the
subscript or substring expression of an array or character
substring reference.
Example:
DATA (A(SIN(REAL(I))), I=1,10) /101./
43. 1.119 - IDOINVPAR
SEVERITY: F MESSAGE TEXT: Invalid DO parameters in implied-DO list EXPLANATION: An invalid control parameter was detected in an implied-DO list in a DATA statement; for example, an increment of zero.
43. 1.120 - IDOINVREF
SEVERITY: F
MESSAGE TEXT: Invalid reference to name in implied-DO list
EXPLANATION: A control parameter expression in an implied-DO list
in a DATA statement contained a name that was not the name of a
control variable within the scope of any implied-DO list. Example:
DATA (A(J), J=1,10),(B(I), I=J,K) /1001./
Both J and K in the second implied-DO list are invalid names.
43. 1.121 - IDOSYNERR
SEVERITY: F MESSAGE TEXT: Syntax error in implied-DO list in data initialization EXPLANATION: Improper syntax was detected in an implied-DO list in data initialization; for example, improperly nested parentheses.
43. 1.122 - ILDIRSPEC
SEVERITY: I MESSAGE TEXT: Unrecognized directive ignored EXPLANATION: A directive with a valid Compaq Fortran prefix was encountered in the first 5 columns of a source code statement (such as a Compaq Fortran vector directive), but its presence in the context of the specified command qualifiers is inconsistent or the keyword following the prefix (such as CDEC$ or CPAR$) was not recognized.
43. 1.123 - ILDOPARCTL
SEVERITY: F MESSAGE TEXT: Illegal parallel DO-loop, control variable must be declared INTEGER EXPLANATION: Only integer control variables can be used with parallel DO loops.
43. 1.124 - ILDOPARDIR
SEVERITY: E MESSAGE TEXT: DO_PARALLEL directive must be followed by DO statement, directive ignored EXPLANATION: The first executable statement after a DO_PARALLEL compiler directive statement (CPAR$ DO_PARALLEL) must be a DO statement.
43. 1.125 - ILIDFDIR
SEVERITY: W MESSAGE TEXT: Loop directive must be followed by DO statement EXPLANATION: A CDEC$ directive that applies to DO loops was found but no DO loop was found within its range.
43. 1.126 - ILLBRANCH
SEVERITY: E MESSAGE TEXT: Illegal branch into or out of parallel DO-loop EXPLANATION: A branch into or out of a parallel DO loop is not allowed.
43. 1.127 - ILPARSTMT
SEVERITY: E MESSAGE TEXT: Statement not permitted inside parallel DO-loop EXPLANATION: I/O statements and RETURN, STOP, and PAUSE statements are not permitted inside a parallel DO-loop.
43. 1.128 - IMPDECLAR
SEVERITY: W MESSAGE TEXT: Use of implicit with declaration warnings EXPLANATION: An IMPLICIT statement was used in a program compiled with the /WARNINGS=DECLARATIONS qualifier on the FORTRAN command line.
43. 1.129 - IMPMULTYP
SEVERITY: E MESSAGE TEXT: Letter mentioned twice in IMPLICIT statement, last type used EXPLANATION: A letter was given an implicit data type more than once. The last data type given is used.
43. 1.130 - IMPNONE
SEVERITY: E
MESSAGE TEXT: Untyped name, must be explicitly typed
EXPLANATION: The displayed name was not defined in any data type
declaration statement, and an IMPLICIT NONE statement was
specified. Check that the name was not accidentally created by an
undetected syntax error. Example:
DO 10 I = 1.10
The apparent DO statement is really an assignment to the
accidentally created variable DO10I.
43. 1.131 - IMPSYNERR
SEVERITY: E MESSAGE TEXT: Syntax error in IMPLICIT statement EXPLANATION: Improper syntax was used in an IMPLICIT statement.
43. 1.132 - INCDONEST
SEVERITY: F
MESSAGE TEXT: DO or IF statement incorrectly nested
EXPLANATION: One of the following conditions occurred:
o A statement label specified in a DO statement was used
previously. Example:
10 I = I + 1
J = J + 1
DO 10 K=1,10
o A DO loop contains an incomplete DO loop or IF block.
Examples:
1. DO 10 I=1,10
J = J + 1
DO 20 K=1,10
J = J + K
10 CONTINUE
The start of the incomplete IF block can be a block IF, ELSE
IF, or ELSE statement.
2. DO 10 I=1,10
J = J + I
IF (J .GT. 20) THEN
J = J - 1
ELSE
J = J + 1
10 CONTINUE
END IF
43. 1.133 - INCFILNES
SEVERITY: F MESSAGE TEXT: INCLUDE files and/or DICTIONARY statements nested too deeply EXPLANATION: Up to 10 levels of nested INCLUDE files and DICTIONARY statements are permitted.
43. 1.134 - INCFUNTYP
SEVERITY: F
MESSAGE TEXT: Inconsistent function data types
EXPLANATION: The function name and entry points in a function
subprogram must be consistent within one of three groups of data
types:
Group 1: All numeric types except REAL*16 and COMPLEX*16
Group 2: REAL*16 and COMPLEX*16
Group 3: Character
Example:
CHARACTER*15 FUNCTION I
REAL*4 G
ENTRY G
43. 1.135 - INCLABUSE
SEVERITY: F
MESSAGE TEXT: Inconsistent usage of statement label
EXPLANATION: Labels of executable statements were confused with
labels of FORMAT statements or with labels of nonexecutable
statements. Example:
GO TO 10
10 FORMAT (I5)
43. 1.136 - INCLENMOD
SEVERITY: F
MESSAGE TEXT: Incorrect length modifier in declaration
EXPLANATION: An unacceptable length was specified in a data type
declaration. For example:
INTEGER PIPES*8
43. 1.137 - INCMODNAM
SEVERITY: F
MESSAGE TEXT: Module name not found in library
EXPLANATION: When an INCLUDE statement of the form INCLUDE
'(module)' is used, several text libraries are searched for the
specified module name. These are, in order:
1. Libraries specified on the FORTRAN command line
with the /LIBRARY qualifier
2. The library specified using the logical name
FORT$LIBRARY
3. The Compaq Fortran system text library,
SYS$LIBRARY:FORSYSDEF.
The INCMODNAM message is issued when the specified module name
cannot be found in any of the libraries. Note that one of the
causes of this search failure may be an open failure on one of the
libraries. If a "$LIBRARY/LIST" command shows the module to be
present in the library, check to ensure that the library itself can
be read by the compiler.
43. 1.138 - INCNOTSUP
SEVERITY: F MESSAGE TEXT: INCLUDE not supported for current source file device EXPLANATION: An INCLUDE statement was found while the current source device was not random-access, for example a tape drive or a terminal. The compiler requires that it be able to close and later reopen and reposition the source file before processing an INCLUDE statement.
43. 1.139 - INCOPEFAI
SEVERITY: F MESSAGE TEXT: Open failure on INCLUDE file EXPLANATION: The specified file could not be opened, possibly because of an incorrect file specification, nonexistent file, unmounted volume, or protection violation.
43. 1.140 - INCOPNFORT
SEVERITY: W MESSAGE TEXT: Unable to open text library defined by FORT$LIBRARY EXPLANATION: In an attempt to include a text library, the compiler was unable to open the text library defined by the logical name FORT$LIBRARY.
43. 1.141 - INCOPNSYSL
SEVERITY: W MESSAGE TEXT: Open error opening include file SYS$LIBRARY:FORSYSDEF.TLB EXPLANATION: In an attempt to include a module from Compaq Fortran's symbolic definition library (FORSYSDEF), the compiler was unable to locate the library. (FORSYSDEF contains Compaq Fortran source definitions for related groups of system symbols.)
43. 1.142 - INCSTAFUN
SEVERITY: W MESSAGE TEXT: Inconsistent statement function reference EXPLANATION: The actual arguments in a statement function reference did not agree in either order, number, or data type with the formal arguments declared.
43. 1.143 - INCSYNERR
SEVERITY: F MESSAGE TEXT: Syntax error in INCLUDE file specification EXPLANATION: The file-name string was not acceptable (invalid syntax, invalid qualifier, undefined device, and so on).
43. 1.144 - INQUNIT
SEVERITY: F MESSAGE TEXT: Missing or invalid use of UNIT or FILE specifier in INQUIRE statement EXPLANATION: An INQUIRE statement must have a UNIT specifier or a FILE specifier, but not both.
43. 1.145 - INSVIRMEM
SEVERITY: F MESSAGE TEXT: Insufficient virtual memory to complete compilation EXPLANATION: The compiler was not able to acquire sufficient virtual memory to complete the compilation. USER ACTION: Increase your process page file quota (AUTHORIZE quota PGFLQUO) and/or the system virtual page count limit (SYSGEN parameter VIRTUALPAGECNT), specify the /NOOPTIMIZE compiler command qualifier, or reduce the size or complexity of the compilation unit.
43. 1.146 - INTACTARG
SEVERITY: W MESSAGE TEXT: Intrinsic routine used as actual argument should be named in INTRINSIC statement EXPLANATION: An identifier which had been previously used as an intrinsic routine was used as an actual argument, but was not named in an INTRINSIC statement. The compiler assumed that the intrinsic routine of that name was intended. USER ACTION: If the identifier is intended to be a routine name, declare it in an EXTERNAL or INTRINSIC statement, as appropriate. This message can be suppressed with /WARNINGS=NOUSAGE.
43. 1.147 - INTFUNARG
SEVERITY: E MESSAGE TEXT: Arguments incompatible with intrinsic function, assumed EXTERNAL EXPLANATION: A function reference was made using an intrinsic function name, but the argument list does not agree in order, number, or type with the intrinsic function requirements. When this error occurs, the function is assumed to be supplied by you as an EXTERNAL function.
43. 1.148 - INTVALREQ
SEVERITY: F MESSAGE TEXT: Non-integer expression where integer value required EXPLANATION: An expression that must be of type integer was another data type.
43. 1.149 - INVACTARG
SEVERITY: E MESSAGE TEXT: Invalid use of intrinsic function name as actual argument EXPLANATION: A generic name of an intrinsic function was used as an actual argument.
43. 1.150 - INVASSVAR
SEVERITY: E MESSAGE TEXT: Invalid ASSOCIATEVARIABLE specification EXPLANATION: An ASSOCIATEVARIABLE specification in an OPEN or DEFINE FILE statement was a dummy argument or an array element.
43. 1.151 - INVCHASOU
SEVERITY: W MESSAGE TEXT: Invalid character treated as blank EXPLANATION: A nonprinting character was found in a source line and was replaced by a space (blank) character. The value of the last nonprinting character found in a source line appears within the message in the form [CHAR(nnn)], where nnn is the decimal value of the nonprinting character. For more information on valid nonprinting characters in source files, see your user manual.
43. 1.152 - INVCHAUSE
SEVERITY: E
MESSAGE TEXT: Invalid character used in constant
EXPLANATION: An invalid character was used in a constant. Valid
characters are:
Hexadecimal: 0 - 9, A - F, a - f
Octal: 0 - 7
Binary: 0 - 1
Radix-50: A - Z, 0 - 9, $, period, or space
For Radix-50, a space is substituted for the invalid character.
For hexadecimal and octal, the entire constant is set to zero.
43. 1.153 - INVCONST
SEVERITY: E MESSAGE TEXT: Arithmetic error while evaluating constant or constant expression EXPLANATION: The specified value of a constant was too large or too small to be represented.
43. 1.154 - INVCONSTR
SEVERITY: F
MESSAGE TEXT: Invalid control structure using ELSE IF, ELSE, or
END IF
EXPLANATION: The order of ELSE IF, ELSE, or END IF statements is
incorrect.
ELSE IF, ELSE, and END IF statements cannot stand alone. ELSE IF
and ELSE must be preceded by either a block IF statement or an ELSE
IF statement. END IF must be preceded by either a block IF, ELSE
IF, or ELSE statement. Examples:
1. DO 10 I=1,10
J = J + I
ELSE IF (J .LE. K) THEN
Error: ELSE IF preceded by a DO statement.
2. IF (J .LT. K) THEN
J = I + J
ELSE
J = I - J
ELSE IF (J .EQ. K) THEN
END IF
Error: ELSE IF preceded by an ELSE statement.
43. 1.155 - INVDEVSPE
SEVERITY: E MESSAGE TEXT: Invalid device specified, analysis data file not produced EXPLANATION: The file specified by the /ANALYSIS_DATA qualifier could not be written because it was not a random access file.
43. 1.156 - INVDOTERM
SEVERITY: W MESSAGE TEXT: Statement cannot terminate a DO loop EXPLANATION: The terminal statement of a DO loop cannot be a GO TO, arithmetic IF, block IF, RETURN, ELSE, ELSE IF, END IF, DO, or END statement.
43. 1.157 - INVDUMARG
SEVERITY: E MESSAGE TEXT: Dummy argument invalid in parallel memory directive EXPLANATION: Dummy arguments cannot be specified on a parallel memory directive.
43. 1.158 - INVENDKEY
SEVERITY: W MESSAGE TEXT: Invalid END= keyword, ignored EXPLANATION: The END keyword was used illegally in a WRITE, REWRITE, direct access READ, or keyed access READ statement.
43. 1.159 - INVENTRY
SEVERITY: E MESSAGE TEXT: ENTRY within DO loop or IF block, statement ignored EXPLANATION: An ENTRY statement is not allowed within the range of a DO loop or IF block.
43. 1.160 - INVEQVCOM
SEVERITY: F MESSAGE TEXT: Invalid equivalence of two variables in common EXPLANATION: Variables in common blocks cannot be equivalenced to each other.
43. 1.161 - INVFUNUSE
SEVERITY: F
MESSAGE TEXT: Invalid use of function name in CALL statement
EXPLANATION: A CALL statement referred to a subprogram name that
was used as a CHARACTER, REAL*16, or COMPLEX*16 function. Example:
IMPLICIT CHARACTER*10(C)
CSCAL = CFUNC(X)
CALL CFUNC(X)
43. 1.162 - INVINIVAR
SEVERITY: E MESSAGE TEXT: Invalid initialization of variable not in common EXPLANATION: An attempt was made in a BLOCK DATA subprogram to initialize a variable that was not in a common block.
43. 1.163 - INVINTFUN
SEVERITY: E MESSAGE TEXT: Name used in INTRINSIC statement is not an intrinsic function EXPLANATION: A function name which appeared in the INTRINSIC statement was not an intrinsic function.
43. 1.164 - INVIOSPEC
SEVERITY: F MESSAGE TEXT: Invalid I/O specification for this type of I/O statement EXPLANATION: A syntax error occurred in the portion of an I/O statement that precedes the I/O list. Examples: 1. TYPE (6), J 2. WRITE 100, J
43. 1.165 - INVKEYOPE
SEVERITY: F MESSAGE TEXT: Incorrect keyword in OPEN, CLOSE, or INQUIRE statement EXPLANATION: An OPEN, CLOSE, or INQUIRE statement contained an invalid keyword.
43. 1.166 - INVLEFSID
SEVERITY: F MESSAGE TEXT: Left side of assignment must be variable or array element EXPLANATION: The symbolic name to which the value of an expression is assigned must be a variable, array element, or character substring reference.
43. 1.167 - INVLEXEME
SEVERITY: F MESSAGE TEXT: Variable name, constant, or expression invalid in this context EXPLANATION: An entity was used incorrectly; for example, the name of a subprogram was used where an arithmetic expression was required.
43. 1.168 - INVLOGIF
SEVERITY: F MESSAGE TEXT: Statement cannot appear in logical IF statement EXPLANATION: A logical IF statement must not contain a DO statement or another logical IF, IF THEN, ELSE IF, ELSE, END IF, or END statement.
43. 1.169 - INVNMLELE
SEVERITY: F MESSAGE TEXT: Invalid namelist element EXPLANATION: An element other than a variable or array name appeared in a namelist declaration.
43. 1.170 - INVNUMSUB
SEVERITY: F MESSAGE TEXT: Number of subscripts does not match array declaration EXPLANATION: More or fewer dimensions than were declared for the array were referenced.
43. 1.171 - INVPERARG
SEVERITY: F
MESSAGE TEXT: Invalid argument to %VAL, %REF, %DESCR, or %LOC
EXPLANATION: The argument specified for one of the built-in
functions was not valid. Examples:
%VAL (3.5D0) Error: Argument cannot be REAL*8,
REAL*16, character, or complex.
%LOC (X+Y) Error: Argument must not be an expression.
43. 1.172 - INVPERUSE
SEVERITY: E
MESSAGE TEXT: %VAL, %REF, or %DESCR used in invalid context
EXPLANATION: The argument list built-in functions (%VAL, %REF, and
%DESCR) cannot be used outside an actual argument list. Example:
X = %REF(Y)
43. 1.173 - INVQUAL
SEVERITY: I MESSAGE TEXT: Invalid qualifier or qualifier value in OPTIONS statement EXPLANATION: An invalid qualifier or qualifier value was specified in the OPTIONS statement. When this error occurs, the qualifier is ignored.
43. 1.174 - INVRECUSE
SEVERITY: F
MESSAGE TEXT: Invalid use of record or array name
EXPLANATION: A statement in the program violated one of the
following rules:
o An aggregate cannot be assigned to a nonaggregate or to an
aggregate with a structure that is not the same.
o An array name reference cannot be qualified.
o Aggregate references cannot be used in I/O lists of formatted
I/O statements.
o An aggregate or array cannot be passed as an expression in an
actual argument list.
43. 1.175 - INVREPCOU
SEVERITY: E MESSAGE TEXT: Invalid repeat count in data initialization, count ignored EXPLANATION: The repeat count in a data initialization was not an unsigned, nonzero integer constant. When this error occurs, the count is ignored.
43. 1.176 - INVSBSREF
SEVERITY: E
MESSAGE TEXT: Substring reference used in invalid context
EXPLANATION: A substring reference was made to a variable or array
that is not of type CHARACTER. Example:
REAL X(10)
Y = X(J:K)
43. 1.177 - INVSTALAB
SEVERITY: W MESSAGE TEXT: Invalid statement label ignored EXPLANATION: An improperly formed statement label (namely, a label containing letters) appeared in columns 1 to 5 of an initial line. When this error occurs, the statement label is ignored.
43. 1.178 - INVSUBREF
SEVERITY: F MESSAGE TEXT: Subscripted reference to non-array variable EXPLANATION: A variable that is not defined as an array cannot appear with subscripts.
43. 1.179 - INVTYPUSE
SEVERITY: F MESSAGE TEXT: Name previously used with conflicting data type EXPLANATION: A data type was assigned to a name that had already been used in a context that required a different data type.
43. 1.180 - IODUPKEY
SEVERITY: F MESSAGE TEXT: Duplicated keyword in I/O statement EXPLANATION: Each keyword subparameter in an I/O statement or auxiliary I/O statement can be specified only once.
43. 1.181 - IOINVFMT
SEVERITY: F
MESSAGE TEXT: Format specifier in error
EXPLANATION: The format specifier in an I/O statement is invalid.
It must be one of the following:
o The label of a FORMAT statement.
o An asterisk (*) in a list-directed I/O statement.
o A run-time format specifier: a variable, array element, or
character substring reference.
o An integer variable that was assigned a FORMAT label by an
ASSIGN statement.
43. 1.182 - IOINVKEY
SEVERITY: F MESSAGE TEXT: Invalid keyword for this type of I/O statement EXPLANATION: An I/O statement contained a keyword that cannot be used with that type of I/O statement.
43. 1.183 - IOINVLIST
SEVERITY: F MESSAGE TEXT: Invalid I/O list element for input statement EXPLANATION: An input statement I/O list contained an invalid element, such as an expression or a constant.
43. 1.184 - IOSYNERR
SEVERITY: F MESSAGE TEXT: Syntax error in I/O list EXPLANATION: Improper syntax was detected in an I/O list.
43. 1.185 - LABASSIGN
SEVERITY: F MESSAGE TEXT: Label in ASSIGN statement exceeds INTEGER*2 range EXPLANATION: A label whose value is assigned to an INTEGER*2 variable by an ASSIGN statement must not be separated by more than 32K bytes from the beginning of the code for the program unit.
43. 1.186 - LENCHAFUN
SEVERITY: E
MESSAGE TEXT: Length specified must match CHARACTER FUNCTION
declaration
EXPLANATION: The length specifications for all ENTRY names in a
character function subprogram must be the same. Example:
CHARACTER*15 FUNCTION F
CHARACTER*20 G
ENTRY G
43. 1.187 - LOGVALREQ
SEVERITY: F MESSAGE TEXT: Non-logical expression where logical value required EXPLANATION: An expression that must be of type LOGICAL was of another data type.
43. 1.188 - LOG4LCKREQ
SEVERITY: E MESSAGE TEXT: Lock variable must be declared LOGICAL*4 EXPLANATION: The lock entity used in a LOCKON or LOCKOFF directive must be declared to be LOGICAL*4.
43. 1.189 - LOWBOUGRE
SEVERITY: E MESSAGE TEXT: Lower bound greater than upper bound in array declaration EXPLANATION: The upper bound of a dimension declarator must be equal to or greater than the lower bound.
43. 1.190 - LSEDIAGS
SEVERITY: I MESSAGE TEXT: Additional diagnostics written to LSE diagnostics file EXPLANATION: Additional data dependence diagnostics were written to the DEC Language-Sensitive Editor diagnostics file and can be reviewed in the editor.
43. 1.191 - MINDIGITS
SEVERITY: I MESSAGE TEXT: CDD description specifies precision less than allowed for data type. Minimum precision is supplied. EXPLANATION: Some Common Data Dictionary data types specified a number of digits that is incompatible with Compaq Fortran data types. When this error occurs, the Compaq Fortran compiler expands the data type to conform to a Compaq Fortran data type.
43. 1.192 - MINOCCURS
SEVERITY: I MESSAGE TEXT: CDD description contains Minimum Occurs attribute (ignored) EXPLANATION: Compaq Fortran does not support the Common Data Dictionary Minimum Occurs attribute.
43. 1.193 - MISSAPOS
SEVERITY: E MESSAGE TEXT: Missing apostrophe in character constant EXPLANATION: A character constant must be enclosed by apostrophes.
43. 1.194 - MISSCOM
SEVERITY: F MESSAGE TEXT: Missing common block name EXPLANATION: A common block name was omitted or specified improperly on a SHARED directive.
43. 1.195 - MISSCONST
SEVERITY: F MESSAGE TEXT: Missing constant EXPLANATION: A required constant was not found.
43. 1.196 - MISSDEL
SEVERITY: F
MESSAGE TEXT: Missing operator or delimiter symbol
EXPLANATION: Two terms of an expression were not separated by an
operator, or a punctuation mark (such as a comma) was omitted.
Examples:
CIRCUM = 3.14 DIAM
IF (I 10,20,30
43. 1.197 - MISSEND
SEVERITY: E MESSAGE TEXT: Missing END statement, END is assumed EXPLANATION: An END statement was missing at the end of the last input file. When this error occurs, an END statement is inserted.
43. 1.198 - MISSEXPO
SEVERITY: E MESSAGE TEXT: Missing exponent after E, D, or Q EXPLANATION: A floating-point constant was specified in E, D, or Q notation, but the exponent was omitted.
43. 1.199 - MISSKEY
SEVERITY: F MESSAGE TEXT: Missing keyword EXPLANATION: A required keyword, such as TO, was omitted from a statement such as ASSIGN 10 TO I.
43. 1.200 - MISSLABEL
SEVERITY: F MESSAGE TEXT: Missing statement label EXPLANATION: A required statement label reference was omitted.
43. 1.201 - MISSNAME
SEVERITY: F MESSAGE TEXT: Missing variable or subprogram name EXPLANATION: A required variable name or subprogram name was not found.
43. 1.202 - MISSUNIT
SEVERITY: F MESSAGE TEXT: Unit specifier keyword missing in I/O statement EXPLANATION: An I/O statement must include a unit specifier subparameter.
43. 1.203 - MISSVAR
SEVERITY: F
MESSAGE TEXT: Missing variable or constant
EXPLANATION: An expression, or a term of an expression, was
omitted. Examples:
WRITE ( )
DIST = *TIME
43. 1.204 - MISSVARCOM
SEVERITY: E MESSAGE TEXT: Missing variable or common name EXPLANATION: A name of a variable or a common block that is required by a compiler directive statement or a VOLATILE statement was omitted.
43. 1.205 - MULDECNAM
SEVERITY: F MESSAGE TEXT: Multiple declaration of name EXPLANATION: A name appeared in two or more inconsistent declaration statements or a dummy argument was specified in an EQUIVALENCE statement.
43. 1.206 - MULDECTYP
SEVERITY: E MESSAGE TEXT: Multiple declaration of data type for variable, first type used EXPLANATION: A variable appeared in more than one data type declaration statement. When this error occurs, the first type declaration is used.
43. 1.207 - MULDEFLAB
SEVERITY: E MESSAGE TEXT: Multiple definition of statement label, second ignored EXPLANATION: The same label appeared on more than one statement. When this error occurs, the first occurrence of the label is used.
43. 1.208 - MULFLDNAM
SEVERITY: F MESSAGE TEXT: Multiply defined field name EXPLANATION: Each field name within the same level of a given structure declaration must be unique.
43. 1.209 - MULSPEPAR
SEVERITY: E MESSAGE TEXT: Multiple specification of parallel memory attributes, first specification used EXPLANATION: A variable, array, record, or COMMON block was a given memory attributes (shared and private or context-shared and private) in a parallel directive. When this error occurs, the first attribute specified is the one that is used.
43. 1.210 - MULSTRNAM
SEVERITY: F MESSAGE TEXT: Multiply defined STRUCTURE name EXPLANATION: A STRUCTURE name must be unique among STRUCTURE names.
43. 1.211 - NAMTOOLON
SEVERITY: W MESSAGE TEXT: Name longer than 31 characters EXPLANATION: A symbolic name cannot exceed 31 characters. When this error occurs, the symbolic name is truncated to 31 characters.
43. 1.212 - NESTPARDO
SEVERITY: E MESSAGE TEXT: Nested parallel DO-loops not permitted, directive ignored EXPLANATION: A parallel DO-loop directive (CPAR$ DO_PARALLEL) was detected within a DO-loop that was already marked as parallel. Nested parallel DO-loop directives are not supported.
43. 1.213 - NMLIOLIST
SEVERITY: E MESSAGE TEXT: I/O list not permitted with namelist I/O EXPLANATION: An I/O statement with a namelist specifier incorrectly contained an I/O list.
43. 1.214 - NODEPCOMMN
SEVERITY: I MESSAGE TEXT: Dependence analysis inhibited due to call in DO-loop and COMMON loop control variable EXPLANATION: Dependence analysis is not performed on DO-loops that have a control variable specified within a COMMON block and a reference to an external routine. The analysis is not done because of the potential for changing the control variable in the external routine.
43. 1.215 - NODEPDEEP
SEVERITY: I MESSAGE TEXT: Dependence analysis inhibited due to more than 7 loops nested inside DO-loop EXPLANATION: Dependence analysis is not performed on DO-loops that have more than seven levels of nesting.
43. 1.216 - NODEPEQUIV
SEVERITY: I MESSAGE TEXT: Dependence analysis inhibited due to EQUIVALENCEd loop control variable EXPLANATION: Dependence analysis is not performed on DO-loops that have a control variable that is also specified in an EQUIVALENCE statement.
43. 1.217 - NODEPFLOW
SEVERITY: I MESSAGE TEXT: Dependence analysis inhibited due to transfer into or out of DO-loop EXPLANATION: Dependence analysis is not performed on DO-loops that contain transfers into or out of the loop. A STOP or RETURN is considered as a transfer out of a DO-loop.
43. 1.218 - NODEPINT4
SEVERITY: I MESSAGE TEXT: Dependence analysis inhibited due to non-integer control variable EXPLANATION: Dependence analysis is not performed on DO-loops that have a non-integer control variable. (Note - INTEGER*2 is now allowed.)
43. 1.219 - NODEPNEST
SEVERITY: I MESSAGE TEXT: Dependence analysis inhibited due to inhibitor in loop nested inside DO-loop EXPLANATION: Dependence analysis is not performed on DO-loops that contain a nested DO-loop with inhibitors.
43. 1.220 - NODEPOVLP
SEVERITY: I MESSAGE TEXT: Dependence analysis inhibited due to potential overlap dummy arguments and common variables in DO-loop EXPLANATION: Dependence analysis is not performed on DO-loops that contain references and stores into dummy arguments and variables in a common block. The potential for dummy arguments and variables in common blocks being aliased is the reason for this inhibitor. This error is partially controlled by the setting of the /ASSUME=[NO]DUMMY_ALIASES qualifier.
43. 1.221 - NODEPPAR
SEVERITY: I MESSAGE TEXT: Dependence analysis inhibited due to parallel loop nested inside DO-loop EXPLANATION: Dependence analysis is not performed on DO-loops that contain a nested parallel DO-loop that was established by a compiler directive statement (directed decomposition).
43. 1.222 - NODEPSTMT
SEVERITY: I
MESSAGE TEXT: Dependence analysis inhibited due to use of
inhibitor statement inside DO-loop
EXPLANATION: Dependence analysis is not performed on DO-loops that
contain any of the following statements:
o An assigned GOTO
o A computed GOTO
o A character function invocation
o A LOCKON or LOCKOFF directive
o A format containing a variable format expression was referenced
in an I/O statement within the DO-loop
43. 1.223 - NODEPVOLAT
SEVERITY: I MESSAGE TEXT: Dependence analysis inhibited due to volatile control variable EXPLANATION: Dependence analysis is not performed on DO-loops that have a control variable that is declared volatile.
43. 1.224 - NODFLOAT
SEVERITY: W MESSAGE TEXT: CDD description specifies the D_floating data type. The data cannot be represented when compiling /G_FLOAT. EXPLANATION: A D_floating data type was specified when compiling with the /G_FLOATING qualifier. Ignore the warning message or recompile the program using the /NOG_FLOATING qualifier.
43. 1.225 - NOGFLOAT
SEVERITY: W MESSAGE TEXT: CDD description specifies G_floating data type. The data cannot be represented when compiling /NOG_FLOAT. EXPLANATION: A G_floating data type was specified when compiling with the /NOG_FLOATING qualifier. Ignore the warning message or recompile the program using the /G_FLOAT qualifier.
43. 1.226 - NONCONSUB
SEVERITY: F MESSAGE TEXT: Nonconstant subscript where constant required EXPLANATION: Subscript and substring expressions used in DATA and EQUIVALENCE statements must be constants.
43. 1.227 - NOPATH
SEVERITY: W
MESSAGE TEXT: No path to this statement
EXPLANATION: Program control cannot reach this statement. When
this error occurs, the statement is deleted. Example:
10 I = I + 1
GO TO 10
STOP
43. 1.228 - NOPPARVEC
SEVERITY: W MESSAGE TEXT: /NOOPTIMIZE conflicts /PARALLEL=AUTOMATIC or /VECTOR EXPLANATION: When you specify /PARALLEL=AUTOMATIC or /VECTOR, you must omit /NOOPTIMIZE.
43. 1.229 - NOSOUFILE
SEVERITY: F MESSAGE TEXT: No source file specified EXPLANATION: A command line was entered that specified only library file names and no source files to compile.
43. 1.230 - NOTINLINED
SEVERITY: I MESSAGE TEXT: Intrinsic reference was not expanded inline EXPLANATION: The reference to a BLAS intrinsic routine could not be expanded into inline code.
43. 1.231 - NOVECACCU
SEVERITY: I MESSAGE TEXT: Vectorization inhibition: Qualifier /ASSUME=ACCURACY prevents recurrence vectorization EXPLANATION: Vectorization is not performed. The /ASSUME=ACCURACY_SENSITIVE option prevents recurrence vectorization.
43. 1.232 - NOVECALIGN
SEVERITY: I MESSAGE TEXT: Vectorization inhibition: Misaligned array EXPLANATION: Vectorization is not performed. Data for vector instructions must be aligned on natural boundaries, based on the data type. An array is aligned on natural boundaries if all its elements are so aligned.
43. 1.233 - NOVECDTARR
SEVERITY: I MESSAGE TEXT: Vectorization inhibition: Data type not supported for array EXPLANATION: Vectorization is not performed because the data type is not supported for the array.
43. 1.234 - NOVECDTIND
SEVERITY: I MESSAGE TEXT: Vectorization inhibition: Use of unsupported data type in array index EXPLANATION: Vectorization is not performed because an unsupported data type is used in the array index.
43. 1.235 - NOVECSUBP
SEVERITY: I MESSAGE TEXT: Vectorization inhibition: Reference to subprogram EXPLANATION: Vectorization is not performed for data that can be modified in the subprogram.
43. 1.236 - NOVECVOLARR
SEVERITY: I MESSAGE TEXT: Vectorization inhibition: Use of volatile array EXPLANATION: Vectorization is not performed. Volatile arrays have dependences the compiler is unaware of; thus, they cannot be vectorized.
43. 1.237 - NOVECVOLIND
SEVERITY: I MESSAGE TEXT: Vectorization inhibition: Use of volatile array index EXPLANATION: Vectorization is not performed. The compiler cannot identify all dependences for volatile array indexes; thus, they cannot be vectorized.
43. 1.238 - OPEDOLOOP
SEVERITY: F
MESSAGE TEXT: Unclosed DO loop or IF block
EXPLANATION: The terminal statement of a DO loop or the END IF
statement of an IF block was not found. Example:
DO 20 I=1,10
X = Y
END
43. 1.239 - OPENIN
SEVERITY: F MESSAGE TEXT: Error opening "file-spec" as input EXPLANATION: Unable to open the file "file-spec".
43. 1.240 - OPENOTPER
SEVERITY: F MESSAGE TEXT: Operation not permissible on these data types EXPLANATION: An invalid operation was specified, such as an .AND. of two real variables.
43. 1.241 - OPENOUT
SEVERITY: F MESSAGE TEXT: Error opening "file-spec" as output EXPLANATION: Unable to open the file "file-spec".
43. 1.242 - OPTLV4CHK
SEVERITY: W MESSAGE TEXT: /OPTIMIZE=LEVEL=4 conflicts with /CHECK=BOUNDS; /OPTIMIZE=LEVEL=4 ignored EXPLANATION: When you specify /CHECK=BOUNDS, you cannot use /OPTIMIZE=LEVEL=4. A lower level of optimization has been used.
43. 1.243 - OPTMISSING
SEVERITY: W MESSAGE TEXT: No matching CDEC$ OPTIONS for CDEC$ END OPTIONS EXPLANATION: A CDEC$ END OPTIONS directive terminates a CDEC$ OPTIONS section. USER ACTION: Remove extraneous CDEC$ END OPTIONS directives or add CDEC$ OPTIONS directives as appropriate.
43. 1.244 - PARCHKCON
SEVERITY: W MESSAGE TEXT: /PARALLEL=AUTOMATIC conflicts with /CHECK=BOUNDS EXPLANATION: When you specify /CHECK=BOUNDS, you cannot use /PARALLEL=AUTOMATIC. /PARALLEL=NOAUTOMATIC was used.
43. 1.245 - PLACEEOL
SEVERITY: F MESSAGE TEXT: Placeholder not terminated before end of line EXPLANATION: The closing delimiter of a placeholder was not found before the end of the line.
43. 1.246 - PLACENODESIGN
SEVERITY: E MESSAGE TEXT: Placeholder not valid without /DESIGN=PLACEHOLDERS EXPLANATION: A placeholder was found but /DESIGN=PLACEHOLDERS was not specified on the compile command line.
43. 1.247 - PLACENODOT
SEVERITY: E MESSAGE TEXT: Repetition of pseudocode placeholder not allowed EXPLANATION: A pseudocode placeholder was found with three dots after it, indicating a list placeholder, which is not supported.
43. 1.248 - PLACENOOBJ
SEVERITY: I MESSAGE TEXT: Placeholders detected - no object code generated EXPLANATION: One or more placeholders were found in the current compilation unit and so no object code was generated for that unit.
43. 1.249 - PLACENOTVAL
SEVERITY: E MESSAGE TEXT: Placeholder not valid in this context EXPLANATION: A placeholder was found in a context that is not supported.
43. 1.250 - PROSTOREQ
SEVERITY: F MESSAGE TEXT: Program storage requirements exceed addressable memory EXPLANATION: The storage space allocated to the variables and arrays of the program unit exceeded the addressing range of the machine.
43. 1.251 - PRVCTLVAR
SEVERITY: I MESSAGE TEXT: Control variable for parallel loop defaulting to PRIVATE EXPLANATION: The control variable for a parallel DO loop was not explicitly declared private.
43. 1.252 - PRVSYMIL
SEVERITY: E MESSAGE TEXT: PRIVATE symbol invalid in routine without parallel DO-loop EXPLANATION: Symbols declared within a routine that does not contain a parallel DO loop cannot be listed in a PRIVATE directive.
43. 1.253 - READERR
SEVERITY: F MESSAGE TEXT: Error reading "file-spec" EXPLANATION: Unable to read from file "file-spec".
43. 1.254 - RECPARCON
SEVERITY: W MESSAGE TEXT: /RECURSIVE conflicts with /PARALLEL; /RECURSIVE ignored EXPLANATION: If you specify /PARALLEL, you must omit /RECURSIVE. Compilation uses /PARALLEL but ignores /RECURSIVE.
43. 1.255 - REDCONMAR
SEVERITY: W MESSAGE TEXT: Redundant continuation mark ignored EXPLANATION: A continuation mark was used where an initial line is required. When this error occurs, the continuation mark is ignored.
43. 1.256 - REFERENCE
SEVERITY: I MESSAGE TEXT: CDD description contains Reference attribute (ignored) EXPLANATION: Fortran does not support the CDD Reference attribute.
43. 1.257 - ROUREFREC
SEVERITY: F MESSAGE TEXT: Routine referenced recursively; /RECURSIVE required EXPLANATION: A subroutine, function or entry name was referenced recursively in the same program unit, but the /RECURSIVE command or OPTIONS statement qualifier was not specified.
43. 1.258 - ROWMAJOR
SEVERITY: I MESSAGE TEXT: Bounds reversed for CDD member row-major array EXPLANATION: A row-major multi-dimensioned array was found in a CDD record. The bounds were reversed to allow for Fortran column-major array addressing.
43. 1.259 - SAVPRICONF
SEVERITY: E MESSAGE TEXT: PRIVATE variable or common block must not be declared SAVE EXPLANATION: Symbols cannot be declared in both a SAVE statement and a PRIVATE directive or common block.
43. 1.260 - SHRCTLVAR
SEVERITY: E MESSAGE TEXT: Control variable for parallel DO-loops must be declared PRIVATE EXPLANATION: The control variable for a parallel DO-loop was explicitly declared SHARED. Control variables for parallel DO-loops must be explicitly declared PRIVATE.
43. 1.261 - SHRNAMLON
SEVERITY: E MESSAGE TEXT: Shared COMMON name too long, limited to 26 characters EXPLANATION: The maximum length of a COMMON block name specified in a SHARED compiler directive statement is 26 characters.
43. 1.262 - SOURCETYPE
SEVERITY: I MESSAGE TEXT: CDD description contains Source Type attribute (ignored) EXPLANATION: Compaq Fortran does not support the CDD Source Type attribute.
43. 1.263 - STAENDSTR
SEVERITY: F MESSAGE TEXT: Statement not allowed within structure; structure definition closed EXPLANATION: A statement not allowed in a structure declaration block was encountered. When this error occurs, the compiler assumes that you omitted one or more END STRUCTURE statements.
43. 1.264 - STAINVSTR
SEVERITY: E MESSAGE TEXT: Statement not allowed within structure definition; statement ignored EXPLANATION: A statement not allowed in a structure declaration block was encountered. Structure declaration blocks can only include the following statements: typed data declaration statements, RECORD statements, UNION/END UNION statements, MAP/END MAP statements, and STRUCTURE/END STRUCTURE statements.
43. 1.265 - STANOTVAL
SEVERITY: E MESSAGE TEXT: Statement not valid in this program unit, statement ignored EXPLANATION: A program unit contained a statement that is not allowed; for example, a BLOCK DATA subprogram containing an executable statement.
43. 1.266 - STAOUTORD
SEVERITY: E MESSAGE TEXT: Statement out of order, statement ignored EXPLANATION: A statement was used in a place where it does not belong. When this error occurs, the statement is ignored.
43. 1.267 - STATOOCOM
SEVERITY: F MESSAGE TEXT: Statement too complex EXPLANATION: A statement was too complex to be compiled. It must be subdivided into two or more statements.
43. 1.268 - STRCONTRU
SEVERITY: E MESSAGE TEXT: String constant truncated to maximum length EXPLANATION: A character constant or Hollerith constant can contain up to 2000 characters. A Radix-50 constant can contain up to 12 characters.
43. 1.269 - STRDEPTH
SEVERITY: F MESSAGE TEXT: STRUCTUREs/UNIONs/MAPs nested too deeply EXPLANATION: The combined nesting level limit for structures, unions, and maps is 20 levels.
43. 1.270 - STREMPTY
SEVERITY: I MESSAGE TEXT: Structure is empty EXPLANATION: A STRUCTURE declaration contains no fields. USER ACTION: This informational message may indicate an unintended coding error. If so, correct the problem.
43. 1.271 - STRNAME
SEVERITY: E MESSAGE TEXT: Outer level structure is missing a structure name EXPLANATION: An outer level STRUCTURE statement must have a structure name in order for a RECORD statement to be able to reference the structure declaration.
43. 1.272 - STRNOTDEF
SEVERITY: F MESSAGE TEXT: Structure name in RECORD statement not defined EXPLANATION: Either a RECORD statement did not contain a structure name enclosed within slashes or the structure name contained in a RECORD statement was not defined in a structure declaration.
43. 1.273 - SUBEXPVAL
SEVERITY: E MESSAGE TEXT: Subscript or substring expression value out of bounds EXPLANATION: A reference was made to either an array element beyond the specified dimensions or a character substring outside the specified bounds.
43. 1.274 - SUBNOTALL
SEVERITY: F MESSAGE TEXT: Subqualifier not allowed with negated qualifier EXPLANATION: A negated qualifier specified on the command line also specified subqualifier values. For example: /NOCHECK=UNDERFLOW
43. 1.275 - TAGVARIAB
SEVERITY: I MESSAGE TEXT: CDD description contains Tag Variable attribute (ignored) EXPLANATION: Compaq Fortran does not support the Common Data Dictionary Tag Variable attribute.
43. 1.276 - TOOMANCOM
SEVERITY: F MESSAGE TEXT: Too many named common blocks EXPLANATION: Compaq Fortran allows a maximun of 508 named common blocks. You must reduce the number of named common blocks.
43. 1.277 - TOOMANCON
SEVERITY: E MESSAGE TEXT: Too many continuation lines, remainder ignored EXPLANATION: Up to 99 continuation lines are permitted.
43. 1.278 - TOOMANDIM
SEVERITY: E MESSAGE TEXT: More than 7 dimensions specified, remainder ignored EXPLANATION: An array cannot have more than seven dimensions.
43. 1.279 - TOOMNYOPT
SEVERITY: W
MESSAGE TEXT: CDEC$ OPTIONS directives nested too deeply -
this one ignored
EXPLANATION: CDEC$ OPTIONS directives cannot be nested beyond 100
levels.
USER ACTION: Modify source so that CDEC$ OPTIONS nesting depth
does not exceed 100.
43. 1.280 - TOOMANYDO
SEVERITY: F MESSAGE TEXT: DO and IF statements nested too deeply EXPLANATION: DO loops and block IF statements cannot be nested beyond 128 levels.
43. 1.281 - UNDARR
SEVERITY: F MESSAGE TEXT: Undimensioned array or statement function definition out of order EXPLANATION: Either a statement function definition was found among executable statements or an assignment statement involving an undimensioned array was found.
43. 1.282 - UNDSTALAB
SEVERITY: F MESSAGE TEXT: Undefined statement label EXPLANATION: A reference was made to a statement label that is not defined in the program unit.
43. 1.283 - UNRECSTMT
SEVERITY: F MESSAGE TEXT: Unrecognized statement EXPLANATION: The statement encountered was not recognized as valid.
43. 1.284 - UNSUPPTYPE
SEVERITY: I MESSAGE TEXT: CDD description specifies an unsupported data type EXPLANATION: The Common Data Dictionary description for a structure item attempted to use a data type that is not supported by Compaq Fortran. The Compaq Fortran compiler makes the data type accessible by declaring it as an inner structure containing a single unnamed field (%FILL field) that is a LOGICAL*1 array with an appropriate dimension. Change the data type to one that is supported by Compaq Fortran or use the Compaq Fortran built-in functions to manipulate the contents of the field.
43. 1.285 - USEBEFDEF
SEVERITY: I
MESSAGE TEXT: Use of variable before definition; name in SAVE
statement if appropriate
EXPLANATION: A variable in a subprogram was used before its
value was defined. This may have been intentional, with an
assumption of implicit SAVE semantics, but may also have been
a programming error. This message can be suppressed with
/WARNINGS=NOUNINITIALIZED.
USER ACTION: If intentional, name the variable in a SAVE
statement and make sure that it is properly initialized.
Initialization to zero is not guaranteed on all implementations.
43. 1.286 - USEUNIVAR
SEVERITY: W MESSAGE TEXT: Use of initialized variable EXPLANATION: A variable was used before it was initialized. Initialize the variable before using it. This message can be suppressed with /WARNINGS=NOUNINITIALIZED.
43. 1.287 - VARINCEQV
SEVERITY: F
MESSAGE TEXT: Variable inconsistently equivalenced to itself
EXPLANATION: EQUIVALENCE statements specified inconsistent
relationships between variables or array elements. Example:
EQUIVALENCE (A(1), A(2))
43. 1.288 - VARNOTASS
SEVERITY: E MESSAGE TEXT: Variable not assigned label by ASSIGN statement EXPLANATION: A variable was found in a context that required an assigned label (such as in an assigned GOTO statement or as the format specifier of an I/O statement), but no ASSIGN statement was found that assigned a label to that variable. This error commonly occurs if you use an arithmetic assignment statement instead of the ASSIGN statement. If the program executes, the result is unpredictable.
43. 1.289 - VARUNUSED
SEVERITY: I MESSAGE TEXT: Variable was declared but not used EXPLANATION: The specified variable was declared but never used.
43. 1.290 - VAXELNUNS
SEVERITY: W MESSAGE TEXT: This feature is unsupported on VAXELN EXPLANATION: The specified Compaq Fortran feature is not supported on a VAXELN system.
43. 1.291 - VECCHKCON
SEVERITY: W MESSAGE TEXT: /VECTOR conflicts with /CHECK=BOUNDS; /VECTOR ignored EXPLANATION: When you specify /CHECK=BOUNDS, you cannot use /VECTOR. The /VECTOR qualifier is ignored.
43. 1.292 - VFUFEANEX
SEVERITY: W
MESSAGE TEXT: This feature is unsupported and non-executable on
ULTRIX
EXPLANATION: The program attempted to use a Compaq Fortran I/O
feature that is not available on ULTRIX systems. If the resulting
program is run on an ULTRIX system, a run-time error will be issued
if this statement is executed. Major Compaq Fortran features not
available on ULTRIX include the following:
o OPEN and INQUIRE options:
- ORGANIZATION= 'RELATIVE' or 'INDEXED'
- ACCESS='KEYED'
- RECORDTYPE= 'STREAM' or 'STREAM_CR'
- KEY
- DEFAULTFILE
- USEROPEN
o I/O statements DELETE, REWRITE, and UNLOCK
o Read statement keyword attributes: KEY, KEYEQ, KEYGE, KEYGT,
and KEYID
43. 1.293 - VFUFEAUNS
SEVERITY: W
MESSAGE TEXT: This feature is unsupported on ULTRIX-32
EXPLANATION: The program attempted to use a Compaq Fortran I/O
feature that is not available on ULTRIX systems. If the resulting
program is run on an ULTRIX system, this construct will be ignored.
Major Compaq Fortran features not available on ULTRIX include the
following:
o OPEN statement keywords (and attributes):
- DISPOSE= 'PRINT', 'PRINT/DELETE', 'SUBMIT', 'SUBMIT/DELETE'
- BUFFERCOUNT
- EXTENDSIZE
- INITIALSIZE
- NOSPANBLOCKS
- SHARED
o CLOSE statement keywords (and attributes):
- DISPOSE= 'PRINT', 'PRINT/DELETE', 'SUBMIT', 'SUBMIT/DELETE'
- STATUS
43. 1.294 - VFUSRCUNA
SEVERITY: W MESSAGE TEXT: Requested source is not available on ULTRIX EXPLANATION: The program attempted to use one of the following Compaq Fortran I/O features that are not available on ULTRIX systems: o The DICTIONARY statement o The INCLUDE statement for a text module from a library file
43. 1.295 - WRITEERR
SEVERITY: F MESSAGE TEXT: Error writing "file-spec" EXPLANATION: Unable to write to file "file-spec".
43. 1.296 - WRONGCLD
SEVERITY: F MESSAGE TEXT: Wrong command definition installed - please see your system manager EXPLANATION: The current command tables do not include the proper definition of the FORTRAN command. This may be due to having installed an older version of the command definition, or the system command tables were updated but a user process is still using an older version.
43. 1.297 - ZERLENSTR
SEVERITY: E MESSAGE TEXT: Zero-length string EXPLANATION: The length specified for a character, Hollerith, hexadecimal, octal, or Radix-50 constant must not be zero.
43.2 - Run Time Errors
Errors that occur during execution of your program are reported by
diagnostic messages from the Run-Time Library. These messages can
result from hardware conditions, file system errors, errors
detected by RMS, errors that occur during transfer of data between
the program and an internal record, computations that cause
overflow or underflow, incorrect calls to the Run-Time Library,
problems in array descriptions, and conditions detected by the
operating system. Refer to the OpenVMS Run-Time Library Reference
Manuals for more information.
In order of greatest to least severity, the three classes of
run-time diagnostic messages are as follows:
Code Description
---- -----------
F Severe error; must be corrected. The program
cannot complete execution and is terminated when
the error is encountered.
E Error; should be corrected. The program may
continue execution, but the output from this
execution may be incorrect.
W Warning; should be investigated. The program
continues executing, but output from this execution
may be incorrect.
The following example shows how run-time messages are displayed:
%FOR-F-ADJARRDIM, adjustable array dimension error
In this Help file, the letter "C" after an error code indicates
that program execution can continue immediately after the error if
a user-written condition handler specifies that execution continue.
43. 2.1 - General
43. 2. 1.1 - ADJARRDIM
NUMBER: 93
ERROR CODE: F, C
MESSAGE TEXT: adjustable array dimension error
EXPLANATION: Upon entry to a subprogram, one of the following
errors was detected during the evaluation of dimensioning
information:
o An upper-dimension bound was less than a lower-dimension bound.
o The dimensions implied an array that was larger than the
addressable memory.
43. 2. 1.2 - ATTACCNON
NUMBER: 36
ERROR CODE: F
MESSAGE TEXT: attempt to access non-existent record
EXPLANATION: One of the following conditions occurred:
o A direct access READ, FIND, or DELETE statement attempted to
access a nonexistent record from a relative organization file.
o A direct access READ or FIND statement attempted to access
beyond the end of a sequential organization file.
o A keyed access READ statement attempted to access a nonexistent
record from an indexed organization file.
43. 2. 1.3 - BACERR
NUMBER: 23
ERROR CODE: F
MESSAGE TEXT: BACKSPACE error
EXPLANATION: One of the following conditions occurred:
o The file was not a sequential organization file.
o The file was not opened for sequential access. (A unit opened
for append access can not be backspaced until a REWIND
statement is executed for that unit.)
o RMS detected an error condition during execution of a BACKSPACE
statement.
43. 2. 1.4 - CLOERR
NUMBER: 28 ERROR CODE: F MESSAGE TEXT: CLOSE error EXPLANATION: An error condition was detected by RMS during execution of a CLOSE statement.
43. 2. 1.5 - DELERR
NUMBER: 55
ERROR CODE: F
MESSAGE TEXT: DELETE error
EXPLANATION: One of the following conditions occurred:
o On a direct access DELETE, the file did not have relative
organization.
o On a current record DELETE, the file did not have relative or
indexed organization, or the file was opened for direct access.
o RMS detected an error condition during execution of a DELETE
statement.
43. 2. 1.6 - DUPFILSPE
NUMBER: 21 ERROR CODE: F MESSAGE TEXT: duplicate file specifications EXPLANATION: Multiple attempts were made to specify file attributes without an intervening close operation. One of the following conditions occurred: o A DEFINE FILE was followed by another DEFINE FILE statement. o A DEFINE FILE was followed by an OPEN statement. o A CALL ASSIGN or CALL FDBSET was followed by an OPEN statement.
43. 2. 1.7 - ENDDURREA
NUMBER: 24
ERROR CODE: F
MESSAGE TEXT: end-of-file during read
EXPLANATION: One of the following conditions occurred:
o An RMS end-of-file condition was encountered during execution
of a READ statement that did not contain an END, ERR, or IOSTAT
specification.
o An end-of-file record written by the ENDFILE statement was
encountered during execution of a READ statement that did not
contain an END, ERR, or IOSTAT specification.
o An attempt was made to read past the end of an internal file,
character string, or array during execution of a READ statement
that did not contain an END, ERR, or IOSTAT specification.
43. 2. 1.8 - ENDFILERR
NUMBER: 33
ERROR CODE: F
MESSAGE TEXT: ENDFILE error
EXPLANATION: One of the following conditions occurred:
o The file was not a sequential organization file with
variable-length records.
o The file was not opened for sequential or append access.
o An unformatted file did not contain segmented records.
o RMS detected an error during execution of an ENDFILE statement.
43. 2. 1.9 - ERRDURREA
NUMBER: 39 ERROR CODE: F MESSAGE TEXT: error during read EXPLANATION: RMS detected an error condition during execution of a READ statement.
43. 2. 1.10 - ERRDURWRI
NUMBER: 38 ERROR CODE: F MESSAGE TEXT: error during write EXPLANATION: RMS detected an error condition during execution of a WRITE statement.
43. 2. 1.11 - FILNAMSPE
NUMBER: 43 ERROR CODE: F MESSAGE TEXT: file name specification error EXPLANATION: A file-name specification given to OPEN, INQUIRE, or CALL ASSIGN statement was not acceptable to RMS.
43. 2. 1.12 - FILNOTFOU
NUMBER: 29 ERROR CODE: F MESSAGE TEXT: file not found EXPLANATION: A file with the specified name could not be found during an open operation.
43. 2. 1.13 - FINERR
NUMBER: 57 ERROR CODE: F MESSAGE TEXT: FIND error EXPLANATION: RMS detected an error condition during execution of a FIND statement.
43. 2. 1.14 - FLOCONFAI
NUMBER: 95 ERROR CODE: E MESSAGE TEXT: floating point conversion failed EXPLANATION: The attempted unformatted read or write of nonnative floating-point data failed. A nonnative floating-point value either exceeded the allowable maximum value for the equivalent native format and was set equal to invalid, or the value was infinity (plus or minus), not a number (NaN), or otherwise invalid and was set to invalid. Very small numbers are set to zero (0). This could be caused by the specified nonnative floating-point format not matching the floating-point format found in the specified file. Make sure the correct file was specified. Make sure the record layout matches the format Compaq Fortran is expecting. Check that the correct nonnative floating-point data format was specified, as described in your user manual.
43. 2. 1.15 - FLOOVEMAT
NUMBER: 88 ERROR CODE: F, C MESSAGE TEXT: floating overflow in math library EXPLANATION: A floating overflow condition was detected during execution of a math library procedure. The result returned was the reserved operand, -0.
43. 2. 1.16 - FLOUNDMAT
NUMBER: 89 ERROR CODE: F, C MESSAGE TEXT: floating underflow in math library EXPLANATION: A floating underflow condition was detected during execution of a math library procedure. The result returned was zero.
43. 2. 1.17 - FLTDIV
NUMBER: 73 ERROR CODE: F, C MESSAGE TEXT: arithmetic trap, zero divide EXPLANATION: During a floating-point or decimal arithmetic operation, an attempt was made to divide by 0.0. If floating-point, the result returned is the the reserved operand, -0. If decimal, the result of the operation is unpredictable.
43. 2. 1.18 - FLTDIV_F
NUMBER: 73 ERROR CODE: F, C MESSAGE TEXT: arithmetic fault, zero divide EXPLANATION: During a floating-point arithmetic operation, an attempt was made to divide by zero.
43. 2. 1.19 - FLTOVF
NUMBER: 72 ERROR CODE: F, C MESSAGE TEXT: arithmetic trap, floating overflow EXPLANATION: During an arithmetic operation a floating-point value exceeded the largest representable value for that data type. The result of the operation was set to the reserved operand, -0.
43. 2. 1.20 - FLTOVF_F
NUMBER: 72 ERROR CODE: F, C MESSAGE TEXT: arithmetic fault, floating overflow EXPLANATION: During an arithmetic operation, a floating-point value exceeded the largest representable value for that data type.
43. 2. 1.21 - FLTUND
NUMBER: 74 ERROR CODE: F, C MESSAGE TEXT: arithmetic trap, floating underflow EXPLANATION: During an arithmetic operation a floating-point value became less than the smallest representable value for that data type and was replaced with a value of zero.
43. 2. 1.22 - FLTUND_F
NUMBER: 74 ERROR CODE: F, C MESSAGE TEXT: arithmetic fault, floating underflow EXPLANATION: During an arithmetic operation a floating-point value became less than the smallest representable value for that data type.
43. 2. 1.23 - FORVARMIS
NUMBER: 61 ERROR CODE: F, C MESSAGE TEXT: format/variable-type mismatch EXPLANATION: An attempt was made either to read or write a real variable with an integer field descriptor (I or L), or to read or write an integer or logical variable with a real field descriptor (D, E, F, or G). If execution continued, one of the following actions occurred: o If I or L, conversion as if INTEGER*4. o If D, E, F, or G, conversion as if REAL*4.
43. 2. 1.24 - INCFILORG
NUMBER: 51
ERROR CODE: F
MESSAGE TEXT: inconsistent file organization
EXPLANATION: One of the following conditions occurred:
o The file organization specified in an OPEN statement did not
match the organization of the existing file.
o The file organization of the existing file was inconsistent
with the specified access mode; that is, either direct access
was specified with an indexed organization file or keyed access
was specified with a sequential or relative organization file.
43. 2. 1.25 - INCKEYCHG
NUMBER: 50 ERROR CODE: F MESSAGE TEXT: inconsistent key change or duplicate key EXPLANATION: A WRITE or REWRITE to an indexed organization file caused a key field to change or be duplicated. This condition was not allowed by the attributes of the file, as established when the file was created.
43. 2. 1.26 - INCOPECLO
NUMBER: 46
ERROR CODE: F
MESSAGE TEXT: inconsistent OPEN/CLOSE parameters
EXPLANATION: Specifications in an OPEN or CLOSE statement were
inconsistent. Some invalid combinations are:
o READONLY with STATUS='NEW' or STATUS='SCRATCH'
o ACCESS='APPEND' with READONLY, STATUS='NEW', or
STATUS='SCRATCH'
o DISPOSE='SAVE', 'PRINT', or 'SUBMIT' with STATUS='SCRATCH'
o DISPOSE='DELETE' with READONLY
43. 2. 1.27 - INCRECLEN
NUMBER: 37
ERROR CODE: F
MESSAGE TEXT: inconsistent record length
EXPLANATION: One of the following conditions occurred:
o An attempt was made to create a new relative, indexed, or
direct access file without specifying a record length.
o An existing file was opened in which the record length did not
match the record size given in an OPEN or DEFINE FILE
statement.
43. 2. 1.28 - INCRECTYP
NUMBER: 44 ERROR CODE: F MESSAGE TEXT: inconsistent record type EXPLANATION: The RECORDTYPE value in an OPEN statement did not match the record type attribute of the existing file that was opened.
43. 2. 1.29 - INFFORLOO
NUMBER: 60 ERROR CODE: F MESSAGE TEXT: infinite format loop EXPLANATION: The format associated with an I/O statement that included an I/O list had no field descriptors to use in transferring those values.
43. 2. 1.30 - INPCONERR
NUMBER: 64 ERROR CODE: F, C MESSAGE TEXT: input conversion error EXPLANATION: During a formatted input operation, either an invalid character was detected in an input field, or the input value overflowed the range representable in the input variable. The value of the variable was set to zero.
43. 2. 1.31 - INPRECTOO
NUMBER: 22 ERROR CODE: F MESSAGE TEXT: input record too long EXPLANATION: A record was read that exceeded the explicit or the default record length specified in OPEN (or by the default OPEN). To read the file, use an OPEN statement with a RECL value of the appropriate size.
43. 2. 1.32 - INPSTAREQ
NUMBER: 67 ERROR CODE: F MESSAGE TEXT: input statement requires too much data EXPLANATION: An unformatted READ statement attempted to read more data than existed in the record being read.
43. 2. 1.33 - INSVIRMEM
NUMBER: 41 ERROR CODE: F MESSAGE TEXT: insufficient virtual memory EXPLANATION: The Compaq Fortran Run-Time Library attempted to exceed its virtual page limit while dynamically allocating space.
43. 2. 1.34 - INTDIV
NUMBER: 71 ERROR CODE: F, C MESSAGE TEXT: arithmetic trap, integer zero divide EXPLANATION: During an integer arithmetic operation, an attempt was made to divide by zero. The result of the operation was set to the dividend, which is equivalent to division by one.
43. 2. 1.35 - INTOVF
NUMBER: 70 ERROR CODE: F, C MESSAGE TEXT: arithmetic trap, integer overflow EXPLANATION: During an arithmetic operation, an integer value exceeded byte, word, or longword range. The result of the operation was the correct low-order part.
43. 2. 1.36 - INVARGFOR
NUMBER: 48
ERROR CODE: F
MESSAGE TEXT: invalid argument to Fortran Run-Time Library
EXPLANATION: One of the following conditions occurred:
o An invalid argument was given to a PDP-11 FORTRAN compatibility
subroutine, such as ERRSET.
o The Compaq Fortran compiler passed an invalid coded argument to
the Run-Time Library. This can occur if the compiler is newer
than the Run-Time Library in use.
43. 2. 1.37 - INVARGMAT
NUMBER: 81 ERROR CODE: F MESSAGE TEXT: invalid argument to math library EXPLANATION: One of the mathematical procedures detected an invalid argument value.
43. 2. 1.38 - INVKEYSPE
NUMBER: 49 ERROR CODE: F MESSAGE TEXT: invalid key specification EXPLANATION: A key specification in an OPEN statement or in a keyed access READ statement was invalid. For example, the key length may have been zero or greater than 255 bytes, or the key length may not conform to the key specification of the existing file.
43. 2. 1.39 - INVLOGUNI
NUMBER: 32 ERROR CODE: F MESSAGE TEXT: invalid logical unit number EXPLANATION: A logical unit number greater than 119 or less than zero was used in an I/O statement.
43. 2. 1.40 - INVMATKEY
NUMBER: 94 ERROR CODE: F MESSAGE TEXT: invalid key match specifier for key direction EXPLANATION: A keyed READ used an invalid key match specifier for the direction of that key. Use KEYGE and KEYGT only on ascending keys. Use KEYLE and KEYLT only on descending keys. Use KEYNXT and KEYNXTNE to avoid enforcement of key direction and match specifier.
43. 2. 1.41 - INVREFVAR
NUMBER: 19
ERROR CODE: F
MESSAGE TEXT: invalid reference to variable "varname" in namelist
input
EXPLANATION: The name of the variable in error is substituted for
"varname" in the message text. One of the following conditions
occurred:
o The variable was not a member of the namelist group.
o An attempt was made to subscript the scalar variable.
o A subscript of the array variable was out-of-bounds.
o There were too many or too few subscripts for the variable.
o An attempt was made to specify a substring of a noncharacter
variable or array name.
o A substring specifier of the character variable is
out-of-bounds.
o A subscript or substring specifier of the variable was not an
integer constant.
o An attempt was made to specify a substring using an
unsubscripted array variable.
43. 2. 1.42 - KEYVALERR
NUMBER: 45 ERROR CODE: F MESSAGE TEXT: keyword value error in OPEN statement EXPLANATION: An OPEN or CLOSE statement keyword requiring a value had an improper value. Refer to the DEC Fortran Language Reference Manual for the allowed keyword values.
43. 2. 1.43 - LISIO_SYN
NUMBER: 59 ERROR CODE: F, C MESSAGE TEXT: list-directed I/O syntax error EXPLANATION: The data in a list-directed input record had an invalid format, or the type of the constant was incompatible with the corresponding variable. The value of the variable was unchanged.
43. 2. 1.44 - LOGZERNEG
NUMBER: 83 ERROR CODE: F, C MESSAGE TEXT: logarithm of zero or negative value EXPLANATION: An attempt was made to take the logarithm of zero or a negative number. The result returned was the reserved operand, -0.
43. 2. 1.45 - MIXFILACC
NUMBER: 31
ERROR CODE: F
MESSAGE TEXT: mixed file access modes
EXPLANATION: One of the following conditions occurred:
o An attempt was made to use both formatted and unformatted
operations on the same unit.
o An attempt was made to use an invalid combination of access
modes on a unit, such as direct and sequential. The only valid
combination is sequential and keyed access on a unit opened
with ACCESS='KEYED'.
o An attempt was made to execute a Fortran I/O statement on a
logical unit that was opened by a language other than Fortran.
43. 2. 1.46 - NO_CURREC
NUMBER: 53 ERROR CODE: F MESSAGE TEXT: no current record EXPLANATION: A REWRITE or current record DELETE was attempted when no current record was defined.
43. 2. 1.47 - NO_SUCDEV
NUMBER: 42 ERROR CODE: F MESSAGE TEXT: no such device EXPLANATION: A file-name specification included an invalid or unknown device name when an open operation was attempted.
43. 2. 1.48 - NOTFORSPE
NUMBER: 1 ERROR CODE: F MESSAGE TEXT: not a Fortran-specific error EXPLANATION: An error occurred in the user program or in the Run-Time Library that was not a Fortran-specific error. Therefore it was not reportable through any other message in the table. If you call ERRSNS, an error of this kind returns a value of 1. Use the fifth argument of the call to ERRSNS (condval) to obtain the unique system condition value that identifies the error.
43. 2. 1.49 - OPEDEFREQ
NUMBER: 26
ERROR CODE: F
MESSAGE TEXT: OPEN or DEFINE FILE required for keyed or direct
access
EXPLANATION: One of the following conditions occurred:
o A direct access READ, WRITE, FIND, or DELETE statement
specified a file that was not opened with a DEFINE FILE
statement or with an OPEN statement specifying ACCESS='DIRECT'.
o A keyed access READ statement specified a file that was not
opened with an OPEN statement specifying ACCESS='KEYED'.
43. 2. 1.50 - OPEFAI
NUMBER: 30 ERROR CODE: F MESSAGE TEXT: open failure EXPLANATION: An error was detected by RMS while attempting to open a file in an OPEN, INQUIRE, or other I/O statement. This message is used when the error condition is not one of the more common conditions for which specific error messages are provided.
43. 2. 1.51 - OUTCONERR
NUMBER: 63 ERROR CODE: E, C MESSAGE TEXT: output conversion error EXPLANATION: During a formatted output operation, the value of a particular number could not be output in the specified field length without loss of significant digits. When this error occurs, the field is filled with asterisks.
43. 2. 1.52 - OUTSTAOVE
NUMBER: 66 ERROR CODE: F MESSAGE TEXT: output statement overflows record EXPLANATION: An output statement attempted to transfer more data than would fit in the maximum record size.
43. 2. 1.53 - RECIO_OPE
NUMBER: 40
ERROR CODE: F
MESSAGE TEXT: recursive I/O operation
EXPLANATION: While processing an I/O statement for a logical unit,
another I/O operation on the same logical unit was attempted. One
of the following conditions may have occurred:
o A function subprogram that performs I/O to the same logical
unit was referenced in an expression in an I/O list or variable
format expression.
o An I/O statement was executed at AST level for the same logical
unit.
o An exception handler (or a procedure it called) executed an I/O
statement in response to a signal from an I/O statement for the
same logical unit.
43. 2. 1.54 - RECNUMOUT
NUMBER: 25 ERROR CODE: F MESSAGE TEXT: record number outside range EXPLANATION: A direct access READ, WRITE, or FIND statement specified a record number outside the range specified when the file was created.
43. 2. 1.55 - REWERR
NUMBER: 20
ERROR CODE: F
MESSAGE TEXT: REWIND error
EXPLANATION: One of the following conditions occurred:
o The file was not a sequential organization file.
o The file was not opened for sequential or append access.
o RMS detected an error condition during execution of a REWIND
statement.
43. 2. 1.56 - REWRITERR
NUMBER: 54 ERROR CODE: F MESSAGE TEXT: REWRITE error EXPLANATION: RMS detected an error condition during execution of a REWRITE statement.
43. 2. 1.57 - SEGRECFOR
NUMBER: 35 ERROR CODE: F MESSAGE TEXT: segmented record format error EXPLANATION: An invalid segmented record control data word was detected in an unformatted sequential file. The file was probably either written in a language other that Fortran, or created with RECORDTYPE='FIXED' or 'VARIABLE' in effect.
43. 2. 1.58 - SIGLOSMAT
NUMBER: 87 ERROR CODE: F, C MESSAGE TEXT: significance lost in math library EXPLANATION: The magnitude of an argument or the magnitude of the ratio of the arguments to a math library function was so large that all significance in the result was lost. The result returned was the reserved operand -0.
43. 2. 1.59 - SPERECLOC
NUMBER: 52 ERROR CODE: F MESSAGE TEXT: specified record locked EXPLANATION: A READ or direct access WRITE, FIND, or DELETE was attempted on a record that was locked by another user.
43. 2. 1.60 - SQUROONEG
NUMBER: 84 ERROR CODE: F, C MESSAGE TEXT: square root of negative value EXPLANATION: An argument required the evaluation of the square root of a negative value. The result returned was the reserved operand, -0.
43. 2. 1.61 - SUBRNG
NUMBER: 77 ERROR CODE: F, C MESSAGE TEXT: trap, subscript out of range EXPLANATION: An array reference was detected outside the declared array bounds.
43. 2. 1.62 - SYNERRFOR
NUMBER: 62 ERROR CODE: F MESSAGE TEXT: syntax error in format EXPLANATION: A syntax error was encountered while the Run-Time Library was processing a format stored in an array or character variable.
43. 2. 1.63 - SYNERRNAM
NUMBER: 17 ERROR CODE: F MESSAGE TEXT: syntax error in namelist input "text" EXPLANATION: The syntax of input to a namelist READ statement was incorrect. The part of the record in which the error was detected is substituted for "text" in the message text.
43. 2. 1.64 - TOOMANREC
NUMBER: 27
ERROR CODE: F
MESSAGE TEXT: too many records in I/O statement
EXPLANATION: One of the following conditions occurred:
o An attempt was made to read or write more than one record with
an ENCODE or DECODE statement.
o An attempt was made to write more records than existed.
43. 2. 1.65 - TOOMANVAL
NUMBER: 18 ERROR CODE: F MESSAGE TEXT: too many values for namelist variable "varname" EXPLANATION: An attempt was made to assign too many values to a variable during a namelist READ statement. The name of the variable is substituted for "varname" in the message text.
43. 2. 1.66 - UNDEXP
NUMBER: 82 ERROR CODE: F, C MESSAGE TEXT: undefined exponentiation EXPLANATION: An exponentiation that is mathematically undefined was attempted, for example, 0.**0. The result returned was the reserved operand -0 (for floating-point operations) or zero (for integer operations).
43. 2. 1.67 - UNIALROPE
NUMBER: 34 ERROR CODE: F MESSAGE TEXT: unit already open EXPLANATION: A DEFINE FILE statement specified a logical unit that was already opened.
43. 2. 1.68 - UNLERR
NUMBER: 56 ERROR CODE: F MESSAGE TEXT: UNLOCK error EXPLANATION: RMS detected an error condition during execution of an UNLOCK statement.
43. 2. 1.69 - VFEVALERR
NUMBER: 68 ERROR CODE: F, C MESSAGE TEXT: variable format expression value error EXPLANATION: The value of a variable format expression was not within the range acceptable for its intended use; for example, a field width was less than or equal to zero. A value of one was assumed, except for a P edit descriptor, for which a value of zero was assumed.
43. 2. 1.70 - WRIREAFIL
NUMBER: 47 ERROR CODE: F MESSAGE TEXT: write to READONLY file EXPLANATION: A write operation was attempted to a file that was declared READONLY in the OPEN statement that is currently in effect.
43. 2. 1.71 - WRONUMARG
NUMBER: 80 ERROR CODE: F MESSAGE TEXT: wrong number of arguments EXPLANATION: An improper number of arguments was used to call a math library procedure.
43. 2.2 - Parallel Processing Specific
43. 2. 2.1 - COMSHRERR
SEVERITY: F MESSAGE TEXT: Unable to share memory region from x to y EXPLANATION: The Fortran Run-Time Library could not make the specified memory region shared among the processes participating in the parallel processing environment.
43. 2. 2.2 - DEFVALUSED
SEVERITY: I MESSAGE TEXT: Default value of xx used for logical name EXPLANATION: A default value was used for the specified logical name.
43. 2. 2.3 - FAIACTCPU
SEVERITY: F MESSAGE TEXT: Failed to obtain active CPU count EXPLANATION: The Fortran Run-Time Library could not obtain the active CPU count. Thus, it was unable to set up the parallel processing environment.
43. 2. 2.4 - FAIDCLEXIT
SEVERITY: F MESSAGE TEXT: Failed to declare an exit handler EXPLANATION: The Fortran Run-Time Library could not declare an exit handler. Thus, it was unable to set up the parallel processing environment.
43. 2. 2.5 - FAIIDPRC
SEVERITY: F MESSAGE TEXT: Failed to identify the process EXPLANATION: The Fortran Run-Time Library could not identify the process. Submit a Software Performance Report (SPR) that describes the conditions leading to the error.
43. 2. 2.6 - FAIIMAGNAME
SEVERITY: F MESSAGE TEXT: Failed to obtain image name EXPLANATION: The Fortran Run-Time Library could not obtain the image name. Thus, it was unable to set up the parallel processing environment.
43. 2. 2.7 - FAIOWNERID
SEVERITY: F MESSAGE TEXT: Failed to obtain owner process ID EXPLANATION: The Fortran Run-Time Library could not obtain the owner process identification. Thus, it was unable to set up the parallel processing environment.
43. 2. 2.8 - FAIPRCID
SEVERITY: F MESSAGE TEXT: Failed to obtain process ID EXPLANATION: The Fortran Run-Time Library could not obtain the process identification. Thus, it was unable to set up the parallel processing environment.
43. 2. 2.9 - FAIPRCNAME
SEVERITY: F MESSAGE TEXT: Failed to obtain process name EXPLANATION: The Fortran Run-Time Library could not obtain the process name. Thus, it was unable to set up the parallel processing environment.
43. 2. 2.10 - FAISHRSTACK
SEVERITY: F MESSAGE TEXT: Unable to share the stack region from x to y EXPLANATION: The Fortran Run-Time Library could not make the specified stack region shared among processes participating in the parallel processing environment.
43. 2. 2.11 - FAISUBPRC
SEVERITY: F MESSAGE TEXT: Failed to create subprocess EXPLANATION: The Fortran Run-Time Library could not get the process identification. Thus, it was unable to set up the parallel processing environment.
43. 2. 2.12 - FATINTERR
SEVERITY: F MESSAGE TEXT: Fatal internal error in the Fortran Parallel Processing Run-Time Library EXPLANATION: The Fortran Run-Time Library detected an unrecoverable, inconsistent condition. Submit a Software Performance Report (SPR) that describes the conditions leading to the error.
43. 2. 2.13 - INVCOMADR
SEVERITY: F MESSAGE TEXT: Invalid memory region addresses EXPLANATION: The Fortran Run-Time Library detected invalid starting and ending addresses for a shared memory region. Submit a Software Performance Report (SPR) that describes the conditions leading to the error.
43. 2. 2.14 - INVLCLADR
SEVERITY: F MESSAGE TEXT: Invalid $LOCAL PSECT addresses EXPLANATION: The Fortran Run-Time Library detected invalid starting and ending addresses for a $LOCAL PSECT. Submit a Software Performance Report (SPR) that describes the conditions leading to the error.
43. 2. 2.15 - INVLOGNAM
SEVERITY: E MESSAGE TEXT: Invalid logical name definition EXPLANATION: A logical name was defined incorrectly.
43. 2. 2.16 - INVNUMPRC
SEVERITY: F MESSAGE TEXT: Invalid number of processes EXPLANATION: The Fortran Run-Time Library detected an invalid number of processes. Submit a Software Performance Report (SPR) that describes the conditions leading to the error.
43. 2. 2.17 - INVUNWIND
SEVERITY: F MESSAGE TEXT: Invalid stack unwinding encountered EXPLANATION: The Fortran Run-Time Library detected an invalid attempt to unwind the stack.
43. 2. 2.18 - LOCALACCESS
SEVERITY: F MESSAGE TEXT: Subprocess unable to access the shared $LOCAL PSECT EXPLANATION: A subprocess could not access the shared $LOCAL PSECT.
43. 2. 2.19 - LOCALSHRERR
SEVERITY: F MESSAGE TEXT: Unable to share the $LOCAL PSECT EXPLANATION: The Fortran Run-Time Library could not make the $LOCAL PSECT shared among the processes participating in the parallel processing environment.
43. 2. 2.20 - MEMSHRERR
SEVERITY: F MESSAGE TEXT: Memory sharing error EXPLANATION: The Fortran Run-Time Library failed to share data among the processes participating in the parallel processing environment.
43. 2. 2.21 - NOPARINIT
SEVERITY: I MESSAGE TEXT: Parallel processing environment was not available EXPLANATION: The Compaq Fortran main program was not compiled with /PARALLEL. As a result, the parallel processing environment was not available.
43. 2. 2.22 - NOTIMPRET
SEVERITY: F MESSAGE TEXT: Routine not implemented in this version of FORRTL2 EXPLANATION: An attempt was made to use a routine that is not implemented in this version of the Fortran Run-Time Library.
43. 2. 2.23 - NOTRUNINPP
SEVERITY: I MESSAGE TEXT: Unable to run the DO-Loop PC: xx in parallel EXPLANATION: A parallel DO loop with the specified PC address cannot run in parallel.
43. 2. 2.24 - STACKSHRERR
SEVERITY: F MESSAGE TEXT: Stack sharing error EXPLANATION: The Fortran Run-Time Library could not make the stack shared among the processes participating in the parallel processing environment.
43. 2. 2.25 - STKBUFOVR
SEVERITY: F MESSAGE TEXT: Stack buffer overflow was detected EXPLANATION: An internal limit on the number of shared stack regions that your program can have was exceeded. Submit a Software Performance Report (SPR) that describes the conditions leading to the error.
43. 2. 2.26 - SUBPRCDIED
SEVERITY: F MESSAGE TEXT: Subprocess PID: xx terminated EXPLANATION: A subprocess with the specified process ID was terminated.
43. 2. 2.27 - TOOMANPRC
SEVERITY: E MESSAGE TEXT: Too many processes, allowed a maximum of 32 processes EXPLANATION: A limit on the number of processes participating in the Fortran parallel processing environment was exceeded. The limit is currently 32.
43.3 - Vectorization Errors
The following errors identify when vectorization was inhibited and
attempt to identify why it was inhibited. These messages are
generated if the /VECTOR/SHOW=DATA_DEPENDENCES/DIAGNOSTICS
qualifiers are specified. These errors are only generated to the
diagnostic file, not to the listing file or terminal.
Unknown dependence using xxxx
The compiler has analyzed the dependences between array
references and is unable to determine the order in which the
references must occur. Many times this is caused by not knowing
the range of values possible for an expression used as part of
the array index.
Nonuniform dependence
The compiler has detected that the relative order of references
to common memory locations, for two array references in the loop,
are not uniform for all such locations. For example:
A(I) = B(I) * A(N-I)
Some locations are accessed first by A(I) and others by A(N-I).
Outer level vectorization inhibited
The compiler has analyzed the dependences between array
references at different DO-loop levels and is unable to determine
the order in which the references must occur.
These errors relate to assertion declarations. See Section 6.2.1
in your performance guide for information on how to handle these
errors.
Within LSE, you can use Review Mode to apply suggested assertions
to handle these errors. To do so, move the cursor to the
suggestion that you wish to use and press Ctrl/G. This instructs
LSE to apply the suggestion to the source file. LSE then prompts
for a confirmation that this change is desirable. If it is, answer
YES and the suggestion will be inserted.
| 44 - Format Specifiers |
A FORMAT statement specifies the format in which data is to be transferred and the conversion (editing) required to achieve that format. FORMAT statements are nonexecutable statements used with formatted I/O statements, ASSIGN statements, and with ENCODE and DECODE statements. Fields defined by a FORMAT statement can contain variable format expressions. A variable format expression is an integer variable or expression enclosed in angle brackets that takes the place of an integer constant. The value of the variable or variables can change during program execution.
44.1 - Default Field Descriptors
Default field descriptor values are as follows:
Field
Descriptor List Element w d e
----------------------------------------------------------
I,O,Z BYTE,INTEGER*1,LOGICAL*1 7
I,O,Z INTEGER*2,LOGICAL*2 7
I,O,Z INTEGER*4,LOGICAL*4 12
O,Z REAL*4 12
O,Z REAL*8 23
O,Z REAL*16 44
O,Z CHARACTER*n MAX(7,3*n)
L LOGICAL*1,LOGICAL*2, 2
LOGICAL*4
F,E,G,D REAL,COMPLEX*8 15 7 2
F,E,G,D REAL*4,COMPLEX*16 25 16 2
F,E,G,D REAL*16 42 33 3
A LOGICAL*1 1
A LOGICAL*2,INTEGER*2 2
A LOGICAL*4,INTEGER*4 4
A REAL*8,COMPLEX*8 8
A REAL*8,COMPLEX*16 8
A REAL*16 16
A CHARACTER*n n
44.2 - General Form
The general form of a FORMAT statement is as follows:
FORMAT (q1 f1s1 f2s2 ... fnsn qn)
qn Is zero or more slash (/) record terminators.
fn Is a field descriptor, an edit descriptor, or
a group of field and edit descriptors enclosed
in parentheses.
sn Is a field separator (a comma or slash). A
comma can be omitted in the following cases:
o Between a P edit descriptor and an immediately
following F, E, D, or G edit descriptor.
o Before or after a slash (/) record terminator.
o Before or after a colon (_:) edit descriptor.
The "field descriptor" has one of the following forms:
[r]c [r]cw [r]cw.m [r]cw.d[Ee]
r Is the optional repeat count. (If you omit "r",
the repeat count is assumed to be 1.)
c Is a format code (I,O,Z,F,E,D,G,L, or A).
w Is the external field width in characters. Each
data item in the external medium is called an
external field.
m Is the minimum number of characters that must appear
in the field (including leading zeros).
d Is the number of characters to the right of the decimal point.
E Is an exponent field.
e Is the number of characters in the exponent.
A group of field descriptors can be formed by enclosing a format
specifier in parentheses and optionally preceding the group with a
repeat count (defaults to 1). Separate a group from other format
specifiers or groups with field separators or record terminators.
Groups can be nested to a depth of 8.
The entire format specifier must be enclosed in parentheses.
The ranges for "r", "w", "m", "d", and "e" are as follows:
Term Range
---- __________
r 1 to 32767 (2**15-1)
w 1 to 32767
m 0 to 255 (2**8-1)
d 0 to 255
e 1 to 255
The "d" and "e" terms are required in some field descriptors and
are invalid in others.
The terms must all be unsigned integer constants or variable format
expressions.
You cannot use PARAMETER constants for "r", "w", "m", "d", or "e".
The "edit descriptor" has one of the following forms:
c [n]c c[n]
c Is a format code (X,T,TL,TR,SP,SS,S,BN,BZ,P,H,Q,'...'
$, or :).
n Is the optional number of characters or character
positions.
The term "n" must be an unsigned integer constant (for format code
P, it can be signed or unsigned) or a variable format expression.
The value of "n" for P must be within the range -128 to 127.
For all other format codes, the value of "n" must be within the
range 1 through 32767 (2**15-1); above 32767, you receive an error.
Actual useful ranges can be constrained by record sizes (RECL) and
the file system.
44.3 - Format Descriptors
A format descriptor can be one of the following:
Field descriptor -- Defines the size and format of a data
item. Each field descriptor corresponds to the next data
item in the statement's I/O list.
Edit descriptor -- Specifies editing functions to be
performed on data items.
Format descriptors are generally separated by commas, but you can
also use the slash (/) record terminator to separate them. A slash
terminates input or output of the current record and initiates a
new record; for example:
WRITE (6,40) K,L,M,N,O,P
40 FORMAT (3I6.6/I6,2F8.4)
The preceding statements are equivalent to the following:
WRITE (6,40) K,L,M
40 FORMAT (3I6.6)
WRITE (6,50) N,O,P
50 FORMAT (I6,2F8.4)
Multiple slashes cause the system to bypass input records or output
blank records. If "n" consecutive slashes appear between two field
or edit descriptors, (n-1) records are skipped on input, or (n-1)
blank records are output. The first slash terminates the current
record. The second slash terminates the first skipped or blank
record, and so on.
However, "n" slashes at the beginning or end of a format
specification result in "n" skipped or blank records. This is
because the opening and closing parentheses of the format
specification are themselves a record initiator and terminator,
respectively.
44.4 - Repeat Count
You can apply the field descriptors I, O, Z, F, E, D, G, L, and A
to a number of successive data fields by preceding the field
descriptor with an unsigned integer constant (PARAMETER constants
are not allowed) specifying the number of repetitions. This
constant is called a repeat count.
For example, the following two statements are equivalent:
20 FORMAT (E12.4,E12.4,E12.4,I5,I5,I5,I5)
20 FORMAT (3E12.4,4I5)
Similarly, you can apply a group of field descriptors repeatedly to
data fields by enclosing these field descriptors in parentheses and
preceding them with an unsigned integer constant. The integer
constant is called a group repeat count. For example, the
following two statements are equivalent:
50 FORMAT (I8,I8,F8.3,E15.7,F8.3,E15.7,F8.3,E15.7,I5,I5)
50 FORMAT (2I8,3(F8.3,E15.7),2(I5))
An H or Q field descriptor, which could not otherwise be repeated,
can be enclosed in parentheses and treated as a group repeat
specification.
44.5 - Reversion
When the last closing parenthesis of the format specification is reached, format control determines whether more I/O list elements are to be processed. If not, format control terminates. However, if additional list elements remain, part or all of the format specification is reused in a process called format reversion. In format reversion, the current record is terminated, a new one is initiated, and format control reverts to the group repeat specification whose opening parenthesis matches the next-to-last closing parenthesis of the format specification. If the format does not contain a group repeat specification, format control returns to the initial opening parenthesis of the format specification. Format control continues from that point.
44.6 - Variable Format Expressions
By enclosing an expression in angle brackets, you can use it in a
FORMAT statement wherever you can use an integer (except as the
specification of the number of characters in the H field). For
example:
20 FORMAT (I<J+1>)
When the format is scanned, the preceding statement performs an
integer (I) data transfer with a field width of J+1. The
expression is reevaluated each time it is encountered in the normal
format scan.
The following rules apply to variable format expressions:
- If the expression is not of integer data type, it is
converted to integer data type before being used.
- The expression can be any valid Fortran expression,
including function calls and references to dummy arguments.
- The value of a variable format expression must obey the
restrictions on magnitude applying to its use in the
format, or an error occurs.
- Variable format expressions are not permitted in run-time
formats.
Variable format expressions are evaluated each time they are
encountered in the scan of the format. If the value of the
variable used in the expression changes during the execution of the
I/O statement, the new value is used the next time the format item
containing the expression is processed.
44.7 - Field
Field descriptors:
+-----------------------------------+
| Function | Format |
+--------------------+--------------+
| Integer | Iw[.m] |
| Real number | Fw.d |
| Exponential form | Ew.d[Ee] |
| D exponential form | Dw.d |
| G exponential form | Gw.d[Ee] |
| Character | A[w] |
| Logical | Lw |
| Hexadecimal | Zw[.m] |
| Octal | Ow[.m] |
+--------------------+--------------+
NOTE: Transfer complex numbers as two real (F, E, D, or G) numbers.
44.8 - Edit
Edit descriptors:
+--------------------------+--------------+
| Function | Format |
+--------------------------+--------------+
| Character constant | 'characters' |
| Hollerith | nHchar... |
| Scale factor | nP |
| Blanks are null (input) | BN |
| Blanks are zero (input) | BZ |
| Input size | Q |
| Plus sign (always) | SP |
| Plus sign (never) | SS |
| Default plus sign | S |
| Skip spaces (same as TRn)| nX |
| Position (Tab) | Tn |
| Relative left tab | TLn |
| Relative right tab | TRn |
| Carriage control | $ |
| Terminate list | : |
+--------------------------+--------------+
44.9 - 'characters'
You can use a character constant instead of an H field descriptor. Both types of format specifiers function identically. On input, this specifier transfers the specified characters from the external field. On output, this specifier transfers the specified characters to the record.
44.10 - Carriage Control
When the first character of a formatted record is transferred to an
output file or printer, it can be interpreted as a carriage control
character (and not printed) if the file is opened with
CARRIAGECONTROL='FORTRAN' in effect.
The I/O system recognizes the characters listed below as carriage
control characters and does not print them.
Character Meaning
--------- -----------------------------------------
'+' Overprinting: Outputs the record (at the
beginning of the current line) and a
carriage return.
' ' One line feed: Outputs the record (at the
beginning of the following line) and a
carriage return.
'0' Two line feeds: Outputs the record (after
skipping a line) and a carriage return.
'1' Next page: Outputs the record (at the
beginning of a new page) and a carriage
return.
'$' Prompting: Outputs the record (at the
beginning of a new page), but no carriage
return.
ASCII NULL Overprinting with no advance: Outputs
the record (at the beginning of the current
line), but no carriage return. (ASCII NULL
is specified as CHAR(0).)
Any character other than those listed above is interpreted as a
space and is deleted from the print line. If you accidentally omit
a carriage control character, the first character of the record is
not printed.
44.11 - $
(Carriage Control Editing)
In a format specification, the dollar sign character ($) modifies
the carriage control specified by the first character of the
record. It only affects the files for which the 'FORTRAN' carriage
control attribute is in effect.
In an input statement, the $ descriptor is ignored.
In an output statement, the following rules apply:
- If the first character of the record is 0, 1, or
ASCII NUL, the $ descriptor is ignored.
- If the first character of the record is a space or
plus sign (+), the $ descriptor suppresses carriage
return (after printing the record).
For terminal I/O, whenever trailing carriage return control is
suppressed by the $ descriptor, a typed response follows output on
the same line.
44.12 - :
(Format Control) Terminates the I/O operation if no more items remain in the I/O list.
44.13 - A
A[w] (Character Editing) If the corresponding I/O list element has a character data type, character data is transmitted. If it has any other data type, Hollerith data is transmitted. The value of "w" must be less than or equal to 32767. On input, transfers "w" characters or Hollerith values from the external record and assigns them to the corresponding list element. If the input value contains fewer characters than "w", it is padded on the right with blanks. If the input value contains excessive characters, it is truncated on the left. If the variable is numeric, the ASCII value of each character is placed in each byte of the variable, starting at the low-order byte. On output, transfers the contents of the corresponding I/O list element to an external field "w" characters long. If the output value contains fewer characters than "w", it is padded on the left with blanks. If the output value contains excess characters, it is truncated on the right (for numbers, the high-order bytes are lost). If the output value is numeric or untyped, the ASCII value of each byte of the variable, starting at the low-order byte, is transferred to the record. The "w" can be omitted and defaults to the number of characters in the character variable or the number of bytes in the numeric variable.
44.14 - BN
(Blank Control Editing) Causes embedded and trailing blanks to be ignored within a numeric input field. Leading blanks are always ignored, and an all blank field is always treated as zero. The BN descriptor must precede all field descriptors to which it applies. It affects all following I, O, Z, F, E, D, and G editing (in the same FORMAT statement) during the execution of an output statement. If the OPEN statement is not used or it is used and BLANK='ZERO' is specified, blanks are converted to zeros. If the OPEN statement is used and either BLANK='NULL' is specified or the BLANK keyword is omitted, blanks are ignored.
44.15 - BZ
(Blank Control Editing) Causes embedded and trailing blanks to be treated as zeros within a numeric input field. (Leading blanks are always ignored.) The BZ descriptor must precede all field descriptors to which it applies. It affects all following I, O, Z, F, E, D, and G editing (in the same FORMAT statement) during the execution of an output statement. If the OPEN statement is not used or it is used and BLANK='ZERO' is specified, blanks are converted to zeros. If the OPEN statement is used and either BLANK='NULL' is specified or the BLANK keyword is omitted, nonleading blanks are treated as zeros. An all blank field is always treated as zero.
44.16 - D
Dw.d (Exponential Editing) On input, performs the same as F format. On output, performs the same as E format, except that the letter D replaces the letter E preceding the exponent and the size of the exponent is fixed at 2.
44.17 - E
Ew.d[Ee] (Exponential Editing) On input, performs the same as F format. On output, E transfers the value of the corresponding I/O list element, rounded to "d" decimal digits and right-justified to an external field "w" characters long. "d" specifies the size of the fraction and "e" specifies the size of the exponent. If the value does not fill the field, leading spaces are inserted; if the value is too large for the field, the entire field is filled with asterisks. The term "w" must be large enough to include all the following: a minus sign (when necessary) or a plus sign (if SP editing is in effect), a zero, a decimal point, "d" digits, and an exponent. Therefore, to accommodate all possible components of the standard form, the term "w" must be greater than or equal to "d"+7; if "e" is present, "w" must be greater than or equal to "d"+"e"+5. However, "w" can be as small as "d"+5 or "d"+"e"+3 and still allow formatting of the value without error, if optional fields are omitted. In this case, the sign is omitted (if the value is positive and SP editing is not in effect) and the zero to the left of the decimal point is also omitted, if necessary.
44.18 - F
Fw.d (Fixed Floating Editing) On input, transfers "w" characters from the external field and assigns them, as a real value, to the corresponding I/O list element (which must be real data type). If the first nonblank character of the external field is a minus sign, the field is treated as a negative value. If the first nonblank character is a plus sign or if no sign appears in the field, the field is treated as a positive value. If the field contains neither a decimal point nor an exponent, it is treated as a real number of w digits, in which the rightmost "d" digits are to the right of the decimal point, with leading zeros assumed if necessary. If the field contains an explicit decimal point, the location of the decimal point overrides the location specified by the field descriptor. If the field contains an exponent, that exponent is used to establish the magnitude of the value before it is assigned to the list element. On output, transfers the value of the corresponding I/O list element, rounded to "d" decimal positions and right-justified, to an external field that is "w" characters long. If the value does not fill the field, leading spaces are inserted; if the value is too large for the field, the entire field is filled with asterisks. The term "w" must be large enough to include all the following: a minus sign (when necessary) or a plus sign (if SP editing is in effect), at least one digit to the left of the decimal point, a decimal point, and "d" digits to the right of the decimal. Therefore, "w" must be greater than or equal to "d"+3.
44.19 - G
Gw.d[Ee] (General Floating Editing)
On input, performs the same as F format.
On output, transfers the value of the corresponding I/O list
element, rounded to d decimal positions, and right-justified, to an
external field that is "w" characters long. The form in which the
value is written is a function of the magnitude of the value. as
given below:
Data Magnitude Effective Conversion
-------------- --------------------
m < 0.1 Ew.d[Ee]
0.1 <= m < 1.0 F(w-4).d, n(' ')
1.0 <= m < 10.0 F(w-4).(d-1), n(' ')
. .
. .
. .
10**d-2 <= m < 10**d-1 F(w-4).1, n(' ')
10**d-1 <= m < 10**d F(w-4).0, n(' ')
m >= 10**d Ew.d[Ee]
The term "w" must be large enough to include all the following: a
minus sign (when necessary) or a plus sign (if SP editing is in
effect), a decimal point, one digit to the left of the decimal
point, "d" digits to the right of the decimal, and either a
4-character or "e"+2-character exponent.
Therefore, "w" must be greater than or equal to "d"+8. If "e" is
present, "w" must be greater than or equal to "d"+"e"+6.
44.20 - H
nHc1c2c2...cn (Hollerith Editing) On input, transfers "n" characters from the external record to the field descriptor itself. The first character appears immediately after the H. Any characters in the field descriptor before the input operation are replaced by the input characters. On output, transfers "n" characters following the letter H from the field descriptor to the external field.
44.21 - I
Iw[.m] (Integer Editing) On input, transfers "w" characters from the external field and assigns them, as an integer value, to the corresponding I/O list element (which must be integer or logical data type). The external data must have the form of an integer constant; it cannot contain a decimal point or exponent field. If the first nonblank character of the external field is a minus sign, the field is treated as a negative value. If the first nonblank character is a plus sign or if no sign appears in the field, the field is treated as a positive value. On output, transfers the value of the corresponding I/O list element, right-justified, to an external field that is w characters long. If the value does not fill the field, leading spaces are inserted; if the value is too large for the field, the entire field is filled with asterisks. "w" must be large enough to include a possible minus sign. If "m" is present, the external field consists of at least "m" digits and, if necessary, is zero filled on the left.
44.22 - L
Lw (Logical Editing) On input, transfers "w" characters from the external field and assigns a logical value to the corresponding I/O list element (which must be integer or logical data type). If the first nonblank characters of the field are T, t, .T, or .t, the value .TRUE. is assigned to the corresponding I/O list element; if the first nonblank characters are F, f, .F, or .f, the value .FALSE. is assigned. An all blank field is assigned the value .FALSE. Any other value in the external field produces an error. The logical constants .TRUE. and .FALSE. are acceptable input forms. On output, transfers either the letter T (if the value of the corresponding I/O list element is .TRUE.) or the letter F (if the value is .FALSE.) to an external field that is w characters long. The letter T or F is in the rightmost position of the field, preceded by w-1 spaces.
44.23 - O
Ow[.m] (Octal Editing) On input, transfers "w" characters from the external field and assigns them, as an octal value, to the corresponding I/O list element (which can be any data type). The external field can contain only the numerals 0 though 7; it cannot contain a sign, a decimal point, or exponent field. An all blank field is treated as a value of zero. If the value of the external field exceeds the range of the corresponding list element, an error occurs. On output, transfers the octal value of the corresponding I/O list element, right-justified, to an external field that is "w" characters long. No signs are transmitted; a negative value is transmitted in internal form. If the value does not fill the field, leading spaces are inserted; if the value is too large for the field, the entire field is filled with asterisks. If "m" is present, the external field consists of at least "m" digits and, if necessary, is zero filled on the left. "w" must be large enough to include a possible minus sign. If "m" is present, the external field consists of at least "m" digits and, if necessary, is zero filled on the left.
44.24 - P
nP (Scale Factor Editing) The scale factor lets you alter, during input or output, the location of the decimal point both in real values and in the two parts of complex values. The "n" is a signed or unsigned integer constant, in the range -128 to 127, that specifies the number of positions to the left or right that the decimal point is to move. A scale factor can appear anywhere in a format specification, but must precede the first F, E, D, or G field descriptor that is to be associated with it and affects all following real field descriptors in the same FORMAT statement (unless another scale factor appears. On input the scale factor of any of the F, E, D, and G field descriptors multiplies the data by 10**-n and assigns it to the corresponding I/O list element. For example a 2P scale factor multiplies an input value by .01; a -2P multiplies an input value by 100. However, if the external field contains an explicit exponent, the scale factor has no effect. E, D, or G field descriptors alter the form in which data is transferred. On input a positive scale factor moves the decimal point to the left and a negative scale factor moves the decimal point to the right; on output, the effect is the reverse.
44. 24.1 - F field descriptor
nPFw.d On output, the value of the I/O list element is multiplied by 10**n before transfer to the external record. Thus, a positive scale factor moves the decimal point to the right; a negative scale factor moves the decimal point to the left. Thus, the F field descriptor alters the magnitude of the data.
44. 24.2 - E field descriptor
nPEw.d On output, the basic real constant part of the I/O list element is multiplied by 10**n, and "n" is subtracted from the exponent. For a positive scale factor, "n" must be less than (d+2) or an output conversion error occurs. Thus, a positive scale factor moves the decimal point to the right and decreases the exponent; a negative scale factor moves the decimal point to the left and increases the exponent.
44. 24.3 - D field descriptor
nPDw.d On output, the basic real constant part of the I/O list element is multiplied by 10**n, and "n" is subtracted from the exponent. For a positive scale factor, "n" must be less than (d+2) or an output conversion error occurs. Thus, a positive scale factor moves the decimal point to the right and decreases the exponent; a negative scale factor moves the decimal point to the left and increases the exponent.
44. 24.4 - G field descriptor
nPGw.d On output, the effect for the G field descriptor is suspended if the magnitude of the data to be output is within the effective range of the descriptor (because the G field descriptor supplies its own scaling function). It functions as an E field descriptor if the magnitude of the data is outside its range. In this case, the scale factor has the same effect as for the E field descriptor.
44.25 - Q
(Query Remaining Character Count)
On input, obtains the number of characters remaining in the input
record to be transferred during a read operation. The following
example uses the Q descriptor to determine the size of the input
record:
READ(5,'(Q,A)') LEN, REC(1:LEN)
On output, the Q descriptor has no effect, except that the
corresponding I/O item is skipped.
44.26 - S
(Normal Signing) Restores the option of producing plus characters (+) in numeric output fields. The S descriptor counters the action of either the SP or SS descriptor by restoring to the processor the discretion of producing plus characters on an optional basis. This descriptor affects fields all that follow it, until an SP or SS is encountered. The S descriptor affects all following I, F, E, D, and G editing (in the same FORMAT statement) during the execution of an output statement.
44.27 - SP
(Always + Signs) Causes the processor to produce a leading plus character (+) in any position where this character would otherwise be optional. This descriptor affects all (suppress + signs) fields that follow it, until an S or SS is encountered. The SP descriptor affects all following I, F, E, D, and G editing (in the same FORMAT statement) during the execution of an output statement.
44.28 - SS
(Suppress Sign) Causes the processor to suppress a leading plus character from any position where this character would otherwise be optional. It has the opposite effect of the SP field descriptor. The SS descriptor affects all following I, F, E, D, and G editing (in the same FORMAT statement) during the execution of an output statement. This descriptor affects all fields that follow it, until an S or SS is encountered.
44.29 - T
Tn (Tab to Position n)
On input, starts the next read operation at the character position
(within the record) indicated by position(n). For example, if an
input statement reads a record containing:
ABC XYZ
and this record is under the control of the FORMAT statement:
10 FORMAT (T7,A3,T1,A3)
On execution, the input statement would first read the characters
XYZ and then read the characters ABC.
On output, starts the next write operation at the character
position n in the external record.
The position specified must be an integer in the range 1 through
the size of the record.
44.30 - TL
TLn (Tab Left n Positions) Indicates that the next character to be transferred to or from a record is the "n"th character to the left of the current character. The value of "n" must be greater than or equal to 1. If the value of "n" is greater than or equal to the current character position, the first character in the record is specified.
44.31 - TR
TRn (Tab Right n Positions) Indicates that the next character to be transferred to or from a record is the "n"th character to the right of the current character. The value of "n" must be greater than or equal to 1.
44.32 - X
nX (Skip Right n Positions) The X field descriptor functions the same as the TR field descriptor. On input, starts the next read operation after skipping "n" character positions. If X is the last format item, it will have no effect. On output, starts the next write operation after skipping the "n" character positions. Intervening characters are not written over. If X is the last format code executed, it will have no effect. The position specified must be an integer in the range 1 through the size of the record.
44.33 - Z
Zw[.m] (Hexadecimal Editing) On input, transfers w characters from the external field and assigns them, as a hexadecimal value, to the corresponding I/O list element (which can be any data type). The input value must be in the form of a hexadecimal constant. Each input character corresponds to four bits in the variable, high order to low order. If the input value contains more characters than specified by "w", an error occurs. If the input value contains fewer characters, it is padded with zeros on the left before being converted. On output, transfers the number of hexadecimal characters specified by "w" from a variable or constant to the record. The rightmost characters represent the low-order bits. If the variable or constant contains more characters than "w" specifies, the value is set to all asterisks (an error occurs). If the variable or constant contains fewer characters, the value is padded on the left with spaces. "m" specifies the minimum number of characters (with zero padding) that the value can contain. "m" must be an integer in the range 1 through 255. "w" must be large enough to include a possible minus sign. If "m" is present, the external field consists of at least "m" digits and, if necessary, is zero filled on the left.
| 45 - Intrinsic Procedures |
45.1 - ABS
ABS (number)
A function that returns the absolute value of the argument. The
absolute value of a complex number, (X,Y), is the real value:
(X**2 + Y**2)**(1/2).
+------+---------+----------+------------+-------------+
| Args | Generic | Specific | Argument | Result Type |
+------+---------+----------+------------+-------------+
| 1 | ABS | IIABS | INTEGER*2 | INTEGER*2 |
| | | JIABS | INTEGER*4 | INTEGER*4 |
| | | ABS | REAL*4 | REAL*4 |
| | | DABS | REAL*8 | REAL*8 |
| | | QABS | REAL*16 | REAL*16 |
| | | CABS | COMPLEX*8 | REAL*4 |
| | | CDABS | COMPLEX*16 | REAL*8 |
| | | ZABS | COMPLEX*16 | REAL*8 |
+------+---------+----------+------------+-------------+
See also the IABS intrinsic function.
45.2 - ACOS
ACOS (number) A function that returns the arc cosine of the argument in radians. The absolute value of the argument must be less than or equal to 1. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | ACOS | ACOS | REAL*4 | REAL*4 | | | | DACOS | REAL*8 | REAL*8 | | | | QACOS | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
45.3 - ACOSD
ACOSD (real-number) A function that returns the arc cosine of the argument in degrees. The value of the argument must be between 0 (exclusive) and 1 (inclusive). +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | ACOSD | ACOSD | REAL*4 | REAL*4 | | | | DACOSD | REAL*8 | REAL*8 | | | | QACOSD | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
45.4 - AIMAG
AIMAG (complex-number) A function that returns the imaginary part of a complex number. The argument must be a COMPLEX*8 data type. The result is a REAL*4 data type.
45.5 - AINT
AINT (real-number) A function that returns the largest integer whose absolute value does not exceed the absolute value of the argument and has the same sign as the argument. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | AINT | AINT | REAL*4 | REAL*4 | | | | DINT | REAL*8 | REAL*8 | | | | QINT | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+ See also the INT intrinsic function.
45.6 - AMAX0
AMAX0 (number, number, ...) A function that returns the greatest of the values specified in the argument list. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | n | AMAX0 | AIMAX0 | INTEGER*2 | REAL*4 | | | | AJMAX0 | INTEGER*4 | REAL*4 | +------+---------+----------+------------+-------------+ See also the MAX intrinsic function.
45.7 - AMIN0
AMIN0 (number, number, ...) A function that returns the lowest of the values specified in the argument list. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | n | AMIN0 | AIMIN0 | INTEGER*2 | REAL*4 | | | | AJMIN0 | INTEGER*4 | REAL*4 | +------+---------+----------+------------+-------------+ See also the MIN intrinsic function.
45.8 - ANINT
ANINT (real-number) A function that returns the value of the integer nearest to the value of the argument. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | ANINT | ANINT | REAL*4 | REAL*4 | | | | DNINT | REAL*8 | REAL*8 | | | | QNINT | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+ [x] is defined as the largest integer whose magnitude does not exceed the magnitude of x and whose sign is the same as that of x. See also the NINT intrinsic function.
45.9 - ASIN
ASIN (real-number) A function that returns the arc sine of the argument in radians. The absolute value of the argument must be less than or equal to 1. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | ASIN | ASIN | REAL*4 | REAL*4 | | | | DASIN | REAL*8 | REAL*8 | | | | QASIN | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
45.10 - ASIND
ASIND (real-number) A function that returns the arc sine of the argument in degrees. The value of the argument must be between 0 (exclusive) and 1 (inclusive). +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | ASIND | ASIND | REAL*4 | REAL*4 | | | | DASIND | REAL*8 | REAL*8 | | | | QASIND | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
45.11 - ATAN
ATAN (real-number) A function that returns the arc tangent of the argument in radians. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | ATAN | ATAN | REAL*4 | REAL*4 | | | | DATAN | REAL*8 | REAL*8 | | | | QATAN | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
45.12 - ATAND
ATAND (real-number) A function that returns the arc tangent of the argument in degrees. The value of the argument must be greater than 0. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | ATAND | ATAND | REAL*4 | REAL*4 | | | | DATAND | REAL*8 | REAL*8 | | | | QATAND | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
45.13 - ATAN2
ATAN2 (real-number, real-number) A function that returns the arc tangent of the quotient of the two arguments in radians. If both arguments are zero, the result is undefined. If the first argument is positive, the result is positive. If the first argument is negative, the result is negative. If the first argument is zero, the result is zero. If the second argument is zero, the absolute value of the result is pi/2. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | ATAN2 | ATAN2 | REAL*4 | REAL*4 | | | | DATAN2 | REAL*8 | REAL*8 | | | | QATAN2 | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+ The range of the result is -pi < result < pi.
45.14 - ATAN2D
ATAN2D (real-number, real-number) A function that returns the arc tangent of the quotient of the two arguments in degrees. If both arguments are zero, the result is undefined. If the first argument is positive, the result is positive. If the first argument is negative, the result is negative. If the first argument is zero, the result is zero. If the second argument is zero, the absolute value of the result is 90 degrees. The value of the argument must be greater than zero. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | ATAN2D | ATAN2D | REAL*4 | REAL*4 | | | | DATAN2D | REAL*8 | REAL*8 | | | | QATAN2D | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+ The range of the result is -180 degrees < result < 180 degrees.
45.15 - BTEST
BTEST (integer, position) A function that returns a logical value of true if the bit within the integer specified by position is set to 1. The low-order bit is position 0. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | BTEST | BITEST | INTEGER*2 | INTEGER*2 | | | | BJTEST | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+
45.16 - CHAR
CHAR (integer) A function that returns the character associated with the ASCII value specified by the argument. The argument must be BYTE, LOGICAL*1, LOGICAL*2, LOGICAL*4, INTEGER*1, INTEGER*2, or INTEGER*4 in data type. The result must be CHARACTER in type. The input value must be in the range 0 to 255.
45.17 - CMPLX
CMPLX (number [,number]) A function that converts the argument(s) into a COMPLEX*8 value. If one argument is specified, the argument is converted into the real part of the complex value and the imaginary part becomes zero. If two arguments are specified, the first argument is converted into the real part of the complex value and the second argument is converted into the imaginary part of the complex value. If two arguments are specified, they must have the same data type. +-------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +-------+---------+----------+------------+-------------+ | 1,2 | CMPLX | CMPLX | INTEGER*2 | COMPLEX*8 | | 1,2 | | CMPLX | INTEGER*4 | COMPLEX*8 | | 1,2 | | CMPLX | REAL*4 | COMPLEX*8 | | 1,2 | | CMPLX | REAL*8 | COMPLEX*8 | | 1,2 | | CMPLX | REAL*16 | COMPLEX*8 | | 1 | | CMPLX | COMPLEX*8 | COMPLEX*8 | | 1 | | CMPLX | COMPLEX*16 | COMPLEX*8 | +-------+---------+----------+------------+-------------+
45.18 - CONJG
CONJG (complex-number) A function that returns the complex conjugate of the argument. If the argument is (X,Y), its complex conjugate is (X,-Y). +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | CONJG | CONJG | COMPLEX*8 | COMPLEX*8 | | | | DCONJG | COMPLEX*16 | COMPLEX*16 | +------+---------+----------+------------+-------------+
45.19 - COS
COS (number) A function that returns the cosine of the argument. The argument must be in radians; it is treated modulo 2*pi. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | COS | COS | REAL*4 | REAL*4 | | | | DCOS | REAL*8 | REAL*8 | | | | QCOS | REAL*16 | REAL*16 | | | | CCOS | COMPLEX*8 | COMPLEX*8 | | | | CDCOS | COMPLEX*16 | COMPLEX*16 | | | | ZCOS | COMPLEX*16 | COMPLEX*16 | +------+---------+----------+------------+-------------+
45.20 - COSD
COSD (number) A function that returns the cosine of the argument. The argument must be in degrees; it is treated modulo 360. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | COSD | COSD | REAL*4 | REAL*4 | | | | DCOSD | REAL*8 | REAL*8 | | | | QCOSD | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
45.21 - COSH
COSH (real-number) A function that returns the hyperbolic cosine of the argument. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | COSH | COSH | REAL*4 | REAL*4 | | | | DCOSH | REAL*8 | REAL*8 | | | | QCOSH | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
45.22 - DATE
CALL DATE (buf)
buf Is a 9-byte variable, array, array element,
or character substring.
A subroutine that gets the current date as set within the system.
The date is returned as a 9-byte ASCII character string as follows:
dd-mmm-yy
If "buf" is numeric type and smaller than 9 bytes, data corruption
can occur.
If "buf" is character type, its associated length is passed to the
subroutine. If "buf" is smaller than 9 bytes, the subroutine
truncates the date to fit in the specified length. Note that if a
CHARACTER array is passed, the subroutine stores the date in the
first array element, using the element length, not the length of
the entire array. For example, consider the following:
CHARACTER*1 DAY(9)
.
.
.
CALL DATE(DAY)
The length of the first array element in CHARACTER array DAY is
passed to the DATE subroutine. The subroutine then truncates the
date to fit into the one-character element, producing an incorrect
result.
45.23 - DATE_AND_TIME
DATE_AND_TIME ([date] ,[time] ,[zone] ,[values])
Returns character data on the real-time clock and date in a form
compatible with the representations defined in Standard ISO
8601:1988.
Optional arguments:
o The "date" must be scalar and of type character; its
length must be at least 8 to contain the complete value. Its
leftmost 8 characters are set to a value of the form CCYYMMDD,
where:
CC is the century
YY is the year within the century
MM is the month within the year
DD is the day within the month
o The "time" must be scalar and of type character; its
length must be at least 10 to contain the complete value. Its
leftmost 10 characters are set to a value of the form
hhmmss.sss, where:
hh is the hour of the day
mm is the minutes of the hour
ss.sss is the seconds and milliseconds of the minute
o The "zone" must be scalar and of type character; its
length must be at least 5 to contain the complete value. Its
leftmost 5 characters are set to a value of the form + or -
hhmm, where "hh" and "mm" are the time difference with respect
to Coordinated Universal Time (UTC) in hours and parts of an
hour expressed in minutes, respectively.
o The "values" must be an array of type INTEGER*4.
Its size must be at least 8. The values returned in "values"
are as follows:
values (1) is the 4-digit year
values (2) is the month of the year
values (3) is the day of the year
values (4) is the time difference with respect to
Coordinated Universal Time (UTC) in minutes
values (5) is the hour of the day (range 0 to 23)
values (6) is the minutes of the hour (range 0 to 59).
values (7) is the seconds of the minute (range 0 to 59).
values (8) is the milliseconds of the second (range 0 to 999).
Example:
Consider the following example executed on 1997 April 23 at
13:23:30.5 in a timezone one hour later than UTC:
INTEGER*4 DATE_TIME (8)
CHARACTER*12 REAL_CLOCK (3)
CALL DATE_AND_TIME (REAL_CLOCK (1), REAL_CLOCK (2),
+ REAL_CLOCK (3), DATE_TIME)
This assigns the value '19970423' to REAL_CLOCK (1), the value
'132330.500' to REAL_CLOCK (2), and the value '+0100' to REAL_CLOCK
(3). The following values are assigned to DATE_TIME: 1997, 4, 23,
60, 13, 23, 30, and 500.
45.24 - DBLE
DBLE (number) A function that converts the argument into a REAL*8 value. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | DBLE | DBLE | INTEGER*2 | REAL*8 | | | | DBLE | INTEGER*4 | REAL*8 | | | | DBLE | REAL*4 | REAL*8 | | | | DBLE | REAL*8 | REAL*8 | | | | DBLEQ | REAL*16 | REAL*8 | | | | DBLE | COMPLEX*8 | REAL*8 | | | | DBLE | COMPLEX*16 | REAL*8 | +------+---------+----------+------------+-------------+
45.25 - DCMPLX
DCMPLX (number [,number]) A function that converts the argument(s) into a COMPLEX*16 value. If one argument is specified, the argument is converted into the real part of the complex value and the imaginary part becomes zero. If two arguments are specified, the first argument is converted into the real part of the complex value and the second argument is converted into the imaginary part of the complex value. If two arguments are specified, they must have the same data type. +-------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +-------+---------+----------+------------+-------------+ | 1,2 | DCMPLX | DCMPLX | INTEGER*2 | COMPLEX*16 | | 1,2 | | DCMPLX | INTEGER*4 | COMPLEX*16 | | 1,2 | | DCMPLX | REAL*4 | COMPLEX*16 | | 1,2 | | DCMPLX | REAL*8 | COMPLEX*16 | | 1,2 | | DCMPLX | REAL*16 | COMPLEX*16 | | 1 | | DCMPLX | COMPLEX*8 | COMPLEX*16 | | 1 | | DCMPLX | COMPLEX*16 | COMPLEX*16 | +-------+---------+----------+------------+-------------+
45.26 - DFLOAT
DFLOAT (integer) A function that converts the argument into a REAL*8 value. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | DFLOAT | DFLOTI | INTEGER*2 | REAL*8 | | | | DFLOTJ | INTEGER*4 | REAL*8 | +------+---------+----------+------------+-------------+
45.27 - DIM
DIM (number, number) A function that returns the value of the first argument minus the minimum (MIN) of the two arguments. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | DIM | IIDIM | INTEGER*2 | INTEGER*2 | | | | JIDIM | INTEGER*4 | INTEGER*4 | | | | DIM | REAL*4 | REAL*4 | | | | DDIM | REAL*8 | REAL*8 | | | | QDIM | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+ See also the IDIM intrinsic function.
45.28 - DIMAG
DIMAG (imaginary) A function that returns the imaginary part of a complex number. The argument must be a COMPLEX*16 data type. The result is a REAL*8 data type.
45.29 - DPROD
DPROD (number, number) A function that returns the product of two real values using the next higher precision data type. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | DPROD | DPROD | REAL*4 | REAL*8 | | | | none | REAL*8 | REAL*16 | +------+---------+----------+------------+-------------+ 3 DREAL DREAL (complex-number) A function that returns the real part of a complex number. The argument must be a COMPLEX*16 data type. The result is a REAL*8 data type.
45.30 - EXIT
EXIT ([status]) A subroutine that terminates the program, closes all files, and returns you to DCL command level. The optional argument specifies the exit status of the program and defaults to SS$_NORMAL (a value of 1 -- normal completion of program).
45.31 - EXP
EXP (exponent) A function that returns e**X, where X is the value of the argument. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | EXP | EXP | REAL*4 | REAL*4 | | | | DEXP | REAL*8 | REAL*8 | | | | QEXP | REAL*16 | REAL*16 | | | | CEXP | COMPLEX*8 | COMPLEX*8 | | | | CDEXP | COMPLEX*16 | COMPLEX*16 | | | | ZEXP | COMPLEX*16 | COMPLEX*16 | +------+---------+----------+------------+-------------+
45.32 - FLOAT
FLOAT (integer) A function that converts the argument to a REAL*4 value. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | FLOAT | FLOATI | INTEGER*2 | REAL*4 | | | | FLOATJ | INTEGER*4 | REAL*4 | +------+---------+----------+------------+-------------+
45.33 - IABS
IABS (number) A function that returns the absolute value of the argument. The absolute value of a complex number, (X,Y), is the real value (X**2 + Y**2)**(1/2). +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | IABS | IIABS | INTEGER*2 | INTEGER*2 | | | | JIABS | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+ See also the ABS intrinsic function.
45.34 - IAND
IAND (integer, integer) A function that performs a logical AND of the arguments on a bit by bit basis. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | IAND | IIAND | INTEGER*2 | INTEGER*2 | | | | JIAND | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+
45.35 - IARGCOUNT
IARGCOUNT () A function that returns the count of actual arguments passed to the current routine. The result is an INTEGER*4 data type. Note that functions with a type of CHARACTER, COMPLEX*16, or REAL*16 have an extra argument added that is used to return the function value.
45.36 - IARGPTR
IARGPTR () A function that returns a pointer to the actual argument list for the current routine. The result is an INTEGER*4 data type. The actual argument list is an array of INTEGER*4 values, the first of which contains the argument count.
45.37 - IBCLR
IBCLR (integer, position) A function that returns the value of the first argument with the specified bit set to 0. The low-order bit is position 0. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | IBCLR | IIBCLR | INTEGER*2 | INTEGER*2 | | | | JIBCLR | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+
45.38 - IBITS
IBITS (integer, start-position, length) A function that returns the value of the bits of the first argument specified by start-position and number of bits. The low-order bit is position 0. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 3 | IBITS | IIBITS | INTEGER*2 | INTEGER*2 | | | | JIBITS | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+
45.39 - IBSET
IBSET (integer, position) A function that returns the value of the first argument with the specified bit set to 1. The low-order bit is position 0. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | IBSET | IIBSET | INTEGER*2 | INTEGER*2 | | | | JIBSET | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+
45.40 - ICHAR
ICHAR (character) A function that returns the ASCII value of the argument. The argument must be a character expression with a length of one. The result is an INTEGER*4 data type.
45.41 - IDATE
IDATE (month,day,year) A subroutine that returns three values representing the current date. The arguments must be defined as integers or integer array elements. The month is represented as the number of the month (1 - 12). The day is represented as the day of the month. The year is represented as the last two digits of the year.
45.42 - IDIM
IDIM (number, number) A function that returns the value of the first argument minus the minimum (MIN) of the two arguments. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | IDIM | IIDIM | INTEGER*2 | INTEGER*2 | | | | JIDIM | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+ See also the DIM intrinsic function.
45.43 - IDINT
IDINT (number) A function that returns the largest integer whose absolute value does not exceed the absolute value of the argument and has the same sign as the argument. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | IDINT | IIDINT | REAL*8 | INTEGER*2 | | | | JIDINT | REAL*8 | INTEGER*4 | +------+---------+----------+------------+-------------+ The function returns an INTEGER*4 value if the /I4 command qualifier is in effect; otherwise it returns an INTEGER*2 value. See also the INT intrinsic function.
45.44 - IDNINT
IDNINT (real-number) A function that returns the value of the integer nearest to the value of the argument. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | IDNINT | IIDNNT | REAL*8 | INTEGER*2 | | | | JIDNNT | REAL*8 | INTEGER*4 | +------+---------+----------+------------+-------------+ The function returns an INTEGER*4 value if the /I4 command qualifier is in effect; otherwise it returns an INTEGER*2 value. See also the NINT intrinsic function.
45.45 - IEOR
IEOR (integer, integer) A function that performs an exclusive OR of the arguments on a bit by bit basis. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | IEOR | IIEOR | INTEGER*2 | INTEGER*2 | | | | JIEOR | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+
45.46 - IFIX
IFIX (real4-number) A function that converts a real number to an integer. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | IFIX | IIFIX | REAL*4 | INTEGER*2 | | | | JIFIX | REAL*4 | INTEGER*4 | +------+---------+----------+------------+-------------+ The function returns an INTEGER*4 value if the /I4 command qualifier is in effect; otherwise it returns an INTEGER*2 value. IIFIX can also be spelled HFIX (to comply with the MIA standard).
45.47 - IMAG
IMAG (complex-number) A function that returns the imaginary part of a complex number. +------+-----------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+-----------+----------+------------+-------------+ | 1 | IMAG | AIMAG | COMPLEX*8 | REAL*4 | | | | DIMAG | COMPLEX*16 | REAL*8 | +--------------------------------------------------------+
45.48 - INDEX
INDEX (string, substring) A function that searches a string for the first occurrence of a substring and returns the starting position of the substring as an INTEGER*4 value.
45.49 - INT
INT (number) A function that returns the largest integer whose absolute value does not exceed the absolute value of the argument and has the same sign as the argument. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | INT | IINT | REAL*4 | INTEGER*2 | | | | JINT | REAL*4 | INTEGER*4 | | | | IIDINT | REAL*8 | INTEGER*2 | | | | JIDINT | REAL*8 | INTEGER*4 | | | | IIQINT | REAL*16 | INTEGER*2 | | | | JIQINT | REAL*16 | INTEGER*4 | | | | JIQINT | COMPLEX*8 | INTEGER*2 | | | | JIQINT | COMPLEX*8 | INTEGER*4 | | | | JIQINT | COMPLEX*16 | INTEGER*2 | | | | JIQINT | COMPLEX*16 | INTEGER*4 | +------+---------+----------+------------+-------------+ The function returns an INTEGER*4 value if the /I4 command qualifier is in effect; otherwise it returns an INTEGER*2 value. See also the AINT, IDINT, and IQINT.
45.50 - IOR
IOR (integer, integer) A function that performs a logical OR of the arguments on a bit by bit basis (bitwise inclusive OR). +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | IOR | IIOR | INTEGER*2 | INTEGER*2 | | | | JIOR | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+
45.51 - IQINT
IQINT (number) A function that returns the largest integer whose absolute value does not exceed the absolute value of the argument and has the same sign as the argument. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | IQINT | IIQINT | REAL*16 | INTEGER*2 | | | | JIQINT | REAL*16 | INTEGER*4 | +------+---------+----------+------------+-------------+ The function returns an INTEGER*4 value if the /I4 command qualifier is in effect; otherwise it returns an INTEGER*2 value. See also the INT intrinsic function.
45.52 - IQNINT
IQNINT (number) A function that returns the value of the integer nearest to the value of the argument. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | IQNINT | IIQNNT | REAL*16 | INTEGER*2 | | | | JIQNNT | REAL*16 | INTEGER*4 | +------+---------+----------+------------+-------------+ The function returns an INTEGER*4 value if the /I4 command qualifier is in effect; otherwise it returns an INTEGER*2 value. See also the NINT intrinsic function.
45.53 - ISHFT
ISHFT (a1,a2) Bitwise logical shift - a1 is an integer, a2 is the no-of-positions A function that logically shifts a1 left (if a2 is positive) or right (if a2 is negative) by ABS(a2) bits. If ABS(a2) is greater than or equal to the length in bits of a1, the result is 0. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | ISHFT | IISHFT | INTEGER*2 | INTEGER*2 | | | | JISHFT | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+
45.54 - ISHFTC
ISHFTC (a1,a2,a3) Bitwise circular shift - a1 is an integer, a2 is no-of-positions, and a3 is no-of-bits A function that circularly shifts the rightmost a3 bits of a1 by a2 places; bits in a1 beyond the value specified by a3 are unaffected. The bits pushed off the left end replace those shifted from the right end. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 3 | ISHFTC | IISHFTC | INTEGER*2 | INTEGER*2 | | | | JISHFTC | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+
45.55 - ISIGN
ISIGN (value, sign) A function that assigns the sign of the second argument to the absolute value of the first. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | ISIGN | IISIGN | INTEGER*2 | INTEGER*2 | | | | JISIGN | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+ See also the SIGN intrinsic function.
45.56 - LEN
LEN (character) A function that returns the number of characters in the argument. The argument must be a character expression. The result is an INTEGER*4 value.
45.57 - LGE
LGE (character, character) A function that returns a value of true if the first character string is greater than or equal to the second character string. The ASCII collating sequence determines the relationship between the arguments. The arguments must be character expressions. The result is a LOGICAL*4 value.
45.58 - LGT
LGT (character, character) A function that returns a value of true if the first character string is greater than the second character string. The arguments must be character expressions. The ASCII collating sequence determines the relationship between the arguments.
45.59 - LLE
LLE (character, character) A function that returns a value of true if the first character string is less than or equal to the second character string. The arguments must be character expressions. The ASCII collating sequence determines the relationship between the arguments.
45.60 - LLT
LLT (character, character) A function that returns a value of true if the first character string is less than the second character string. The arguments must be character expressions. The ASCII collating sequence determines the relationship between the arguments.
45.61 - LOC
LOC (arg) Returns the actual storage address of a data element. The argument can be any data value. The result is an INTEGER*4 data type. In the case of global symbols, LOC returns the value of the symbol rather than its address. The LOC intrinsic serves the same purpose as the %LOC built-in function.
45.62 - LOG
LOG (number) A function that returns the natural log (base e) of the argument. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | LOG | ALOG | REAL*4 | REAL*4 | | | | DLOG | REAL*8 | REAL*8 | | | | QLOG | REAL*16 | REAL*16 | | | | CLOG | COMPLEX*8 | COMPLEX*8 | | | | CDLOG | COMPLEX*16 | COMPLEX*16 | | | | ZLOG | COMPLEX*16 | COMPLEX*16 | +------+---------+----------+------------+-------------+ The argument for ALOG and DLOG must be greater than zero. The argument for CLOG and CDLOG must not be (0.,0.).
45.63 - LOG10
LOG10 (number) A function that returns the common log (base 10) of the argument. The argument must be greater than zero. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | LOG10 | ALOG10 | REAL*4 | REAL*4 | | | | DLOG10 | REAL*8 | REAL*8 | | | | QLOG10 | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+ The argument for ALOG10, DLOG10, and QLOG10 must be greater than zero.
45.64 - MAX
MAX (number, number, ...) A function that returns the greatest of the values specified in the argument list. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | n | MAX | IMAX0 | INTEGER*2 | INTEGER*2 | | | | JMAX0 | INTEGER*4 | INTEGER*4 | | | | AMAX1 | REAL*4 | REAL*4 | | | | DMAX1 | REAL*8 | REAL*8 | | | | QMAX1 | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+ See also the AMAX0, MAX0, and MAX1 intrinsic functions.
45.65 - MAX0
MAX0 (number, number, ...) A function that returns the greatest of the values specified in the argument list. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | n | MAX0 | IMAX0 | INTEGER*2 | INTEGER*2 | | | | JMAX0 | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+ See also the MAX intrinsic function.
45.66 - MAX1
MAX1 (number, number, ...) A function that returns the greatest of the values specified in the argument list. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | n | MAX1 | IMAX1 | REAL*4 | INTEGER*2 | | | | JMAX1 | REAL*4 | INTEGER*4 | +------+---------+----------+------------+-------------+ The function returns an INTEGER*4 value if the /I4 command qualifier is in effect; otherwise, it returns an INTEGER*2 value. See also the MAX intrinsic function.
45.67 - MIN
MIN (number, number, ...) A function that returns the lowest of the values specified in the argument list. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | n | MIN | IMIN0 | INTEGER*2 | INTEGER*2 | | | | JMIN0 | INTEGER*4 | INTEGER*4 | | | | AMIN1 | REAL*4 | REAL*4 | | | | DMIN1 | REAL*8 | REAL*8 | | | | QMIN1 | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+ See also the AMIN0, MIN0, and MIN1 intrinsic functions.
45.68 - MIN0
MIN0 A function that returns the lowest of the values specified in the argument list. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | n | MIN0 | IMIN0 | INTEGER*2 | INTEGER*2 | | | | JMIN0 | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+ See also the MIN intrinsic function.
45.69 - MIN1
MIN1 A function that returns the lowest of the values specified in the argument list. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | n | MIN1 | IMIN1 | REAL*4 | INTEGER*2 | | | | JMIN1 | REAL*4 | INTEGER*4 | +------+---------+----------+------------+-------------+ The function returns an INTEGER*4 value if the /I4 command qualifier is in effect; otherwise it returns an INTEGER*2 value. See also the MIN intrinsic function.
45.70 - MOD
MOD (dividend, divisor) A function that divides the first argument by the second and returns the remainder. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | MOD | IMOD | INTEGER*2 | INTEGER*2 | | | | JMOD | INTEGER*4 | INTEGER*4 | | | | AMOD | REAL*4 | REAL*4 | | | | DMOD | REAL*8 | REAL*8 | | | | QMOD | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
45.71 - MVBITS
MVBITS (integer1, start1, len, integer2, start2)
A subroutine that moves bits from one location to another. Specify
the arguments as follows:
integer1 An integer variable or array element that contains
the bits to be transferred.
start1 An integer expression that identifies the position
of the first bit within integer1 to be transferred.
len An integer expression that specifies the number of
bits to be transferred.
integer2 An integer variable or array element that identifies
the location to which the bits are being transferred.
start2 An integer expression that identifies the starting
position within integer2 for the bits being transferred.
The low-order bit in either integer is position 0. The last bit
position in either integer must not exceed 31.
45.72 - NINT
NINT (real-number) A function that returns the value of the integer nearest to the value of the argument. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | NINT | ININT | REAL*4 | INTEGER*2 | | | | JNINT | REAL*4 | INTEGER*4 | | | | IIDNNT | REAL*8 | INTEGER*2 | | | | JIDNNT | REAL*8 | INTEGER*4 | | | | IIQNNT | REAL*16 | INTEGER*2 | | | | JIQNNT | REAL*16 | INTEGER*4 | +------+---------+----------+------------+-------------+ The function returns an INTEGER*4 value if the /I4 command qualifier is in effect; otherwise it returns an INTEGER*2 value. See also the ANINT, IDNINT, and IQNINT intrinsic functions.
45.73 - NOT
NOT (integer) A function that complements each bit of the argument. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | NOT | INOT | INTEGER*2 | INTEGER*2 | | | | JNOT | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+
45.74 - NWORKERS
The intrinsic function NWORKERS requires no arguments and returns
an INTEGER*4 value that represents the total number of processes
executing an application. NWORKERS will be most useful in parallel
applications for determining the size of the iteration segments to
be executed by the parallel processes. For example:
CPAR$ DO_PARALLEL (N+NWORKERS( )-1) / NWORKERS( )
DO I = 1, N
...
ENDDO
In this example, the size of each iteration segment to be executed
in the parallel processes would be the total number of iterations
in the parallel DO loop divided by the number of available
processes. (Specifying "(N+NWORKERS( )-1)" guarantees that you can
never get an illegal segment value of 0.)
By using NWORKERS as a variable in the calculation to establish
iteration segment size, the segment size adjusts automatically when
the application is run on systems with varying numbers of available
processors.
45.75 - QEXT
QEXT (number) A function that converts the argument to a REAL*16 value. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | QEXT | QEXT | INTEGER*2 | REAL*16 | | | | QEXT | INTEGER*4 | REAL*16 | | | | QEXT | REAL*4 | REAL*16 | | | | QEXTD | REAL*8 | REAL*16 | | | | QEXT | REAL*16 | REAL*16 | | | | QEXT | COMPLEX*8 | REAL*16 | | | | QEXT | COMPLEX*16 | REAL*16 | +------+---------+----------+------------+-------------+
45.76 - QFLOAT
QFLOAT (integer) A function that converts an integer value to a REAL*16 value. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | QFLOAT | QFLOAT | INTEGER*2 | REAL*16 | | | | QFLOAT | INTEGER*4 | REAL*16 | +------+---------+----------+------------+-------------+
45.77 - RAN
RAN (seed) A function that returns a different REAL*4 number between 0.0 (inclusive) and 1.0 (exclusive) each time it is invoked. The argument must be an INTEGER*4 variable or array element. For best results, you should initialize the argument to a large, odd value before invoking RAN the first time. To generate different sets of random values, initialize the seed to a different value on each run. Do not modify the seed during a run.
45.78 - REAL
REAL (number) A function that converts the argument to a real value. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | REAL | FLOATI | INTEGER*2 | REAL*4 | | | | FLOATJ | INTEGER*4 | REAL*4 | | | | REAL | REAL*4 | REAL*4 | | | | SNGL | REAL*8 | REAL*4 | | | | SNGLQ | REAL*16 | REAL*4 | | | | REAL | COMPLEX*8 | REAL*4 | | | | REAL | COMPLEX*16 | REAL*4 | +------+---------+----------+------------+-------------+
45.79 - SECNDS
SECNDS (real-number) A subroutine that returns the number of seconds since midnight minus the value of the argument. The argument must be a REAL*4 data type. The return value is a REAL*4 data type. The time returned is accurate to .01 seconds.
45.80 - SIGN
SIGN (value, sign) A function that assigns the sign of the second argument to the absolute value of the first. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | SIGN | IISIGN | INTEGER*2 | INTEGER*2 | | | | JISIGN | INTEGER*4 | INTEGER*4 | | | | SIGN | REAL*4 | REAL*4 | | | | DSIGN | REAL*8 | REAL*8 | | | | QSIGN | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+ See also the ISIGN intrinsic function.
45.81 - SIN
SIN (number) A function that returns the sine of the argument. The argument must be in radians; it is treated modulo 2*pi. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | SIN | SIN | REAL*4 | REAL*4 | | | | DSIN | REAL*8 | REAL*8 | | | | QSIN | REAL*16 | REAL*16 | | | | CSIN | COMPLEX*8 | COMPLEX*8 | | | | CDSIN | COMPLEX*16 | COMPLEX*16 | | | | ZSIN | COMPLEX*16 | COMPLEX*16 | +------+---------+----------+------------+-------------+
45.82 - SIND
SIND (number) A function that returns the sine of the argument. The argument must be in degrees; it is treated modulo 360. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | SIND | SIND | REAL*4 | REAL*4 | | | | DSIND | REAL*8 | REAL*8 | | | | QSIND | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
45.83 - SINH
SINH (number) A function that returns the hyperbolic sine of the argument. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | SINH | SINH | REAL*4 | REAL*4 | | | | DSINH | REAL*8 | REAL*8 | | | | QSINH | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
45.84 - SIZEOF
SIZEOF (arg) A function that returns the number of bytes of storage used by the argument. +------+---------+----------+---------------------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+---------------------------+-------------+ | 1 | -- | SIZEOF | Anything with a valid | INTEGER*4 | | | | | data type, except assumed-| | | | | | size arrays or passed- | | | | | | length characters. | | +------+---------+----------+---------------------------+-------------+
45.85 - SQRT
SQRT (number) A function that returns the square root of the argument. The result is the principal value, with the real part greater than or equal to zero. If the real part is zero, the result is the principal value, with the imaginary part greater than or equal to zero. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | SQRT | SQRT | REAL*4 | REAL*4 | | | | DSQRT | REAL*8 | REAL*8 | | | | QSQRT | REAL*16 | REAL*16 | | | | CSQRT | COMPLEX*8 | COMPLEX*8 | | | | CDSQRT | COMPLEX*16 | COMPLEX*8 | | | | ZSQRT | COMPLEX*16 | COMPLEX*8 | +------+---------+----------+------------+-------------+ The argument for SQRT and DSQRT must be greater than or equal to zero. The argument for QSQRT must be greater than zero.
45.86 - TAN
TAN (real-number) A function that returns the tangent of the argument. The argument must be in radians; it is treated modulo 2*pi. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | TAN | TAN | REAL*4 | REAL*4 | | | | DTAN | REAL*8 | REAL*8 | | | | QTAN | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
45.87 - TAND
TAND (real-number) A function that returns the tangent of the argument. The argument must be in degrees; it is treated modulo 360. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | TAND | TAND | REAL*4 | REAL*4 | | | | DTAND | REAL*8 | REAL*8 | | | | QTAND | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
45.88 - TANH
TANH (real-number) A function that returns the hyperbolic tangent of the argument. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | TANH | TANH | REAL*4 | REAL*4 | | | | DTANH | REAL*8 | REAL*8 | | | | QTANH | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+
45.89 - TIME
CALL TIME (buf)
buf Is an 8-byte variable, array, array element,
or character substring.
A subroutine that places the current time in 24-hour ASCII format
in the argument. The time is returned as an 8-byte ASCII character
string having the following form:
hh:mm:ss
A 24-hour clock is used.
If "buf" is numeric type and smaller than 8 bytes, data corruption
can occur.
If "buf" is character type, its associated length is passed to the
subroutine. If "buf" is smaller than 8 bytes, the subroutine
truncates the date to fit in the specified length. Note that if a
CHARACTER array is passed, the subroutine stores the time in the
first array element, using the element length, not the length of
the entire array. For example, consider the following:
CHARACTER*1 HOUR(8)
.
.
.
CALL TIME(HOUR)
The length of the first array element in CHARACTER array HOUR is
passed to the TIME subroutine. The subroutine then truncates the
time to fit into the one-character element, producing an incorrect
result.
45.90 - IxAMAX
INTEGER*4 ISAMAX (n, x, incx)
INTEGER*4 IDAMAX (n, x, incx)
INTEGER*4 ICAMAX (n, x, incx)
INTEGER*4 IZAMAX (n, x, incx)
Functions that return the index of the first selected element of
the array argument which has the maximum absolute value.
These functions are part of the BLAS1 Basic Set, and are only
available on VAX processors.
Arguments
n
Integer number of elements in array "x" to be accessed.
x
Array containing the elements to be accessed or array reference
to the first such element. The data type is REAL*4 for ISAMAX,
REAL*8 for IDAMAX, COMPLEX*8 for ICAMAX, COMPLEX*16 for IZAMAX.
incx
Integer index increment used in selecting which elements of array
"x" are accessed.
45.91 - IxAMIN
INTEGER*4 ISAMIN (n, x, incx)
INTEGER*4 IDAMIN (n, x, incx)
INTEGER*4 ICAMIN (n, x, incx)
INTEGER*4 IZAMIN (n, x, incx)
Functions that return the index of the first selected element of
the array "x" that has the minimum absolute value. For these
routines, the absolute value of a complex number is defined as the
sum of the absolute values of the real and imaginary parts.
These routines are part of the BLAS1 Extended Set, and are
available only on VAX processors. Compaq Extended Math Library
product may be needed to resolve references to Extended Set
routines that are not expanded inline by the compiler.
Arguments
n
Integer number of elements in array "x" to be accessed.
x
Array containing the elements to be accessed or array reference
to the first such element. The data type is REAL*4 for ISAMIN,
REAL*8 for IDAMIN, COMPLEX*8 for ICAMIN, COMPLEX*16 for IZAMIN.
incx
Integer index increment used in selecting which elements of array
"x" are accessed.
45.92 - IxMAX
INTEGER*4 ISMAX (n, x, incx)
INTEGER*4 IDMAX (n, x, incx)
INTEGER*4 ICMAX (n, x, incx)
INTEGER*4 IZMAX (n, x, incx)
Functions that return the index of the first selected element of
the array "x" that has the maximum value.
These routines are part of the BLAS1 Extended Set, and are
available only on VAX processors. Compaq Extended Math Library
product may be needed to resolve references to Extended Set
routines that are not expanded inline by the compiler.
Arguments
n
Integer number of elements in array "x" to be accessed.
x
Array containing the elements to be accessed or array reference
to the first such element. The data type is REAL*4 for ISMAX,
REAL*8 for IDMAX, COMPLEX*8 for ICMAX, COMPLEX*16 for IZMAX.
incx
Integer index increment used in selecting which elements of array
"x" are accessed.
45.93 - IxMIN
INTEGER*4 ISMIN (n, x, incx)
INTEGER*4 IDMIN (n, x, incx)
INTEGER*4 ICMIN (n, x, incx)
INTEGER*4 IZMIN (n, x, incx)
Functions that return the index of the first selected element of
the array "x" that has the minimum value.
These routines are part of the BLAS1 Extended Set, and are
available only on VAX processors. Compaq Extended Math Library
product may be needed to resolve references to Extended Set
routines that are not expanded inline by the compiler.
Arguments
n
Integer number of elements in array "x" to be accessed.
x
Array containing the elements to be accessed or array reference
to the first such element. The data type is REAL*4 for ISMIN,
REAL*8 for IDMIN, COMPLEX*8 for ICMIN, COMPLEX*16 for IZMIN.
incx
Integer index increment used in selecting which elements of array
"x" are accessed.
45.94 - xAMAX
REAL*4 SAMAX (n, x, incx)
REAL*8 DAMAX (n, x, incx)
COMPLEX*8 CAMAX (n, x, incx)
COMPLEX*16 ZAMAX (n, x, incx)
Functions that return the first selected element of the array "x"
that has the maximum absolute value. For these routines, the
absolute value of a complex number is defined as the sum of the
absolute values of the real and imaginary parts.
These routines are part of the BLAS1 Extended Set, and are
available only on VAX processors. Compaq Extended Math Library
product may be needed to resolve references to Extended Set
routines that are not expanded inline by the compiler.
Arguments
n
Integer number of elements in array "x" to be accessed.
x
Array containing the elements to be accessed or array reference
to the first such element. The data type is REAL*4 for SAMAX,
REAL*8 for DAMAX, COMPLEX*8 for CAMAX, COMPLEX*16 for ZAMAX.
incx
Integer index increment used in selecting which elements of array
"x" are accessed.
45.95 - xAMIN
REAL*4 SAMIN (n, x, incx)
REAL*8 DAMIN (n, x, incx)
COMPLEX*8 CAMIN (n, x, incx)
COMPLEX*16 ZAMIN (n, x, incx)
Functions that return the first selected element of the array "x"
that has the minimum absolute value. For these routines, the
absolute value of a complex number is defined as the sum of the
absolute values of the real and imaginary parts.
These routines are part of the BLAS1 Extended Set, and are
available only on VAX processors. Compaq Extended Math Library
product may be needed to resolve references to Extended Set
routines that are not expanded inline by the compiler.
Arguments
n
Integer number of elements in array "x" to be accessed.
x
Array containing the elements to be accessed or array reference
to the first such element. The data type is REAL*4 for SAMIN,
REAL*8 for DAMIN, COMPLEX*8 for CAMIN, COMPLEX*16 for ZAMIN.
incx
Integer index increment used in selecting which elements of array
"x" are accessed.
45.96 - xASUM
REAL*4 SASUM (n, x, incx)
REAL*8 DASUM (n, x, incx)
REAL*4 SCASUM (n, x, incx)
REAL*8 DZASUM (n, x, incx)
Functions that return the sum of the absolute values of selected
elements of the array argument.
These functions are part of the BLAS1 Basic Set, and are only
available on VAX processors.
Arguments
n
Integer number of elements in array "x" to be accessed.
x
Array containing the elements to be accessed or array reference
to the first such element. The data type is REAL*4 for SASUM,
REAL*8 for DASUM, COMPLEX*8 for SCASUM, COMPLEX*16 for DZASUM.
incx
Integer index increment used in selecting which elements of array
"x" are accessed.
45.97 - xAXPY
SAXPY (n, a, x, incx, y, incy)
DAXPY (n, a, x, incx, y, incy)
CAXPY (n, a, x, incx, y, incy)
ZAXPY (n, a, x, incx, y, incy)
Subroutines that multiply an array by a scalar value and add an
array.
These subroutines are part of the BLAS1 Basic Set, and are only
available on VAX processors.
Arguments
n
Integer number of elements in arrays "x" and "y" to be accessed.
a
Scalar multiplier for array "x". The data type is REAL*4 for
SAXPY, REAL*8 for DAXPY, COMPLEX*8 for CAXPY, COMPLEX*16 for
ZAXPY.
x
Array containing the elements to be accessed or array reference
to the first such element. The data type is REAL*4 for SAXPY,
REAL*8 for DAXPY, COMPLEX*8 for CAXPY, COMPLEX*16 for ZAXPY. The
elements in array "x" are multiplied by the scalar argument a and
then added to elements of array "y".
incx
Integer index increment used in selecting which elements of array
"x" are accessed.
y
Array containing the elements to be accessed or array reference
to the first such element. The data type is REAL*4 for SAXPY,
REAL*8 for DAXPY, COMPLEX*8 for CAXPY, COMPLEX*16 for ZAXPY. The
elements of array "y" are replaced by the result of adding their
value to the product of the corresponding elements of array "x"
and the scalar argument "a".
incy
Integer index increment used in selecting which elements of array
"y" are accessed.
45.98 - xCOPY
SCOPY (n, x, incx, y, incy)
DCOPY (n, x, incx, y, incy)
CCOPY (n, x, incx, y, incy)
ZCOPY (n, x, incx, y, incy)
Subroutines that copy selected elements of one array to another
array.
These subroutines are part of the BLAS1 Basic Set, and are only
available on VAX processors.
Arguments
n
Integer number of elements in arrays "x" and "y" to be accessed.
x
Array containing the elements to be copied or array reference to
the first such element. The data type is REAL*4 for SCOPY,
REAL*8 for DCOPY, COMPLEX*8 for CCOPY, COMPLEX*16 for ZCOPY. The
elements in array "x" are copied to the corresponding elements of
array "y".
incx
Integer index increment used in selecting which elements of array
"x" are accessed.
y
Array containing the elements to receive the copied values or
array reference to the first such element. The data type is
REAL*4 for SCOPY, REAL*8 for DCOPY, COMPLEX*8 for CCOPY,
COMPLEX*16 for ZCOPY. The elements of array "y" are replaced by
the corresponding elements of array "x".
incy
Integer index increment used in selecting which elements of array
"y" are accessed.
45.99 - xDOTx
REAL*4 SDOT (n, x, incx, y, incy)
REAL*8 DDOT (n, x, incx, y, incy)
COMPLEX*8 CDOTC (n, x, incx, y, incy)
COMPLEX*8 CDOTU (n, x, incx, y, incy)
COMPLEX*16 ZDOTC (n, x, incx, y, incy)
COMPLEX*16 ZDOTU (n, x, incx, y, incy)
Functions that return the inner product of two arrays. CDOTC and
ZDOTC compute conjugated values while CDOTU and ZDOTU compute
unconjugated values.
These functions are part of the BLAS1 Basic Set, and are only
available on VAX processors.
Arguments
n
Integer number of elements in arrays "x" and "y" to be accessed.
x
Array containing the elements to be accessed or array reference
to the first such element. The data type is REAL*4 for SDOT,
REAL*8 for DDOT, COMPLEX*8 for CDOTC and CDOTU, COMPLEX*16 for
ZDOTC and ZDOTU.
incx
Integer index increment used in selecting which elements of array
"x" are accessed.
y
Array containing the elements to be accessed or array reference
to the first such element. The data type is REAL*4 for SDOT,
REAL*8 for DDOT, COMPLEX*8 for CDOTC and CDOTU, COMPLEX*16 for
ZDOTC and ZDOTU.
incy
Integer index increment used in selecting which elements of array
"y" are accessed.
45.100 - xMAX
REAL*4 SMAX (n, x, incx)
REAL*8 DMAX (n, x, incx)
COMPLEX*8 CMAX (n, x, incx)
COMPLEX*16 ZMAX (n, x, incx)
Functions that return the first selected element of the array "x"
that has the maximum value.
These routines are part of the BLAS1 Extended Set, and are
available only on VAX processors. The Compaq Extended Math
Library product may be needed to resolve references to Extended Set
routines that are not expanded inline by the compiler.
Arguments
n
Integer number of elements in array "x" to be accessed.
x
Array containing the elements to be accessed or array reference
to the first such element. The data type is REAL*4 for SMAX,
REAL*8 for DMAX, COMPLEX*8 for CMAX, COMPLEX*16 for ZMAX.
incx
Integer index increment used in selecting which elements of array
"x" are accessed.
45.101 - xMIN
REAL*4 SMIN (n, x, incx)
REAL*8 DMIN (n, x, incx)
COMPLEX*8 CMIN (n, x, incx)
COMPLEX*16 ZMIN (n, x, incx)
Functions that return the first selected element of the array "x"
that has the minimum value.
These routines are part of the BLAS1 Extended Set, and are
available only on VAX processors. The Compaq Extended Math
Library product may be needed to resolve references to Extended Set
routines that are not expanded inline by the compiler.
Arguments
n
Integer number of elements in array "x" to be accessed.
x
Array containing the elements to be accessed or array reference
to the first such element. The data type is REAL*4 for SMIN,
REAL*8 for DMIN, COMPLEX*8 for CMIN, COMPLEX*16 for ZMIN.
incx
Integer index increment used in selecting which elements of array
"x" are accessed.
45.102 - xNORM2
REAL*4 SNORM2 (n, x, incx)
REAL*8 DNORM2 (n, x, incx)
REAL*4 SCNORM2 (n, x, incx)
REAL*8 DZNORM2 (n, x, incx)
Functions that return the Euclidean norm of array "x" that is the
square root of the sum of the squares of the absolute values of the
array elements. For the purposes of these routines, the absolute
value of a complex value is the square root of the sum of the
squares of the real and imaginary parts.
Unlike the BLAS1 routines xNRM2, the xNORM2 routines assume that
intermediate underflow or overflow exceptions will not occur.
These routines are part of the BLAS1 Extended Set, and are
available only on VAX processors. The Compaq Extended Math
Library product may be needed to resolve references to Extended Set
routines that are not expanded inline by the compiler.
Arguments
n
Integer number of elements in array "x" to be accessed.
x
Array containing the elements to be accessed or array reference
to the first such element. The data type is REAL*4 for SNORM2,
REAL*8 for DNORM2, COMPLEX*8 for SCNORM2, COMPLEX*16 for DZNORM2.
incx
Integer index increment used in selecting which elements of array
"x" are accessed.
45.103 - xNRM2
REAL*4 SNRM2 (n, x, incx)
REAL*8 DNRM2 (n, x, incx)
REAL*4 SCNRM2 (n, x, incx)
REAL*8 DZNRM2 (n, x, incx)
Functions that return the Euclidean norm of a array. These
functions cannot be inlined.
These functions are part of the BLAS1 Basic Set, and are only
available on VAX processors.
Arguments
n
Integer number of elements in array "x" to be accessed.
x
Array containing the elements to be accessed or array reference
to the first such element. The data type is REAL*4 for SNRM2,
REAL*8 for DNRM2, COMPLEX*8 for SCNRM2, COMPLEX*16 for DZNRM2.
incx
Integer index increment used in selecting which elements of array
"x" are accessed.
45.104 - xNRSQ
REAL*4 SNRSQ (n, x, incx)
REAL*8 DNRSQ (n, x, incx)
REAL*4 SCNRSQ (n, x, incx)
REAL*8 DZNRSQ (n, x, incx)
Functions that return the sum of the squares of the absolute values
of the elements of array "x". For the purposes of these routines,
the absolute value of a complex value is the square root of the sum
of the squares of the real and imaginary parts.
These routines are part of the BLAS1 Extended Set, and are
available only on VAX processors. The Compaq Extended Math
Library product may be needed to resolve references to Extended Set
routines that are not expanded inline by the compiler.
Arguments
n
Integer number of elements in array "x" to be accessed.
x
Array containing the elements to be accessed or array reference
to the first such element. The data type is REAL*4 for SNRSQ,
REAL*8 for DNRSQ, COMPLEX*8 for SCNRSQ, COMPLEX*16 for DZNRSQ.
incx
Integer index increment used in selecting which elements of array
"x" are accessed.
45.105 - xROT
SROT (n, x, incx, y, incy, c, s)
DROT (n, x, incx, y, incy, c, s)
CSROT (n, x, incx, y, incy, c, s)
ZDROT (n, x, incx, y, incy, c, s)
Subroutines that apply a Givens plane rotation to a pair of arrays.
CSROT and ZDROT apply a real rotation to a pair of complex arrays.
These routines are part of the BLAS1 Basic Set, and are only
available on VAX processors.
Arguments
n
Integer number of elements in arrays "x" and "y" to be accessed.
x
Array containing the elements to be accessed or array reference
to the first such element. The data type is REAL*4 for SROT,
REAL*8 for DROT, COMPLEX*8 for CSROT, COMPLEX*16 for ZDROT.
incx
Integer index increment used in selecting which elements of array
"x" are accessed.
y
Array containing the elements to be accessed or array reference
to the first such element. The data type is REAL*4 for SROT,
REAL*8 for DROT, COMPLEX*8 for CSROT, COMPLEX*16 for ZDROT.
incy
Integer index increment used in selecting which elements of array
"y" are accessed.
c
First rotation element, which can be interpreted as the cosine of
the angle of rotation. This argument can be generated by the
xROTG routines. The data type is REAL*4 for SROT and CSROT,
REAL*8 for DROT and ZDROT.
s
Second rotation element, which can be interpreted as the sine of
the angle of rotation. This argument can be generated by the
xROTG routines. The data type is REAL*4 for SROT, REAL*8 for
DROT, COMPLEX*8 for CSROT and COMPLEX*16 for ZDROT
45.106 - xROTG
SROTG (a, b, c, s)
DROTG (a, b, c, s)
CROTG (a, b, c, s)
ZROTG (a, b, c, s)
Subroutines that generate the elements for a Givens plane rotation.
These subroutines cannot be inlined.
These routines are part of the BLAS1 Basic Set, and are only
available on VAX processors.
Arguments
a
On entry, first element of the input array. On exit, rotated
element r. The data type is REAL*4 for SROTG, REAL*8 for DROTG,
COMPLEX*8 for CROTG, COMPLEX*16 for ZROTG.
b
On entry, second element of the input array. On exit from SROTG
and DROTG, reconstruction element z. The data type is REAL*4 for
SROTG, REAL*8 for DROTG, COMPLEX*8 for CROTG, COMPLEX*16 for
ZROTG.
c
Variable into which is stored the first rotation element, which
can be interpreted as the cosine of the angle of rotation. The
data type is REAL*4 for SROTG and CROTG, REAL*8 for DROTG and
ZROTG.
s
Variable into which is stored the second rotation element, which
can be interpreted as the sine of the angle of rotation. The
data type is REAL*4 for SROTG, REAL*8 for DROTG, COMPLEX*8 for
CROTG, COMPLEX*16 for ZROTG.
45.107 - xSCAL
SSCAL (n, a, x, incx)
DSCAL (n, a, x, incx)
CSCAL (n, a, x, incx)
CSSCAL (n, a, x, incx)
ZSCAL (n, a, x, incx)
ZDSCAL (n, a, x, incx)
Subroutines that scale the elements of an array by a scalar value.
These routines are part of the BLAS1 Basic Set, and are only
available on VAX processors.
Arguments
n
Integer number of elements in array "x" to be accessed.
a
Scalar value to be multiplied by each selected element in array
"x". The data type is REAL*4 for SSCAL and CSSCAL, REAL*8 for
DSCAL and ZDSCAL, COMPLEX*8 for CSCAL and COMPLEX*16 for ZSCAL.
x
Array containing the elements to be scaled or array reference to
the first such element. The selected elements are replaced by
the scaled value. The data type is REAL*4 for SSCAL, REAL*8 for
DSCAL, COMPLEX*8 for CSCAL and CSSCAL, COMPLEX*16 for ZSCAL and
ZDSCAL.
incx
Integer index increment used in selecting which elements of array
"x" are accessed.
45.108 - xSET
SSET (n, a, x, incx)
DSET (n, a, x, incx)
CSET (n, a, x, incx)
ZSET (n, a, x, incx)
Subroutines that set all selected elements of array "x" to scalar
value "a".
These routines are part of the BLAS1 Extended Set, and are
available only on VAX processors. The Compaq Extended Math
Library product may be needed to resolve references to Extended Set
routines that are not expanded inline by the compiler.
Arguments
n
Integer number of elements in array "x" to be accessed.
a
Scalar value to be stored in all selected elements of array "x".
The data type is REAL*4 for SSET, REAL*8 for DSET, COMPLEX*8 for
CSET, COMPLEX*16 for ZSET
x
Array containing the elements to be accessed or array reference
to the first such element. The data type is REAL*4 for SSET,
REAL*8 for DSET, COMPLEX*8 for CSET, COMPLEX*16 for ZSET.
incx
Integer index increment used in selecting which elements of array
"x" are accessed.
45.109 - xSUM
REAL*4 SSUM (n, x, incx)
REAL*8 DSUM (n, x, incx)
COMPLEX*8 CSUM (n, x, incx)
COMPLEX*16 ZSUM (n, x, incx)
Functions that return the sum of the selected elements of array
"x".
These routines are part of the BLAS1 Extended Set, and are
available only on VAX processors. The Compaq Extended Math
Library product may be needed to resolve references to Extended Set
routines that are not expanded inline by the compiler.
Arguments
n
Integer number of elements in array "x" to be accessed.
x
Array containing the elements to be accessed or array reference
to the first such element. The data type is REAL*4 for SSUM,
REAL*8 for DSUM, COMPLEX*8 for CSUM, COMPLEX*16 for ZSUM.
incx
Integer index increment used in selecting which elements of array
"x" are accessed.
45.110 - xSWAP
SSWAP (n, x, incx, y, incy)
DSWAP (n, x, incx, y, incy)
CSWAP (n, x, incx, y, incy)
ZSWAP (n, x, incx, y, incy)
Subroutines that swap elements between two arrays.
These routines are part of the BLAS1 Basic Set, and are only
available on VAX processors.
Arguments
n
Integer number of elements in arrays "x" and "y" to be accessed.
x
Array containing elements to be swapped with corresponding
elements in array "y", or array reference to the first such
element. The data type is REAL*4 for SSWAP, REAL*8 for DSWAP,
COMPLEX*8 for CSWAP, COMPLEX*16 for ZSWAP.
incx
Integer index increment used in selecting which elements of array
"x" are accessed.
y
Array containing elements to be swapped with corresponding
elements in array "x", or array reference to the first such
element. The data type is REAL*4 for SSWAP, REAL*8 for DSWAP,
COMPLEX*8 for CSWAP, COMPLEX*16 for ZSWAP.
incy
Integer index increment used in selecting which elements of array
"y" are accessed.
45.111 - xVCAL
SVCAL (n, a, x, incx, y, incy)
DVCAL (n, a, x, incx, y, incy)
CVCAL (n, a, x, incx, y, incy)
CSVCAL (n, a, x, incx, y, incy)
ZVCAL (n, a, x, incx, y, incy)
ZDVCAL (n, a, x, incx, y, incy)
Subroutines that scale the elements of array "x" by scalar value
"a" and store the results in array "y".
These routines are part of the BLAS1 Extended Set, and are
available only on VAX processors. The Compaq Extended Math
Library product may be needed to resolve references to Extended Set
routines that are not expanded inline by the compiler.
Arguments
n
Integer number of elements in arrays "x" and "y" to be accessed.
a
Scalar value to be multiplied by each selected element in array
"x". The data type is REAL*4 for SVCAL and CSVCAL, REAL*8 for
DVCAL and ZDVCAL, COMPLEX*8 for CVCAL and COMPLEX*16 for ZVCAL.
x
Array containing the elements to be scaled or array reference to
the first such element. The data type is REAL*4 for SVCAL,
REAL*8 for DVCAL, COMPLEX*8 for CVCAL and CSVCAL, COMPLEX*16 for
ZVCAL and ZDVCAL.
incx
Integer index increment used in selecting which elements of array
"x" are accessed.
y
Array into which the scaled elements are stored or array
reference to the first such element. The data type is REAL*4 for
SVCAL, REAL*8 for DVCAL, COMPLEX*8 for CVCAL and CSVCAL,
COMPLEX*16 for ZVCAL and ZDVCAL.
incy
Integer index increment used in selecting which elements of array
"y" are accessed.
45.112 - xZAXPY
SZAXPY (n, a, x, incx, y, incy, z, incz)
DZAXPY (n, a, x, incx, y, incy, z, incz)
CZAXPY (n, a, x, incx, y, incy, z, incz)
ZZAXPY (n, a, x, incx, y, incy, z, incz)
Subroutines that multiply an array "x" by a scalar "a" and add an
array "y"; the result is stored in a third array "z".
These routines are part of the BLAS1 Extended Set, and are
available only on VAX processors. The Compaq Extended Math
Library product may be needed to resolve references to Extended Set
routines that are not expanded inline by the compiler.
Arguments
n
Integer number of elements in arrays "x", "y" and "z" to be
accessed.
a
Scalar multiplier for array x. The data type is REAL*4 for
SZAXPY, REAL*8 for DZAXPY, COMPLEX*8 for CZAXPY, COMPLEX*16 for
ZZAXPY.
x
Array containing the elements to be accessed or array reference
to the first such element. The data type is REAL*4 for SZAXPY,
REAL*8 for DZAXPY, COMPLEX*8 for CZAXPY, COMPLEX*16 for ZZAXPY.
The elements in array "x" are multiplied by the scalar argument
"a" and then added to elements of array "y"; the results are
stored in array "z".
incx
Integer index increment used in selecting which elements of array
"x" are accessed.
y
Array containing the elements to be accessed or array reference
to the first such element. The data type is REAL*4 for SZAXPY,
REAL*8 for DZAXPY, COMPLEX*8 for CZAXPY, COMPLEX*16 for ZZAXPY.
The elements of array "y" are added to the product of scalar "a"
and array "x"; the result is stored in array "z".
incy
Integer index increment used in selecting which elements of array
"y" are accessed.
z
Array containing the elements to receive the result values or
array reference to the first such element. The data type is
REAL*4 for SZAXPY, REAL*8 for DZAXPY, COMPLEX*8 for CZAXPY,
COMPLEX*16 for ZZAXPY.
incz
Integer index increment used in selecting which elements of array
"z" are accessed.
45.113 - ZEXT
ZEXT (integer) A function that returns the value of the argument, zero extended. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | ZEXT | IZEXT | LOGICAL*1 | INTEGER*2 | | | | IZEXT | LOGICAL*2 | INTEGER*2 | | | | IZEXT | INTEGER*2 | INTEGER*2 | | | | JZEXT | LOGICAL*1 | INTEGER*4 | | | | JZEXT | LOGICAL*2 | INTEGER*4 | | | | JZEXT | LOGICAL*4 | INTEGER*4 | | | | JZEXT | INTEGER*2 | INTEGER*4 | | | | JZEXT | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+
| 46 - Logical Names |
Various VMS logical names can be defined to modify the behavior of the Compaq Fortran compiler or an executing application.
46.1 - FORT$INCLUDE
If defined during compilation, this logical name changes the default file specification used to locate include files and text libraries from '.FOR' and '.TLB' to 'FORT$INCLUDE:.FOR' and 'FORT$INCLUDE:.TLB', respectively. It can be a search list.
46.2 - FORT$LIBRARY
If defined during compilation, this logical name specifies one or more default text libraries to be searched for library-based INCLUDE statements which do not specify a library file. These default libraries are searched after any libraries specified on the command line (with /LIBRARY) and before the system-supplied library FORSYSDEF.TLB. It can have multiple translations; each translation is used as if it appeared as an input file on the command line with the /LIBRARY qualifier with file specification defaulting occurring within the FORT$LIBRARY list only.
46.3 - FOR$ACCEPT
If defined during execution, 'FOR$ACCEPT' is used instead of 'SYS$INPUT' as the file specification for the implicit Fortran logical unit used for ACCEPT statements.
46.4 - FOR$CONVERTnnn
If defined during execution, this logical name specifies a default
data conversion type for unit "nnn". The translation of the
logical name must be a valid keyword for the /CONVERT= qualifier.
For example:
$ DEFINE FOR$CONVERT002 LITTLE_ENDIAN
This command makes LITTLE_ENDIAN the default convert type for unit
2. A defined logical name for a unit overrides the /CONVERT
compile command or OPTIONS statement qualifier and an explicit
CONVERT= keyword on an OPEN statement. For more information, see
the /CONVERT qualifier.
46.5 - FOR$PRINT
If defined during execution, 'FOR$PRINT' is used instead of 'SYS$OUTPUT' as the file specification for the implicit Fortran logical unit used for PRINT statements and WRITE statements that specify * as the unit number.
46.6 - FOR$PROCESSES
If defined during execution of a parallel processing application, this logical name controls the number of processes used. The default is the number of processors available on the executing system. The minimum is 1, the maximum is 32. For more information, see the Compaq Fortran Performance Guide.
46.7 - FOR$READ
If defined during execution, 'FOR$READ' is used instead of 'SYS$INPUT' as the file specification for the implicit Fortran logical unit used for READ statements that specify * or omit the unit number.
46.8 - FOR$SPIN_WAIT
If defined during execution of a parallel processing application, this logical name controls the synchronization method used. A value of 0 causes busy-waiting to be used, which maximizes synchronization response at the expense of wasted processor cycles. Positive values specify the number of busy-wait cycles to execute before relinquishing control of the processor. The default is 1000. For more information, see the Compaq Fortran Performance Guide.
46.9 - FOR$STALL_WAIT
If defined during execution of a parallel processing application, this logical name specifies the number of spin-wait cycles (see FOR$SPIN_WAIT) that a parallel worker subprocess should execute while waiting for more work to do before becoming inactive. A value of 0 prevents the process from becoming inactive. The default is 10 times the number of worker subprocesses. For more information, see the Compaq Fortran Performance Guide.
46.10 - FOR$TYPE
If defined during execution, 'FOR$TYPE' is used instead of 'SYS$OUTPUT' as the file specification for the implicit Fortran logical unit used for TYPE statements.
46.11 - FORnnn
The file specification 'FORnnn', where 'nnn' is the logical unit number, is used as the file specification when a logical unit is opened and the FILE= keyword was not specified in an OPEN statement. Similarly, 'FORnnn.DAT' is used as the default file specification unless the DEFAULTFILE= keyword was specified. FORnnn may be defined as a logical name, in which case it is used by OpenVMS RMS to specify the file to be opened.
| 47 - Source Format |
Each Fortran line has the following four fields:
Statement label field Columns 1-5
Continuation indicator field Column 6
Statement field Columns 7-72 (if you specify
/EXTEND_SOURCE or
OPTIONS/EXTEND_SOURCE,
statements extend to
column 132)
Sequence number field Columns 73-80
There are two ways to code a Fortran line: standard formatting and
tab formatting. You may prefer to use standard formatting when
program portability to other systems is necessary. The tab
formatting method is convenient when you are entering lines at a
terminal with a text editor.
47.1 - Standard
A Fortran line is divided into fields for the required information.
Each column represents a single character.
COLUMN FIELD
------ -----
1 Indicator: Comment(C,c,*,!,blank) or Debug(D,d)
1-5 Label (any decimal integer except zero)
6 Indicator: Continuation of statement (any character
except zero or space)
7-72 Statement Field (up to column 72)
73-80 Sequence Number (optionally to column 132 -- ignored)
47.2 - Tab
A Fortran line is divided into fields for the required information.
Each column represents a single character. You cannot specify a
sequence number field using this method of coding.
COLUMN FIELD
------ -----
(before tab)
1 Indicator: Comment(C,c,*,!,blank) or Debug(D,d)
1-5 Label (any decimal integer except zero)
(after first tab)
6 Indicator: Continuation of statement (any digit 1-9)
(after second tab)
Statement Field (up to column 72)
Tabs are treated as single characters.
| 48 - Statements |
Statements in a Fortran program unit follow a required order. In the following figure, vertical lines separate statement types that can be interspersed. For example, DATA statements can be interspersed with executable statements. Horizontal lines indicate statement types that cannot be interspersed. For example, type declaration statements cannot be interspersed with executable statements. +-------+--------------------------------------------------------+ | | OPTIONS Statement | | |--------------------------------------------------------| | |PROGRAM, FUNCTION, SUBROUTINE, or BLOCK DATA Statements | | |--------+-----------------------------------------------| |COMMENT| | IMPLICIT NONE Statement | | Lines,| |-------------------------------+--------------| |INCLUDE|NAMELIST,| IMPLICIT Statements | | | State-| FORMAT, |------+------------------------| PARAMETER | | ments,| & | | Other Specification | Statements | |& Gen- | ENTRY | DATA | Statements, | | | eral | State- |State-| DICTIONARY Statements | | |Direc- | ments | ments|------------------------+--------------| | tives | | | Statement Function Definitions | | | | |---------------------------------------| | | | | Executable Statements | |-------+---------+------+---------------------------------------| | END Statement | +----------------------------------------------------------------+
48.1 - Directive Statements
CDEC$ ALIAS name, external-name CDEC$ ASSERT (e) CDEC$ END OPTIONS (see CDEC$ OPTIONS) CDEC$ IDENT string CDEC$ INIT_DEP_FWD CDEC$ NOVECTOR CDEC$ OPTIONS /qual... CDEC$ PSECT /common-name/ attr [,attr,...] CDEC$ SUBTITLE string CDEC$ TITLE string CPAR$ CONTEXT_SHARED var_name[,...,var_name] CPAR$ CONTEXT_SHARED_ALL CPAR$ DO_PARALLEL [distribution-size] CPAR$ LOCKON lock-variable CPAR$ LOCKOFF lock-variable CPAR$ PRIVATE name[,...,name] CPAR$ PRIVATE_ALL CPAR$ SHARED common_name[,...,common_name] CPAR$ SHARED_ALL You can use directives in a Fortran source program to influence certain aspects of the compilation process. Directives are prefixed, starting in column 1, with a 5-character identifier and a space (or tab). Directives prefixed with CDEC$ are enabled in all Fortran compilation units, regardless of the qualifiers used on the FORTRAN command line. Directives may also be prefixed with a first character of ! (!DEC$ or !PAR$) in any column of a source line as long as only whitespace (blanks or tabs) precedes the directive prefix. Directives prefixed with CPAR$ are enabled only in Fortran compilation units involved in parallel processing (that is, when the /PARALLEL qualifier is specified on the FORTRAN command line). If the /PARALLEL qualifier is not specified, parallel-processing directives (CPAR$ directives) are interpreted as comment lines. A directive statement cannot be continued across multiple lines in a source program, and any blanks appearing after column 6 are insignificant. Continuation lines cannot appear in directive statements. If a blank common block is used in a compiler directive, it must be specified as two slashes (/ /).
48. 1.1 - ALIAS
CDEC$ ALIAS name, external-name The ALIAS directive lets you specify an alternate external name to be used when referring to external objects such as subroutines and functions. This can be useful when compiling applications written for other platforms which have different naming conventions. The external-name may be an identifier or a quoted character constant. If a quoted character constant is specified, it is used as-is; the string is not changed to upper case nor are blanks removed. Names which are not acceptable to the OpenVMS linker will cause link-time errors. The ALIAS directive affects only the external name used for references to the specified internal name.
48. 1.2 - ASSERT
CDEC$ ASSERT (log-exp)
or in statement form:
ASSERT (log-exp)
log-exp Is a logical expression.
The ASSERT directive (also available in statement form) provides
the compiler with information to improve optimization (particularly
if vectorization or automatic decomposition for parallel processing
is being performed). The directive can also be used to provide a
form of error checking in user applications.
The ASSERT directive tells the compiler that "log-exp" evaluates as
.TRUE. at the location in the program unit where the ASSERT
appears.
If the compiler option /CHECK=ASSERTIONS (or
OPTIONS/CHECK=ASSERTIONS) is in effect, the compiler adds run-time
code to verify the asserted expression; if the expression evaluates
as .FALSE., a run-time error is signaled.
The following is an example of how to use the CDEC$ ASSERT
directive for error checking (the program is compiled using the
compiler option /CHECK=ASSERTIONS:
CDEC$ ASSERT (ICOUNT .NE. 0)
IVAL = IVAL / ICOUNT ! Avoid zero-divide exception
48. 1.3 - IDENT
CDEC$ IDENT string The IDENT directive lets you specify a string that can be used to identify an object module. The compiler places the string in the identification field of an object module when it generates the module for each source program unit. The string that you specify can consist of a group of up to 31 printable characters delimited by apostrophes. Only the first IDENT directive is effective -- the compiler ignores any additional IDENT directives in a program unit.
48. 1.4 - INIT_DEP_FWD
CDEC$ INIT_DEP_FWD The INIT_DEP_FWD (INITialize DEPendences ForWarD) directive specifies that the compiler is to begin its dependence analysis by assuming all dependences occur in the same forward direction as their appearance in the normal scalar execution order. This contrasts with the normal compiler behavior, which is for the dependence analysis to make no initial assumptions about the direction of a dependence. The INIT_DEP_FWD directive must precede the DO statement for each DO loop. No source code lines, other than the following, can be placed between the INIT_DEP_FWD directive statement and the DO statement: an optional CPAR$ DO_PARALLEL directive, a CDEC$ NOVECTOR directive, placeholder lines, comment lines, or blank lines.
48. 1.5 - NOVECTOR
CDEC$ NOVECTOR The CDEC$ NOVECTOR directive tells the compiler not to vectorize the DO loop following the directive. This is useful in cases where the vectorized form would not perform as well as the scalar form. This directive is only available on VAX processors. The NOVECTOR directive must precede the DO statement for each DO loop to which you want the directive to apply. No source code lines, other than the following can be placed between the NOVECTOR directive statement and the DO statement: an optional CPAR$ DO_PARALLEL directive, a CDEC$ INIT_DEP_FWD directive, placeholder lines, comment lines, or blank lines.
48. 1.6 - OPTIONS and ENDOPTIONS
CDEC$ OPTIONS
The OPTIONS directive controls whether the Compaq Fortran compiler
naturally aligns fields in records and data items in common blocks
for performance reasons, or whether the compiler packs those fields
and data items together on arbitrary byte boundaries. The OPTIONS
directive takes the following form:
CDEC$ OPTIONS /[NO]ALIGN[=p] /[NO]WARNINGS=[NO]ALIGNMENT
.
.
.
CDEC$ END OPTIONS
p Is a specifier with one of the following forms:
[class =] rule
(class = rule,...)
ALL
NONE
class Is one of the following keywords:
COMMONS (for common blocks)
RECORDS (for records)
STRUCTURES (a synonym for RECORDS)
rule Is one of the following keywords:
PACKED - Packs fields in records or data
items in common blocks on arbitrary
byte boundaries.
NATURAL - Naturally aligns fields in records
and data items in common blocks on
up to 64-bit boundaries (inconsistent
with the FORTRAN-77 standard).
If you specify NATURAL, the compiler will
naturally align all data in a common
block, including REAL*8, and
all COMPLEX data.
STANDARD - Naturally aligns data items in common
blocks on up to 32-bit boundaries (con-
sistent with the FORTRAN-77 standard).
Note that this keyword only applies to
common blocks; therefore, you can specify
/ALIGN=COMMONS=STANDARD, but you cannot
specify /ALIGN=STANDARD.
ALL Is the same as /ALIGN, /ALIGN=NATURAL, and
/ALIGN=(RECORDS=NATURAL,COMMONS=NATURAL).
NONE Is the same as /NOALIGN, /ALIGN=PACKED, and
/ALIGN=(RECORDS=PACKED,COMMONS=PACKED)
CDEC$ OPTIONS (and accompanying CDEC$ END OPTIONS) directives must
come after OPTIONS, SUBROUTINE, FUNCTION, and BLOCK DATA statements
(if any) in the program unit, and before statement functions or the
executable part of the program unit.
For performance reasons, Compaq Fortran always aligns local data items
on natural boundaries. However, EQUIVALENCE, COMMON, RECORD, and
STRUCTURE data declaration statements can force misaligned data.
You can use the OPTIONS directive to control the alignment of
fields associated with COMMON and RECORD statements. By default,
you do not receive compiler messages when misaligned data is
encountered.
To request aligned data in a record structure, specify
/ALIGN=RECORDS=NATURAL, or consider placing source data declarations
for the record so that the data is naturally aligned.
NOTE
Misaligned data significantly increases the time it
takes to execute a program. As the number of
misaligned fields encountered increases, so does
the time needed to complete program execution.
Specifying CDEC$ OPTIONS/ALIGN (or the /ALIGN
compiler option) minimizes misaligned data.
To request aligned, data in common blocks, specify
/ALIGN=COMMONS=STANDARD (for data items up to 32 bits in length) or
/ALIGN=COMMONS=NATURAL (for data items up to 64 bits in length), or
place source data declarations within the common block in
descending size order, so that each data field is naturally
aligned.
The OPTIONS directive supersedes the /ALIGN compiler option.
OPTIONS directives must be balanced and can be nested up to 100
levels, for example:
CDEC$ OPTIONS /ALIGN=PACKED ! Group A
declarations
CDEC$ OPTIONS /ALIGN=RECO=NATU ! Group B
more declarations
CDEC$ END OPTIONS ! End of Group B
still more declarations
CDEC$ END OPTIONS ! End of Group A
Note that common blocks within Group B will be PACKED. The CDEC$
OPTION specification for Group B only applies to RECORDS, so
COMMONS retains the previous setting (in this case, from the Group
A specification).
For more information on alignment and data sizes, see your user
manual.
The /WARNINGS qualifier may be specified to control whether or not
alignment warnings are given for STRUCTURE and COMMON declarations
within the scope of this CDEC$ OPTIONS directive. Warnings are given
only if /WARNINGS=ALIGNMENT was also specified on the command line;
use the directive qualifier to disable alignment warnings for selected
declarations.
For COMMON blocks, all declarations and directives naming the COMMON
block must have the same setting for /WARNINGS=ALIGNMENT. For example:
CDEC$ OPTIONS /WARN=ALIGNMENT
COMMON /CMN/ X
CDEC$ END OPTIONS
CDEC$ OPTIONS /WARN=NOALIGNMENT
SAVE /CMN/
CDEC$ END OPTIONS
will result in a warning message from the compiler. The initial state
is taken from the value of /WARNINGS=ALIGNMENT on the command line.
48. 1.7 - PSECT
CDEC$ PSECT /common-name/ attr [,attr,...]
The PSECT directive lets you modify several attributes of a common
block.
You specify the name of a common block, preceded and followed by a
slash, and one of the following attributes:
LCL Local scope.
GBL Global scope.
[NO]WRT Writability or no-writability.
[NO]SHR Shareability or no-shareability.
[NO]MULTILANGUAGE Length padded to multiple of alignment or not
ALIGN=val Alignment for the common block.
Val must be a constant (0 through 9).
Refer to the "OpenVMS Linker Reference Manual" for detailed information
about default attributes of common blocks.
48. 1.8 - TITLE and SUBTITLE
CDEC$ TITLE string
CDEC$ SUBTITLE string
The TITLE directive lets you specify a string and place it in the
title field of a listing header. Similarly, SUBTITLE lets you
place a specified string in the subtitle field of a listing header.
The string that you specify can consist of up to 31 printable
characters and must be delimited by apostrophes.
In addition to the compiler-directive syntax rules, the TITLE and
SUBTITLE directives have the following specific rules:
o To enable TITLE and SUBTITLE directives, you must specify the
/LIST compiler option.
o When TITLE or SUBTITLE appears on a page of a listing file, the
specified string appears in the listing header of the following
page.
o If two or more of either directive appear on a page, the last
directive is the one in effect for the following page.
o If either directive does not specify a string, no change occurs
in the listing file header.
48. 1.9 - CONTEXT_SHARED
CPAR$ CONTEXT_SHARED var_name[,...,var_name] CPAR$ CONTEXT_SHARED_ALL CONTEXT_SHARED directives can be interspersed with declaration statements within program units in a parallel-processing application program. Variables (scalars, arrays, and records) specified on a CONTEXT_SHARED directive reside in a shared memory location throughout any one invocation of a subprogram (subroutine or function), including any parallel loops contained within the subprogram. However, if a subprogram has several concurrent invocations (because it is called from within a parallel loop), each invocation will use different memory for these variables. This context adjustment is handled automatically by the compiler and is not a programming consideration. By default, all variables in a routine compiled with the /PARALLEL qualifier are context-shared. Commas are required between variable names specified on a CONTEXT_SHARED directive. The CONTEXT_SHARED_ALL directive forces all symbols that are declared within a routine to default to CONTEXT_SHARED. This directive affects only default behavior. Individual symbols can still be declared PRIVATE. See your user manual for information about when to use directives to resolve certain types of data dependence problems.
48. 1.10 - DO_PARALLEL
CPAR$ DO_PARALLEL [distribution-size] The DO_PARALLEL compiler directive statement identifies an indexed DO loop that is to be executed in parallel. The DO_PARALLEL directive must precede the DO statement for each parallel DO loop. No source code lines, other than the following can be placed between the DO_PARALLEL directive statement and the DO statement: a CDEC$ INIT_DEP_FWD directive, a CDEC$ NOVECTOR directive, placeholder lines, comment lines, or blank lines. You can specify how the DO loop iterations are to be divided up among the processors executing the parallel DO loop. For example, if a parallel DO loop has 100 iterations and you specify a distribution size of 25, iterations will be distributed to each processor for execution in sets of 25. When a process completes one set of iterations, it then begins processing the next unprocessed set. If the number that you specify for distribution size does not divide evenly into the number of iterations, any remaining iterations are run in the last process. The expression that you use to specify the distribution size must be capable of being evaluated as a positive, nonzero integer. If necessary, it is converted to an integer. For example, 5.2 is acceptable and is converted to 5. The number 0.2 is not acceptable, however, because it is converted to 0.
48. 1.11 - LOCKON and LOCKOFF
CPAR$ LOCKON lock-variable
CPAR$ LOCKOFF lock-variable
The LOCKON and LOCKOFF compiler directive statements can be used
within a parallel DO loop to prevent multiple processes from
executing selected statements in parallel. These directives force
the multiple processes executing a parallel DO loop to execute
selected statements serially. This can be useful when a statement
(or set of statements) creates an unacceptable data dependence
problem that cannot be resolved by other means.
The lock variable can be a variable or a dummy argument. It must
have a data type of LOGICAL*4 and must have a status of shared
(SHARED directive). The lock is in effect when the lock variable
has a value of .TRUE. and unlocked when the lock variable has a
value of .FALSE.
The LOCKON and LOCKOFF directives perform the following operations:
LOCKON Waits, if necessary, for the lock variable to become
.FALSE., then sets it to .TRUE. (that is, locks the
lock), and then proceeds.
LOCKOFF Sets the lock variable to .FALSE. (that is, unlocks
the lock).
These directives use the VAX interlocked instructions to guarantee
proper synchronization on a multiprocessor. Do not use any other
statements to modify the lock variable while another process may be
executing a LOCKON or LOCKOFF directive.
See your user manual for examples of how locks are used in parallel
DO loops.
48. 1.12 - PRIVATE
CPAR$ PRIVATE name[,...,name] CPAR$ PRIVATE_ALL PRIVATE directives can be interspersed with declaration statements within program units in a parallel-processing application program. The PRIVATE[_ALL] directive specifies those variables (scalars, arrays, and records) and common blocks that must have unique memory locations within each of the processes executing a parallel DO loop. PRIVATE_ALL causes all variables and common blocks declared in a routine to default to private -- unless they are explicitly declared as shared (for common blocks) or context-shared (for variables). PRIVATE_ALL does not disallow the use of the SHARED and CONTEXT_SHARED directives; it merely establishes the default behavior for data sharing as PRIVATE, overriding the default behavior (SHARED_ALL and CONTEXT_SHARED) established by the /PARALLEL qualifier. Commas are required between the names that you specify on PRIVATE directives. In addition, common block names must be enclosed by slashes (for example, /name/ or, for blank common, / /). See your user manual for information about when to use directives to resolve certain types of data dependence problems.
48. 1.13 - SHARED
CPAR$ SHARED common_name[,...,common_name] CPAR$ SHARED_ALL SHARED directives can be interspersed with declaration statements within program units in a parallel-processing application program. The SHARED[_ALL] directive identifies those variables (scalar, array, and record variables) and common blocks that are to be shared among all the processes executing the compilation unit -- in both parallel and nonparallel (serial) execution contexts. SHARED_ALL does not disallow the use of the PRIVATE directive; it merely reinforces the default behavior for data sharing established by /PARALLEL. The default behavior associated with the /PARALLEL qualifier is to give a status of shared to all common blocks declared in a given compilation unit. Note that any given common block should have the same status (shared or private) in all subprograms in the parallel application. The common block names must be enclosed by slashes (for example, /name/ or, for blank common, / /). Commas are required between names. See your user manual for information about when to use directives to resolve certain types of data dependence problems.
48.2 - Executable Statements
The executable statements are: ACCEPT, ASSIGN, assignment statements, BACKSPACE, CALL, CLOSE, CONTINUE, DELETE, DO, END DO, ELSE, END, ENDFILE, FIND, GO TO, IF, END IF, INQUIRE, OPEN, PAUSE, PRINT, READ, RETURN, REWIND, REWRITE, STOP, TYPE, UNLOCK, and WRITE.
48.3 - Specification Statements
The specification statements are: AUTOMATIC, BLOCK DATA, COMMON, DATA, DIMENSION, EQUIVALENCE, EXTERNAL, IMPLICIT, INTRINSIC, NAMELIST, PARAMETER, POINTER, PROGRAM, RECORD, SAVE, STATIC, structure declarations, type declarations, and VOLATILE.
48.4 - ACCEPT
Formatted ACCEPT f[,iolist]
List-directed ACCEPT *[,iolist]
Namelist ACCEPT n
f Is a format specifier not prefaced by FMT=.
iolist Is a simple I/O list element or an implied-DO list.
* Specifies list-directed formatting (can be specified
as FMT=*).
n The nonkeyword form of a namelist specifier.
The control-list parameters are "f," "*" (or FMT=*), and "n". The
I/O list parameter is "iolist".
The formatted ACCEPT statement transfers data from your terminal to
internal storage. The access mode is sequential.
The list-directed ACCEPT statement translates the data from
character to binary format according to the data types of the
variables in the I/O list.
The namelist ACCEPT statement translates the data from character to
binary format according to the data types of the list entities in
the corresponding NAMELIST statement.
Also see the READ Statement.
48.5 - ASSERT
See CDEC$ ASSERT under Statements Directive_Statements in this Help file.
48.6 - ASSIGN
Assigns the value of a statement label to an integer variable.
Statement format:
ASSIGN s TO v
s Is the label of an executable statement or a
FORMAT statement. You must specify the label
as an unsigned integer (from 1-5 characters
long, using digits 0-9).
v Is an integer variable name (must be INTEGER*4).
When the value of a statement label is assigned to an integer
variable: the variable can then be used as a transfer destination
in a following assigned GOTO statement or as a format specifier in
a formatted I/O statement. The ASSIGN statement must be in the
same program unit as and must be executed before the statement(s)
in which the assigned variable is used.
48.7 - Assignment
Assigns the value of the expression to the variable.
Arithmetic/Logical/Character assignment takes the form:
v = e
v Is a scalar memory reference.
e Is an arithmetic expression (arithmetic assignment),
a character scalar memory reference (character assignment),
or a logical scalar memory reference (logical assignment).
The right side of the equation must evaluate to a data type
compatible with the variable on the left side. If aggregates are
involved, the aggregate reference and the aggregate must have
matching structures.
48. 7.1 - Conversion Rules
The following tables summarize the conversion rules for assignment statements. MS signifies the most significant (high-order) bit; LS signifies the least significant (low-order) bit. ---------------------------------------------------------------- |Variable | Expression (E) | |or Array |----------------------------------------------------- |Element |integer or logical | REAL | REAL*8 | ---------------------------------------------------------------- | integer | Assign E to V | Truncate E to | Truncate E to | | or | | integer and | integer and | | logical | | assign to V | assign to V | ---------------------------------------------------------------- | REAL | Append fraction | Assign E to V | Assign MS por- | | | (.0) to E and | | tion of E to V;| | | assign to V | | LS portion of E| | | | | is rounded | ---------------------------------------------------------------- | REAL*8 | Append fraction | Assign E to MS| Assign E to V | | | (.0) to E and | portion of V; | | | | assign to V | LS portion of | | | | | V is 0 | | ---------------------------------------------------------------- | REAL*16 | same as above | same as above | Assign E to MS | | | | | portion of V; | | | | | LS portion of V| | | | | is 0 | ---------------------------------------------------------------- | COMPLEX | Append fraction | Assign E to | Assign MS por- | | | (.0) to E and | real part of | tion of E to | | | assign to real | V; imaginary | real part of V;| | | part of V; imagin-| part of V is | LS portion of | | | ary part of V is | 0.0 | E is rounded; | | | 0.0 | | imaginary part | | | | | of V is 0.0 | ---------------------------------------------------------------- |COMPLEX*16| Append fraction | Assign E to MS | Assign E to | | | (.0) to E and | portion of | real part of | | | assign to V; | real part of V;| V; imaginary | | | imaginary part of| imaginary part | part is 0.0 | | | V is 0.0 | of V is 0.0 | | ---------------------------------------------------------------- continued chart ---------------------------------------------------------------- |Variable | Expression (E) | |or Array |----------------------------------------------------- |Element | REAL*16 | COMPLEX | COMPLEX*16 | ---------------------------------------------------------------- | integer | Truncate E | Truncate real | Truncate real part of| | or | to integer | part of E to | E to integer and | |logical | and assign | integer and | assign to V; imagin- | | | to V | assign to V; | ary part of E is not | | | | imaginary part| used | | | | is not used | | ---------------------------------------------------------------- | REAL | Assign MS | Assign real | Assign MS portion of | | | portion of E| part of E to | the real part of E to| | | to V; LS | V; imaginary | V; LS portion of the | | | portion of E| part of E is | real part of E is | | | is rounded | not used | rounded; imaginary | | | | | part of E is not used| ---------------------------------------------------------------- | REAL*8 | same as | Assign real | Assign real part of E| | | above | part of E to | to V; imaginary part | | | | MS of V; LS | of E is not used | | | | portion of V | | | | | is 0; imagin- | | | | | ary part of E | | | | | is not used | | ---------------------------------------------------------------- | REAL*16 | Assign E to | same as above | Assign real part of E| | | V | | to MS portion of V; | | | | | LS portion of real | | | | | part of V is 0; imag-| | | | | inary part of E is | | | | | not used | ---------------------------------------------------------------- | COMPLEX | Assign MS | Assign E to V | Assign MS portion of | | | portion of E| | real part of E to | | | to real part| | real part of V; LS | | | of V; LS | | portion of real part | | | portion of E| | of E is rounded. | | | is rounded; | | Assign MS portion of | | | imaginary | | imaginary part of E | | | part of V is| | to imaginary part of | | | 0.0 | | V; LS portion of | | | | | imaginary part of E | | | | | is rounded | ---------------------------------------------------------------- |COMPLEX*16| same as | Assign real | Assign E to V | | | above | part of E to | | | | | MS portion of | | | | | real part of V;| | | | | LS portion of | | | | | real part is 0.| | | | | Assign imagin- | | | | | ary part of E | | | | | to MS portion | | | | | of imaginary | | | | | part of V; | | | | | LS portion of | | | | | imaginary part | | | | | is 0 | | ----------------------------------------------------------------
48.8 - AUTOMATIC and STATIC
The AUTOMATIC and STATIC statements are used within a called
subprogram to control the allocation of storage to variables and
the initial value of variables. Statement format:
AUTOMATIC v [,v]...
STATIC v [,v]...
v Is the name of a variable, array, or array declarator.
The following table summarizes the difference between automatic and
static variables upon entry to and exit from a subprogram:
+-----------+---------------------------+------------------------+
| Variable | Entry | Exit |
+-----------+---------------------------+------------------------+
| AUTOMATIC | Variables are unassigned, | The storage area allo- |
| | and do not reflect any | cated to the variable |
| | changes caused in the | is deleted. |
| | previous execution of | |
| | the program. | |
+-----------+---------------------------+------------------------+
| STATIC | Values of the subprogram | The current values of |
| | variables are unchanged | the variables are kept |
| | since the last execution | in the static storage |
| | of the subprogram. | area. |
+-----------+---------------------------+------------------------+
By default, all variables are STATIC. To change the default from
STATIC to AUTOMATIC, specify the /RECURSIVE compiler option.
To override the compiler option in effect for specific variables,
specify the variables in AUTOMATIC or STATIC type statements.
NOTE
Variables in COMMON, DATA, EQUIVALENCE, and SAVE
statements, or in BLOCK DATA subprograms are always
STATIC, regardless of the /RECURSIVE compiler
option or any previous AUTOMATIC specification.
AUTOMATIC variables can reduce memory use because only the
variables currently being used are allocated to memory.
AUTOMATIC variables permit recursion. With recursion, a subprogram
can call itself (directly or indirectly), and resulting values are
available upon a following call or return to the subprogram.
48.9 - BACKSPACE
Repositions a sequential file that is currently open for sequential
access to the beginning of the preceding record. The file must be
on disk or tape. Statement format:
BACKSPACE ([UNIT=]u[,ERR=s][,IOSTAT=ios])
BACKSPACE u
u Is an integer variable or constant specifying the
logical unit number of the file, optionally prefaced
by UNIT=. UNIT= is required if unit is not the
first I/O specifier.
s Is the label of a statement that receives control
if an error occurs, prefaced by ERR=.
ios Is an integer variable to which the completion status
of the I/O operation is returned, prefaced by IOSTAT=
(positive if an error occurs, zero if no error occurs).
A BACKSPACE statement should not be specified for a file that is
open for direct or append access. Backspacing from record "n" can
be done by rewinding to the start of the file and then performing
n-1 successive reads to reach the previous record. For direct and
append access, the current record count ("n") is not available to
the Fortran I/O system.
48.10 - BLOCK_DATA
Begins a block data program unit. Statement format:
BLOCK DATA [nam]
nam Is the symbolic name used to identify the block.
A BLOCK DATA statement and its associated specification statements
are a special kind of program unit, called a block data subprogram.
The block data subprogram has the following syntax rules:
- Any of the following specification statements can appear
in a block data subprogram:
COMMON RECORD
DATA SAVE
DIMENSION STATIC
EQUIVALENCE Structure declaration
IMPLICIT Type declaration statements
PARAMETER
- A block data subprogram must not contain any
executable statements.
- As with other types of program units, the last
statement in a block data subprogram must be an
END statement.
- Within a block data subprogram, if a DATA statement
initializes any entity in a named common block,
the subprogram must have a complete set of speci-
fication statements that establishes the common block.
However, all the entities in the block do not have
to be assigned initial values in a DATA statement.
- One block data subprogram can establish and define
initial values for more than one common block.
- The name of a block data subprogram can appear in the
EXTERNAL statement of a different program unit to force
a search of object libraries for the BLOCK DATA program
unit at link time.
48.11 - CALL
Transfers control and passes arguments to a subprogram.
CALL sub[([a][,[a]]...)]
sub Is the name of a subroutine, or other external
procedure, or a dummy argument associated with
a subroutine subprogram or other external procedure.
a Is a value to be passed to the subroutine.
If you specify an argument list, the CALL statement associates the
values in the list with the dummy arguments in the subroutine. It
then transfers control to the first executable statement following
the SUBROUTINE or ENTRY statement referenced by the CALL statement.
The arguments in the CALL statement must agree in number, order,
and data type with the dummy arguments in the subroutine. They can
be variables, arrays, array elements, records, record elements,
record arrays, record array elements, substring references,
constants, expressions, Hollerith constants, alternate return
specifiers, or subprogram names. An unsubscripted array name or
record array name in the argument list refers to the entire array.
An alternate return specifier is an asterisk (or ampersand)
followed by the label of a statement in the program unit containing
the CALL statement.
Compaq Fortran allows direct or indirect recursive calls to
subroutines, if you specify the /RECURSIVE compiler option.
48.12 - CLOSE
Closes a file. Statement format:
CLOSE ([UNIT=]u[,p][,ERR=s][,IOSTAT=ios])
u Is an integer variable or constant specifying the
logical unit number of the file, optionally prefaced
by UNIT=. UNIT= is required if unit is not the
first I/O specifier.
p Is the disposition of the file after closing, prefaced
by STATUS=, DISPOSE= or DISP=. Dispositions are as follows:
'KEEP' Retains the file.
*DEFAULT FOR ALL BUT SCRATCH FILES*
'SAVE' Retains the file.
'DELETE' Deletes the file.
*DEFAULT FOR SCRATCH FILES*
'PRINT' Submits the file as a print job.
'PRINT/DELETE' Submits then deletes the file as a
print job.
'SUBMIT' Submits the file as a batch job.
'SUBMIT/DELETE' Submits then deletes the file as a
batch job.
s Is the label of an executable statement.
ios Is an integer scalar memory reference. (Returns a
zero if no error condition exists or a positive
integer if an error condition exists.)
The disposition specified in a CLOSE statement supersedes the
disposition specified in the OPEN statement, except that a file
opened as a scratch file cannot be saved, printed, or submitted,
nor can a file opened for read-only access be deleted.
48.13 - COMMON
Defines one or more contiguous blocks of storage shared among
separate subprograms. You can define the same common block in
different program units of your program. The first COMMON
statement in a program unit to name a common block defines it;
later COMMON statements that name the block reference it. You can
leave one common block (the "blank" common block) unnamed.
Statement format:
COMMON [/[cb]/]nlist[[,]/[cb]/nlist]...
cb Is a symbolic name to identify the common block.
nlist Is one or more names of variables, arrays, array
declarators, or records to identify elements of
the common block.
Any common block name, blank or otherwise, can appear more than
once in one or more COMMON statements in a program unit. The list
following each successive appearance of the same common block name
is treated as a continuation of the list for the block associated
with that name.
You can use array declarators in the COMMON statement to define
arrays.
A common block can have the same name as a variable, array, record,
structure, or field. However, in a program with one or more
program units, a common block cannot have the same name as a
function, subroutine, or entry name in the executable program.
When common blocks from different program units have the same name,
they share the same storage area when the units are combined into
an executable program.
Entities are assigned storage in common blocks on a one-for-one
basis. Thus, the entities assigned by a COMMON statement in one
program unit should agree with the data type of entities placed in
a common block by another program unit; for example, consider a
program unit containing the following statement:
COMMON CENTS
Consider another program unit containing the following statements:
INTEGER*2 MONEY
COMMON MONEY
When these program units are combined into an executable program,
incorrect results can occur if the 2-byte integer variable MONEY is
made to correspond to the lower-addressed two bytes of the real
variable CENTS.
48.14 - CONTINUE
Transfers control to the next executable statement. The CONTINUE
statement is used primarily as the terminal statement of a labeled
DO loop when that loop would otherwise end improperly with a GOTO,
arithmetic IF, or other prohibited control statement. Statement
format:
CONTINUE
48.15 - DATA
Assigns values to variables at compile time. The values within the
backslashes are assigned to the preceding variables left to right;
the number of values must equal the number of variable elements.
Statement format:
DATA nlist/clist/[[,] nlist/clist]...
nlist Is a list combining any combination of variable names,
array names, array element names, character substring
names, and implied-DO lists. (RECORDs are not allowed
in this list.) Elements in the list must be separated
by commas.
Subscript expressions and expressions in substring
references must be integer expressions containing
integer constants and implied-DO variables.
An implied-DO list in a DATA statement takes the
following form:
(dlist, i = n1,n2[,n3])
dlist Is a list of one or more array element
names, character substring names, or
implied-DO lists, separated by commas.
i Is the name of an integer variable.
n1,n2,n3 Are integer constant expressions. The
expression can contain implied-DO variables
of other implied-DO lists that have this
implied-DO list within their ranges.
clist Is a list of constants separated by commas; "clist"
constants take one of the following forms:
c OR n *c
c Is a constant or the symbolic name of a constant.
n Defines the number of times the same value is to
be assigned to successive entities in the associated
"nlist"; "n" is a nonzero, unsigned integer constant
or the symbolic name of an unsigned integer constant.
The DATA statement assigns the constant values in each "clist" to
the entities in the preceding "nlist", from left to right, as they
appear in the "nlist". The number of constants must equal the
number of entities in the "nlist".
When an unsubscripted array name appears in a DATA statement,
values are assigned to every element of that array in the order of
subscript progression. The associated constant list must contain
enough values to fill the array.
For more information on the relationship between "nlist" and
"clist", see your user manual.
48.16 - DELETE
Deletes a record from an indexed or relative file.
Format -- indexed:
DELETE ([UNIT=]u[,ERR=s][,IOSTAT=ios])
Deletes the current record (last record read) from an indexed
file.
Format -- Relative:
DELETE ([UNIT=]u,REC=r[,ERR=s][,IOSTAT=ios])
DELETE (u'r[,ERR=s][,IOSTAT=ios])
Deletes the specified record from a relative file.
u Is the logical unit specifier, optionally prefaced
by UNIT=. UNIT= is required if unit is not the first
I/O specifier.
r Is a record position specifier, prefaced by REC=.
u'r Is a unit and a record position specifier, not
prefaced by REC=.
s Is the label of a statement to which control is
transferred if an error occurs, prefaced by ERR=.
ios Is an I/O status specifier, prefaced by IOSTAT=.
The forms of the DELETE statement with relative files are direct
access deletes. These forms delete the record specified by the
number "r".
The DELETE statement logically removes the appropriate record from
the specified file by locating the record and marking it as a
deleted record. A new record can be written into that position.
Following a direct access delete, any associated variable is set to
the next record number.
48.17 - DICTIONARY
At compile time, incorporates Oracle Common Data Dictionary
(CDD/Repository) data definitions into the current Fortran source file.
The DICTIONARY statement can appear anywhere in a Fortran source file
that a specification statement is allowed. Statement format:
DICTIONARY 'cdd-path [/[NO]LIST]'
cdd-path The full or relative pathname of a Common
Data Dictionary object. The resulting pathname
must conform to the rules for forming Common
Data Dictionary pathnames. The object must be
a record description.
/[NO]LIST Directs the compiler to include (or not include)
the resulting Fortran source representation in
the program listing. /LIST and /NOLIST must be
spelled completely.
In the following example, the logical name definition specifies the
beginning of the CDD pathname; thus, a relative pathname specifies
the remainder of the path to the record definition:
$ DEFINE CDD$DEFAULT CDD$TOP.FOR
The following examples show how a CDD pathname beginning with
CDD$TOP overrides the default CDD pathname. Consider a record with
the pathname CDD$TOP.SALES.JONES.SALARY. If you defined
CDD$DEFAULT to be CDD$TOP.SALES.JONES, you could then specify a
relative pathname:
DICTIONARY 'SALARY'
Alternatively, you could specify a full pathname:
DICTIONARY 'CDD$TOP.SALES.JONES.SALARY'
48.18 - DIMENSION
Defines the number of dimensions in an array and the number of
elements in each dimension. Statement format:
DIMENSION a([d1:]d2)[,a([d1:]d2)]...
a Is the symbolic name of the array. If the array
is not defined in a data type statement, the array
takes an implicit data type.
[d1:]d2 Is the optional lower (d1) and required upper (d2)
bounds of the array.
48.19 - DO
Executes a block of statements repeatedly until the value of a
control variable equals, exceeds, or is less than the terminal
value, according to the control variable specified in the DO loop.
The block of statements starts immediately following the DO
statement.
You can transfer control out of a DO loop, but not out of a
parallel DO loop.
Statement format:
DO [s[,]] v = e1,e2[,e3]
s Is the optional label of an executable statement
that follows the DO statement in the same program unit.
The label designates the last statement of the DO
loop. If omitted, an END DO statement is required.
v Is the control variable; an integer or real variable
(it cannot be a record field). You cannot modify
the control variable inside the DO loop.
e1 Is the initial value of the control variable; an
integer or real value.
e2 Is the terminal value of the control variable; an
integer or real value.
e3 Is the value by which to increment the control
variable after each execution of the DO loop;
integer or real value. It cannot be 0.
The default of e3 is 1.
If the iteration count (the number of executions of the DO range)
is zero or negative, the body of the loop is not executed. If the
/NOF77 compiler option is specified and the iteration count is zero
or negative, the body of the loop is executed once.
48.20 - DO_WHILE
Executes a block of statements repeatedly until the value of a
logical expression is false. Statement format:
DO [s[,]] WHILE (e)
s Is the label of an executable statement that follows
the DO statement in the same program unit. The label
designates the last statement of the DO loop. If
omitted, an END DO statement is required.
e Is a logical expression. You can reference and modify
the variable elements of the expression within the
DO loop.
You can transfer control out of a DO WHILE loop but not into a loop
from elsewhere in the program.
The DO WHILE statement tests the logical expression at the
beginning of each execution of the loop, including the first. If
the value of the expression is true, the statements in the body of
the loop are executed; if the expression is false, control
transfers to the statement following the loop.
If no label appears in the DO WHILE statement, the DO WHILE loop
must be terminated with an END DO statement.
48.21 - ELSE
Executes a block of statements if no preceding statement block in a
block IF construct was executed. The block of statements starts
immediately following the ELSE statement. The block is terminated
by an END IF statement. Statement format:
ELSE
48.22 - ELSE_IF
Executes a block of statements if no preceding statement block in a
block IF construct was executed and if the value of a logical
expression is true. The block of statements starts immediately
following the ELSE IF statement. The block is terminated by
another ELSE IF statement, an ELSE statement, or an END IF
statement. Statement format:
ELSE IF (e) THEN
Where e represents a logical expression.
48.23 - END
Marks the end of a program unit. The END statement must be present
as the last statement of every program unit. In a main program,
execution terminates if control reaches the END statement. In a
subprogram, a RETURN statement is implicitly executed. Statement
format:
END
48.24 - END_DO
Terminates the block of statements following a DO or DO WHILE
statement when a label is not used. Statement format:
END DO
48.25 - END_MAP
Marks the end of a map declaration within a union declaration in a
structure declaration block. Terminates a field declaration or a
series of field declarations that started with the MAP statement.
The END MAP statement must be present in a map declaration.
Statement format:
END MAP
48.26 - END_STRUCTURE
Marks the end of a structure declaration. The END STRUCTURE
statement must be present as the last statement of every structure
declaration. Statement format:
END STRUCTURE
48.27 - END_UNION
Marks the end of a union declaration within a structure declaration
block. The END statement must be present as the last statement of
every union declaration. Statement format:
END UNION
48.28 - ENDFILE
Writes an end of file record to a file. An end of file record
consists of one byte with the ASCII value 26 (CTRL/Z). An end-file
record can be written only to sequential organization files that
are accessed as formatted sequential files or unformatted segmented
sequential files. Statement format:
ENDFILE ([UNIT=]u[,ERR=s][,IOSTAT=ios])
ENDFILE u
u Is an integer variable or constant specifying
the logical unit number of the file, optionally
prefaced by UNIT=. UNIT= is required if unit is
not the first I/O specifier.
s Is the label of a statement to which control is
transferred if an error occurs, prefaced by ERR=.
ios Is an integer variable to which the completion
status of the I/O operation is returned, prefaced
by IOSTAT= (a zero if no error occurs; a positive
value if an error occurs).
If the unit specified in the ENDFILE statement is not open, the
default file is opened for unformatted output.
An end-of-file record consists of one byte with the ASCII value 26
(Ctrl/Z). An end-of-file record can be written only to sequential
organization files that are accessed as formatted sequential files
or unformatted segmented sequential files.
An ENDFILE statement must not be specified for a file that is open
for direct access. End-of-file records should not be written in
files that are read by programs written in a language other than
Fortran.
48.29 - END_IF
Terminates a block IF construct. Statement format:
END IF
48.30 - ENTRY
Designates an alternate entry point at which execution of a
subprogram can commence. You cannot use an ENTRY statement in a DO
loop or a block IF construct. Statement format:
ENTRY nam[([p[,p]...])]
nam Is a symbolic name for the entry point. The name
must be unique among all global names in the program.
In a function subprogram, the data type defined for
or implied by the name and the data type of the
function must be consistent within the following groups:
Group 1: BYTE, INTEGER*1, INTEGER*2, INTEGER*4,
LOGICAL*1, LOGICAL*2, LOGICAL*4, REAL*4,
REAL*8, and COMPLEX*8
Group 2: REAL*16 and COMPLEX*16
Group 3: CHARACTER
If the data type is character, the length of the entry
point name must be the same as the function name or must
be of passed length.
p Is a dummy argument or an alternate return argument
(designated by an asterisk). The arguments must agree in
order, number, and type with the actual arguments of the
statement invoking the entry point. The arguments need
not agree in name, order, number, or type with the
dummy arguments in the SUBROUTINE or FUNCTION statement
for the subprogram. You must use only the dummy arguments
defined in the ENTRY statement.
The ENTRY statement is not executable and can appear within a
function or subroutine program after the FUNCTION or SUBROUTINE
statement. Execution of a subprogram referred to by an entry name
begins with the first executable statement after the ENTRY
statement.
48.31 - EQUIVALENCE
Starts two or more data elements in one program unit at the same
storage location, thereby overlaying them in memory. Statement
format:
EQUIVALENCE (nlist)[,(nlist)]...
nlist Is a list of variables, array elements, arrays,
or character substring references, separated by
commas. You must specify at least two of these
entities in each list.
The elements named within each set of parentheses are given the
same storage location. The data elements do not have to be of the
same type or length. An equivalency begins with the first byte of
each element. When an array or substring element is equivalenced,
the entire array or string is equivalenced in its normal linear
storage.
You cannot equivalence array or string elements in a manner that is
inconsistent with their normal linear order. You cannot
equivalence elements of the same array or string. You cannot
equivalence two elements that are both in common areas.
Records, record fields, and dummy arguments cannot be specified in
EQUIVALENCE statements.
You can identify a multidimensional array element by a single
subscript. The single subscript designates the absolute position
of the element within the array.
48.32 - EXTERNAL
Specifies that a name is a global symbol defined outside the
program unit. Statement format:
EXTERNAL v[,v]...
EXTERNAL *v[,*v]...
v Is the symbolic name of a user-supplied subprogram, or
the name of a dummy argument associated with the name
of a subprogram. If you name an intrinsic subprogram,
that name becomes disassociated from the intrinsic
subprogram and is assumed to be the name of an external
element. (The INTRINSIC statement allows intrinsic
function names to be used as arguments.)
* Is permitted only with the -nof77 option.
You must use EXTERNAL statements in the following cases:
- To identify subprogram or entry point names passed as actual
arguments
- To identify a block data program unit that will reside in a
library module not explicitly referenced at link time.
You do not need to use an EXTERNAL statement to identify a
subprogram or entry point name used as the object of a CALL
statement or function reference; these names are recognized as
external implicitly.
48.33 - FORMAT
Defines the conversion of data in formatted data transfer
operations. Statement format:
FORMAT (q1 f1s1 f2s2 ... fnsn qn)
qn Is zero or more slash (/) record terminators.
fn Is a field descriptor, an edit descriptor, or
a group of field and edit descriptors enclosed
in parentheses.
sn Is a field separator (a comma or slash). A
comma can be omitted in the following cases:
o Between a P edit descriptor and an immediately
following F, E, D, or G edit descriptor.
o Before or after a slash (/) record terminator.
o Before or after a colon (:) edit descriptor.
The "field descriptor" has one of the following forms:
[r]c [r]cw [r]cw.m [r]cw.d[Ee]
r Is the optional repeat count. (If you omit r,
the repeat count is assumed to be 1.)
c Is a format code (I,O,Z,F,E,D,G,L, or A).
w Is the external field width in characters. Each
data item in the external medium is called an
external field.
m Is the minimum number of characters that must appear
in the field (including leading zeros).
d Is the number of characters to the right of the decimal point.
E Is an exponent field.
e Is the number of characters in the exponent.
The terms "r", "w", "m" and "d" must all be unsigned integer
constants or variable format expressions. A variable format
expression is an integer variable or expression enclosed in angle
brackets that takes the place of an integer constant. The value of
the variable or variables can change during program execution.
The values of "r" and "w" must be in the range of 1 through 32767
(2**15-1), the values of "m" and "d" must be in the range of 0
through 255 (2**8-1), and "e" must be in the range of 1 through 255
(2**8-1). You cannot use PARAMETER constants for the terms "r",
"w", "m", "d", or "e".
The "edit descriptor" has one of the following forms:
c [n]c c[n]
c Is a format code (X,T,TL,TR,SP,SS,S,BN,BZ,P,H,Q,'...'
$, or :).
n Is the optional number of characters or character
positions.
The term "n" must be an unsigned integer constant (for format code
P, it can be signed or unsigned) or a variable format expression.
A variable format expression is an integer variable or expression
enclosed in angle brackets that takes the place of an integer
constant. The value of the variable or variables can change during
program execution.
The value of "n" for P must be within the range -128 to 127. For
all other format codes, the value of "n" must be within the range 1
through 65535 (2**16-1); above 65535, the value truncates to 16
bits. Note that if you write to a record, it must be able to
accommodate the size of "n".
For more detail see Format_Specifiers.
48.34 - FUNCTION
Begins a function subprogram. Identifies the data type of the
function and names the dummy arguments. Format:
[typ] FUNCTION nam[*m][([p[,p]...])]
typ Is a data type. If you do not specify a data type,
the data type of the function is implied from its
name. If the data type is CHARACTER, you can specify
CHARACTER*(*) to indicate a passed length function
type -- the function type assumes the length of its
definition in the program unit invoking it.
nam Is a symbolic name for the function. The name must be
unique among all global names in the program. The name
is used as a variable within the function. The value of
the variable is returned to the caller of the function
as the value of the function.
m Is an unsigned, nonzero integer specifying the length of
the data type. It must be one of the valid length specifiers
for "typ". This length overrides the length specified or
implied by the type.
p Is an unsubscripted variable name specifying a dummy
argument. The arguments must agree in order, number, and
type with the actual arguments of the statement invoking
the function. A dummy argument must not be defined as an
array with more elements than the actual argument holds.
The array declarator for a dummy argument can itself contain
integer values that are dummy arguments or are references to a
common block, providing for adjustable size arrays in functions.
The upper bound of the array declarator for a dummy argument can be
specified as an asterisk, in which case the upper bound of the
dummy argument assumes the size of the upper bound of the actual
argument. The size in a character string declarator for a dummy
argument can be specified as an asterisk in parentheses -- in which
case the size of the actual argument is passed to the dummy
argument.
The values of the actual arguments in the invoking program unit
become the values of the dummy arguments in the function. If you
modify a dummy argument, the corresponding actual argument in the
invoking program unit is also modified; the actual argument must be
a variable if it is to be modified.
If the actual argument is a character constant, the dummy argument
can be either character or numeric in type, unless the name of the
subprogram being invoked is a dummy argument in the invoking
program unit. If the actual argument is a Hollerith constant, the
dummy argument must be numeric.
The FUNCTION statement must be the first statement of a function
subprogram, unless an OPTIONS statement is specified. A function
subprogram cannot contain a SUBROUTINE statement, a BLOCK DATA
statement, a PROGRAM statement, or another FUNCTION statement.
ENTRY statements can be included to provide multiple entry points
to the subprogram.
NOTE
In a function, the function name identifier refers
to the return value, not the function itself,
unless an argument list is present. Therefore, it
is not possible to pass a function as an argument
to another routine from inside the function. For
example, consider the following:
INTEGER FUNCTION RECURSIVE_FUNCTION
.
.
.
CALL OTHERSUB (RECURSIVE_FUNCTION)
The reference to RECURSIVE_FUNCTION in the CALL
statement passes the function return value, not the
function itself.
48.35 - Function Reference
Transfers control and passes arguments to a function. Format:
nam(p[,p]...)
nam Is the name of the function or the name of an entry
point to the function.
p Is a value to be passed to the function. The value
can be a constant, the name of a variable, the name
of an array element, the name of an array, an expression,
a substring, field reference, or the name of a subprogram
or entry point to a subprogram (must be defined as
external). You must not specify more than 255 arguments.
48.36 - GOTO
Transfers control within a program unit. Depending upon the value of an expression, control is transferred either to the same statement every time GO TO is executed or to one of a set of statements.
48. 36.1 - Unconditional
Transfers control unconditionally to the same statement every time
the GO TO is executed. Statement format:
GO TO s
s Is the label of an executable statement that is
in the same program unit as the GO TO statement.
48. 36.2 - Computed
Transfers control to a statement based upon the value of an
expression within the statement. Statement format:
GO TO (slist)[,]e
slist Is a list of one or more labels of executable
statements separated by commas. The list of labels
is called the transfer list.
e Is an integer arithmetic expression in the range
1 to n (where "n" is the number of statement labels
in the transfer list).
If the value of e is less than one or greater than the number of
labels in the transfer list, control is transferred to the first
executable statement after the computed GO TO.
48. 36.3 - Assigned
Transfers control to a statement label that is represented by a
variable. An ASSIGN statement must establish a relationship
between the variable and the specified statement label. Statement
format:
GO TO v[[,](slist)]
v Is an integer variable whose value was set by a
preceding ASSIGN statement in the same program unit.
(In Compaq Fortran, v must be INTEGER*4.)
slist Is a list of one or more labels of executable
statements separated by commas.
48.37 - IF
Conditionally transfers control or executes a statement or block of statements. For each type of IF statement, the decision to transfer control or to execute the statement or block of statements is based on the evaluation of an expression within the IF statement.
48. 37.1 - Arithmetic
Executes the statement at the first label if the arithmetic
expression evaluates to a value less than 0; the statement at the
second label if the arithmetic expression evaluates to 0; or the
statement at the third label if the arithmetic expression evaluates
to a value greater than 0. Statement format:
IF (e) s1,s2,s3
e Is an arithmetic expression.
s1,s2,s3 Are labels of executable statements in the same
program unit. All three labels are required,
but they need not refer to different statements.
Executes the statement at the first label ("s1") if the arithmetic
expression evaluates to a value less than 0; the statement at the
second label ("s2") if the arithmetic expression evaluates to 0; or
the statement at the third label ("s3") if the arithmetic
expression evaluates to a value greater than 0.
48. 37.2 - Logical
Executes the statement if the logical expression is true.
Statement format:
IF (e) st
e Is a logical expression.
st Is a complete Fortran statement. The statement can
be any statement except DO, END DO, END, block IF,
or another logical IF statement.
48. 37.3 - Block
Executes a block of statements if the logical expression is true.
The block of statements starts immediately following the IF
statement. The block of statements can be followed by optional
ELSE IF statements (any number) and one optional ELSE statement.
The entire block IF construct must be terminated by an END IF
statement. Format:
IF (e) THEN
block
ELSE IF (e1) THEN
block
ELSE
block
END IF
e,e1 Are logical expressions.
block Is a series of zero or more Fortran statements
(called a statement block).
NOTE: No additional statement can be placed after the IF THEN
statement in a block IF construct. For example, the following
statement is invalid in the block IF construct:
IF (e) THEN I = J
This statement is translated as the following logical IF statement:
IF (e) THENI = J
48.38 - IMPLICIT
Defines the type specifications of implicitly defined variables.
Statement format:
IMPLICIT typ(a[,a]...)[,typ(a[,a]...)]...
typ Is any data type except CHARACTER*(*). When "typ"
is equal to CHARACTER*len, "len" specifies the length
for character data type. The "len" is an unsigned
integer constant or an integer constant expression
enclosed in parentheses, and must be in the range of
1 to 65535.
a Is an alphabetical character. If you specify a
range of alphabetic characters (two characters
joined by a hyphen), the first character must be
less than the second.
The IMPLICIT statement assigns the specified data type to all
symbolic names that have no explicit data type and begins with the
specified letter or range of letters. It has no effect on the
default types of intrinsic procedures.
48.39 - IMPLICIT_NONE
Inhibits the implicit declaration of data types in the program
unit. When it is used, you must declare the data types of all
symbols explicitly. You must not include any other IMPLICIT
statements in the program unit. containing an IMPLICIT NONE
statement. Statement format:
IMPLICIT NONE
NOTE: To receive warnings when variables are used but not
declared, you can specify the /WARNINGS=DECLARATIONS compiler
option instead of IMPLICIT NONE.
48.40 - INCLUDE
Directs the compiler to stop reading statements from the current
file and read the statements in the included file or module. When
it reaches the end of the included file or module, the compiler
resumes compilation with the next statement after the INCLUDE
statement. Statement format:
INCLUDE 'full-file-name[/[NO]LIST]'
INCLUDE '[text-lib] (module-name)[/[NO]LIST]'
full-file-name Is a character string that specifies
the file to be included. The form of
the "full-file-name" must be acceptable
to the operating system, as described
in your user manual.
/[NO]LIST Specifies whether the incorporated code
is to appear in the compilation source
listing. In the listing, a number precedes
each incorporated statement. The number
indicates the "include" nesting depth of
the code. The default is /NOLIST. /LIST
and /NOLIST must be spelled completely.
text-lib Is a character string that specifies
the "full-file-name" of the text
library to be searched. Its form must
be acceptable to the operating system,
as described in your user manual. If
"text-lib" is omitted, the specified
"module-name" must reside in the default
Fortran text library SYS$LIBRARY:FORSYSDEF.TLB,
or a user-specified default library.
module-name Is the name of the text module, located
in a text library, that is to be included.
The name of the module must be enclosed
in parentheses. It can be up to 31 char-
acters long and can contain any alpha-
numeric character and the special char-
acters dollar sign ($) and underscore (_).
The file or module must contain valid Fortran statements. The file
or module cannot start with a continuation line, but it can contain
an INCLUDE statement.
The limit on nesting depth is 10.
In the following example, the file COMMON.FOR defines a parameter
constant M, and defines arrays X and Y as part of the blank common
block.
Main Program File COMMON.FOR File
----------------- ---------------
INCLUDE 'COMMON.FOR' PARAMETER (M=100)
DIMENSION Z(M) COMMON X(M),Y(M)
CALL CUBE
DO 5, I=1,M
5 Z(I) = X(I)+SQRT(Y(I))
.
.
.
END
SUBROUTINE CUBE
INCLUDE 'COMMON.FOR'
DO 10, I=1,M
10 X(I) = Y(I)**3
RETURN
END
48.41 - Input Output
Transfer I/O statements include READ, WRITE, REWRITE, ACCEPT, TYPE,
and PRINT. Auxiliary I/O statements include OPEN, CLOSE, INQUIRE,
REWIND, BACKSPACE, ENDFILE, DELETE, and UNLOCK.
Transfer I/O statements can be formatted (F), unformatted (U),
list-directed (L-D), or namelist (N) as follows:
ACCEPT Sequential -- F, L-D, N
DELETE Relative -- U
Indexed -- U
PRINT Sequential -- F, L-D, N
READ Sequential -- F, U, L-D, N
Direct Access -- F, U
Internal -- F, L-D
Indexed -- F, U
REWRITE Relative -- F, U
Sequential -- F
Indexed -- F, U
TYPE Sequential -- F, L-D, N
WRITE Sequential -- F, U, L-D, N
Direct Access -- F, U
Internal -- F, L-D
Indexed -- F, U
48. 41.1 - Formatted
Formatted I/O statements contain explicit format specifiers that
are used to control the translation of data from internal (binary)
form within a program to external (readable character) form in the
records, or vice versa.
Formatted I/O statements must have a format (FMT=) specified in the
control list (clist). Additional "clist" elements are required
depending on the type of access.
Formatted sequential READ:
READ (UNIT=u,FMT=f[,IOSTAT=ios][,ERR=err][,END=end]) [iolist]
READ f [,iolist]
Formatted direct access READ:
READ (UNIT=u,REC=rec,FMT=f[,IOSTAT=ios][,ERR=err]) [iolist]
Formatted indexed READ:
READ (UNIT=u,FMT=f,KEY=k[,KEYID=n][,IOSTAT=ios][,ERR=err]) [iolist]
Formatted internal READ:
READ (UNIT=u,FMT=f[,IOSTAT=ios][,ERR=err][,END=end]) [iolist]
Formatted sequential WRITE:
WRITE (UNIT=u,FMT=f[,IOSTAT=ios][,ERR=err]) [iolist]
Formatted direct access WRITE:
WRITE (UNIT=u,REC=rec,FMT=f[,IOSTAT=ios][,ERR=err]) [iolist]
Formatted indexed WRITE:
WRITE (UNIT=u,FMT=f[,IOSTAT=ios][,ERR=err]) [iolist]
Formatted internal WRITE:
WRITE (UNIT=u,FMT=f[,IOSTAT=ios][,ERR=err]) [iolist]
48. 41.2 - Unformatted
Unformatted I/O statements do not contain format specifiers and
therefore do not translate the data being transferred.
Unformatted I/O is especially appropriate where the output data
will later be used as input. Unformatted I/O saves execution time
by eliminating the data translation process, preserves greater
precision in the external data, and usually conserves file storage
space.
Unformatted I/O statements do not specify a format (FMT=) in the
control list (clist). Other "clist" elements are required
depending on the type of access.
Unformatted sequential READ:
READ (UNIT=u[,IOSTAT=ios][,ERR=err][,END=end]) [iolist]
Unformatted direct access READ:
READ (UNIT=u,REC=rec[,IOSTAT=ios][,ERR=err]) [iolist]
Unformatted indexed READ:
READ (UNIT=u,KEY=k[,KEYID=n][,IOSTAT=ios][,ERR=err]) [iolist]
Unformatted sequential WRITE:
WRITE (UNIT=u,[,IOSTAT=ios][,ERR=err]) [iolist]
Unformatted direct access WRITE:
WRITE (UNIT=u,REC=rec[,IOSTAT=ios][,ERR=err]) [iolist]
Unformatted indexed WRITE:
WRITE (UNIT=u[,IOSTAT=ios][,ERR=err]) [iolist]
48. 41.3 - List Directed
List-directed I/O statements are similar to formatted statements in
function, but control the translation of data through data types
instead of explicit format specifiers.
List-directed I/O statements specify a format (FMT=) in the control
list (clist). Other "clist" elements are required depending on the
type of access.
List-directed sequential READ:
READ (UNIT=u,FMT=*[,IOSTAT=ios][,ERR=err][,END=end]) [iolist]
READ * [,iolist]
List-directed internal READ
READ (UNIT=u,FMT=*[,IOSTAT=ios][,ERR=err][,END=end]) [iolist]
List-directed sequential WRITE
WRITE (UNIT=u,FMT=*[,IOSTAT=ios][,ERR=err]) [iolist]
List-directed internal WRITE
WRITE (UNIT=u,FMT=*[,IOSTAT=ios][,ERR=err]) [iolist]
48. 41.4 - Namelist
Namelist I/O statements are similar to formatted statements in
function, but control the translation of data through data types
instead of explicit format specifiers.
Namelist I/O statements do not specify a format (FMT=) in the
control list (clist).
Namelist sequential READ:
READ (UNIT=u,NML=nml[,IOSTAT=ios][,ERR=err][,END=end])
READ n
Namelist sequential WRITE:
WRITE (UNIT=u,NML=nml[,IOSTAT=ios][,ERR=err])
48.42 - INQUIRE
Returns information about specified properties of a file or of a
logical unit on which a file might be opened. The unit need not
exist, nor need it be connected to a file. If the unit is
connected to a file, the inquiry encompasses both the connection
and the file. Statement format:
INQUIRE ([FILE=fi][,DEFAULTFILE=dfi...],flist)
INQUIRE ([UNIT=]u,flist)
fi Is a character expression, numeric scalar memory
reference, or numeric array name reference whose
value specifies the name of the file to be
inquired about.
dfi Is a character expression specifying a default file
specification string. Parts of the file specification
not specified in FILE are filled in from DEFAULTFILE.
Parts of the file specification that are still missing
are filled in from your default directory when the
program runs.
flist Is a list of property specifiers in which any one
specifier appears only once. Information about the
individual specifiers is available under the
subtopic headings listed at the end of this Help
topic.
u Is an integer variable or constant specifying the
logical unit number of the file, optionally prefaced
by UNIT=. UNIT= is required if unit is not the
first I/O specifier. The unit does not have to
exist, nor does it need to be connected to a file.
If the unit is connected to a file, the inquiry
encompasses both the connection and the file.
FILE=fi and UNIT=u can appear anywhere in the property-specifier
list; however, if the UNIT keyword is omitted, the unit specifier
("u") must be the first parameter in the list.
When inquiring by file, you can specify DEFAULTFILE=dfi in addition
to, or in place of, FILE=fi. If a file is open with both FILE and
DEFAULTFILE keywords specified in the OPEN statement, then you can
inquire about this file by specifying both the FILE and DEFAULTFILE
keywords in the INQUIRE statement.
An INQUIRE statement can be executed before, during, or after the
connection of a file to a unit. The values assigned by the
statement are those that are current when the INQUIRE statement
executes.
You can use INQUIRE to get file characteristics before opening a
file. (File characteristics are stored in the file header.)
48. 42.1 - ACCESS
ACCESS = acc
acc Is a character scalar memory reference that is
assigned one of the following values:
'SEQUENTIAL' If the file is open for sequential access
'DIRECT' If the file is open for direct access
'KEYED' If the file is open for keyed access
'UNKNOWN' If the file is not open
48. 42.2 - BLANK
BLANK = blnk
blnk Is a character scalar memory reference that is
assigned one of the following values:
'NULL' If null blank control is in effect for the
file open for formatted I/O. (Blanks are
ignored unless the field is all blanks, in
which case it is treated as zero.)
'ZERO' If zero blank control is in effect. (All
blanks other than leading blanks are treated
as zeros.)
'UNKNOWN' If the file is not open or if the existing
file is not open for formatted I/O.
48. 42.3 - CARRIAGECONTROL
CARRIAGECONTROL = cc
cc Is a character scalar memory reference that is
assigned one of the following values:
'FORTRAN' If the file is open with the FORTRAN carriage
control
'LIST' If the file is open with implied carriage control
(single spacing between records)
'NONE' If the file is open with no carriage control
attribute
'UNKNOWN' If none of the above values apply
48. 42.4 - CONVERT
CONVERT = fm
fm Is a character scalar memory reference that is assigned
one of the following values:
'LITTLE_ENDIAN': If the file is open with little
endian integer and IEEE floating-point
data conversion in effect.
'BIG_ENDIAN': If the file is open with big endian
integer and IEEE floating-point data
conversion in effect.
'CRAY': If the file is open with big endian
integer and CRAY floating-point data
conversion in effect.
'IBM': If the file is open with big endian
integer and IBM System\370 floating-
point data conversion in effect.
'VAXD': If the file is open with little
endian integer and Compaq VAX
F_floating and D_floating data
conversion in effect.
'VAXG': If the file is open with little
endian integer and Compaq VAX
F_floating and G_floating data
conversion in effect.
'NATIVE': If the file is open with no data
conversion in effect.
'UNKNOWN': If the file or unit is not connected
for unformatted I/O.
48. 42.5 - DIRECT
DIRECT = dir
dir Is a character scalar memory reference that is
assigned one of the following values:
'YES' If the file is open for direct access
'NO' If the file is not open for direct access
'UNKNOWN' If the processor cannot determine whether
the processor is open for direct access
48. 42.6 - ERR
ERR = s s Is the label of an executable statement. ERR is a control specifier rather than a property specifier. If an error occurs during the execution of the INQUIRE statement, control is transferred to the statement whose label is "s".
48. 42.7 - EXIST
EXIST = lv
lv Is a logical scalar memory reference that is
assigned one of the following values:
.TRUE. If the specified file exists and can be opened
or if the unit exists
.FALSE. If the specified file or unit does not exist or
if the file exists but cannot be opened
The unit exists if it is a number in the range allowed by the
processor.
48. 42.8 - FORM
FORM = fm
fm Is a character scalar memory reference that is
assigned one of the following values:
'FORMATTED' If the file is open for formatted I/O
'UNFORMATTED' If the file is open for unformatted I/O
'UNKNOWN' If no connection exists
48. 42.9 - FORMATTED
FORMATTED = fmd
fmd Is a character character scalar memory reference that is
assigned one of the following values:
'YES' If formatted I/O is allowed
'NO' If formatted I/O is not allowed
'UNKNOWN' If the processor cannot determine whether formatted
I/O is allowed
48. 42.10 - IOSTAT
IOSTAT = ios ios Is an integer scalar memory reference. IOSTAT is a control specifier rather than a property specifier. The "ios" is assigned a processor-dependent positive integer value if an error occurs during execution of the INQUIRE statement; it is assigned the value zero if there is no error condition.
48. 42.11 - KEYED
KEYED = kyd
kyd Is a character scalar memory reference that is assigned
one of the following values:
'YES' If keyed access is allowed.
'NO' If keyed access is not allowed.
'UNKNOWN' If the processor cannot determine whether
keyed access is allowed
48. 42.12 - NAME
NAME = nme
nme Is a character scalar memory reference that is
assigned the name of the file being inquired about.
If the file does not have a name, "nme" is undefined.
NOTE: The FILE and NAME keywords are synonyms when used with the
OPEN statement, but not when used with the INQUIRE statement.
48. 42.13 - NAMED
NAMED = nmd
nmd Is a logical scalar memory reference that is
assigned one of the following values:
.TRUE. If the specified file has a name
.FALSE. If the file does not have a name
48. 42.14 - NEXTREC
NEXTREC = nr
nr Is an integer scalar memory reference whose value depends
on the following conditions:
- If a record was previously read or written on the
specified unit, the value of "nr" is one more than the
number of that record.
- If no records have been read or written, the value
of "nr" is 1.
- If the file is not opened for direct access or if the
position is indeterminate because of an error condition,
"nr" is 0.
48. 42.15 - NUMBER
NUMBER = num
num Is an integer scalar memory reference to which the
logical unit number of the file is returned. No value
is returned if the file is not connected to a unit.
48. 42.16 - OPENED
OPENED = od
od Is a logical scalar memory reference that is
assigned one of the following values:
.TRUE. If the specified file or unit is open
.FALSE. If the specified file or unit is not open
48. 42.17 - ORGANIZATION
ORGANIZATION = org
org Is a character scalar memory reference that is
assigned one of the following values:
'SEQUENTIAL' If the file is a sequential file
'RELATIVE' If the file is a relative file
'INDEXED' (OpenVMS only) If the file is an indexed file
'UNKNOWN' If the file organization cannot
be determined
48. 42.18 - RECL
RECL = rcl
rcl Is an integer scalar memory reference whose value
depends on the following conditions:
- If the file or unit is open, "rcl" is the maximum
record length allowed in the file
- If the file is not open, "rcl" is the maximum
record length allowed in the file; or, if the
maximum record length is 0, "rcl" is the length
of the longest record in the file
- If the file is segmented, "rcl" is the longest
segment length in the file
- If the file does not exist, "rcl" is 0.
The length is expressed in bytes for formatted files and longwords
for unformatted files.
48. 42.19 - RECORDTYPE
RECORDTYPE = rtype
rtype Is a character scalar memory reference that is
assigned one of the following values:
'FIXED' If the file is open for fixed-length records
'VARIABLE' If the file is open for variable-length records
'SEGMENTED' If the file is open for unformatted sequential
I/O using segmented records
'STREAM' If the file's records are not terminated
'STREAM_CR' If the file's records are terminated with a
carriage-return
'STREAM_LF' If the file's records are terminated with a
line-feed
'UNKNOWN' If the processor cannot determine the record type
48. 42.20 - SEQUENTIAL
SEQUENTIAL = seq
seq Is a character scalar memory reference that is
assigned one of the following values:
'YES' If sequential access is allowed for the
specified file
'NO' If sequential access is not allowed
'UNKNOWN' If the access mode cannot be determined
48. 42.21 - UNFORMATTED
UNFORMATTED = unf
unf Is a character scalar memory reference that is
assigned one of the following values:
'YES' If unformatted I/O is allowed for the
specified file
'NO' If unformatted I/O is not allowed
'UNKNOWN' If the form cannot be determined
48.43 - INTRINSIC
Specifies that a symbolic name is the name of an intrinsic
subprogram. Statement format:
INTRINSIC v[,v]...
v Is the symbolic name of an intrinsic subprogram.
Subprogram names passed as actual arguments must be identified in
INTRINSIC statements. Names of subprograms used as the objects of
CALL statements or function references do not need to be identified
with INTRINSIC statements; these names are recognized as intrinsic
implicitly.
48.44 - MAP
See STRUCTURE (subheads Unions and Type_declarations).
48.45 - NAMELIST
Defines a list of variables or array names and associates that list
with a unique group-name, which is used in the namelist I/O
statement.
NAMELIST/grp/nlist[[,]/grp/nlist]...
group-name Is a symbolic name.
nlist Is the list of (no more than 250) variable
or array names, separated by commas, to be
associated with the preceding group-name.
You cannot include array elements, character substrings, records,
and record fields in a namelist, but you can use namelist I/O to
assign values to elements of arrays or substrings of character
variables that appear in namelists. Dummy arguments can appear in
a namelist.
The namelist entities can have any data type and can be explicitly
or implicitly typed.
Only the entities specified in the namelist can be read or written
in namelist I/O. It is not necessary for the input records in a
namelist input statement to define every entity in the associated
namelist.
The order of entities in the namelist controls the order in which
the values are written in the namelist output. Input of namelist
values can be in any order.
A variable or an array name can appear in several namelists.
48.46 - OPEN
Opens an existing file or creates a new file. If you do not
explicitly open a file before accessing it, the file is created
(for write operations) or opened with default attributes.
OPEN (par[,par]...)
par Is a keyword specification in one of the
following forms:
keywd
keywd=value
keywd Is a keyword. (See the subtopic headings
listed at the end of this Help topic.)
value Is a keyword value. (Some keywords do not
have keyword values.)
If an OPEN statement is executed for a unit that is already open,
and the file specification is different from that of the current
open file, the previously opened file is closed and the new file is
opened. If the file specification is the same for both files, the
new value of the BLANK= specifier is in effect, but the position of
the file is unaffected.
Keyword specifications can appear in any order. In most cases,
they are optional. Default values apply in their absence. If the
logical unit specifier is the first parameter in the list, the UNIT
keyword is optional.
You can specify character values at run time by substituting a
general character expression for a keyword value in the OPEN
statement. The character value can contain trailing spaces but not
leading or embedded spaces; for example:
CHARACTER*6 FINAL /' '/
.
.
.
IF (exp) FINAL = 'DELETE'
OPEN (UNIT=1, STATUS='NEW', DISP=FINAL)
NOTE: Keyword values that are numeric expressions can be any
integer or real expression. The value of the expression is
converted to integer data type before it is used in the OPEN
statement.
48. 46.1 - ACCESS
ACCESS = acc
acc Is a character expression with one of the following
values:
'DIRECT' Access by record number
'SEQUENTIAL' Access sequentially (*DEFAULT*)
'KEYED' Access by a specified key
'APPEND' Access sequentially, after the last record
of the file
48. 46.2 - ASSOCIATEVARIABLE
ASSOCIATEVARIABLE = asv
asv Is an integer variable. It cannot be a dummy argument
to the routine in which the OPEN statement appears.
Use only in direct access mode.
NOTE: Direct access READ, direct access WRITE, FIND, DELETE, and
REWRITE statements can affect the value of the variable.
48. 46.3 - BLANK
BLANK = blnk
blnk Is a character expression with one of the following
values:
'NULL' Ignore all blanks in a numeric field (unless the field
is all blanks, in which case treat blanks as zero).
'ZERO' Treat all blanks other than leading blanks as zeros.
The default is 'NULL'. However, if you specify the /NOF77 compiler
option (or OPTIONS /NOF77), the file is implicitly opened, or the
file is opened for internal I/O, the default is 'ZERO'.
48. 46.4 - BLOCKSIZE
BLOCKSIZE = bks
bks Is a numeric expression whose value specifies a
number of bytes.
For magnetic tape files, the value of "bks" specifies the physical
record size in the range 18 to 32767 bytes. The default value is
2048 bytes.
For sequential disk files, "bks" is rounded up to an integral
number of 512-byte blocks and used to specify multiblock transfers.
The number of blocks transferred can be 1 to 127, and defaults to
the current count for the device at program run time.
For indexed and relative files, "bks" is rounded up to an integral
number of 512-byte blocks and used to specify the RMS bucket size.
This must fall in the range 1 to 63 blocks, and defaults to the
smallest value capable of holding one record.
48. 46.5 - BUFFERCOUNT
BUFFERCOUNT = bc
bc Is a numeric expression whose value specifies
the number of buffers to be associated with the
logical unit for multibuffered I/O. The range
for "bc" is 1 to 127.
If you do not specify BUFFERCOUNT or you specify 0, the system
default is assumed.
48. 46.6 - CARRIAGECONTROL
CARRIAGECONTROL = cc
cc Is a character expression with one of the following
values:
'FORTRAN' Process with normal FORTRAN interpretation of
the first character
'LIST' Process with single spacing between records
'NONE' Do not use implied carriage control
The default for unformatted files is 'NONE'. The default for
formatted files is 'FORTRAN'.
48. 46.7 - CONVERT
CONVERT = fm
fm Is a character expression with one of the following
options:
'LITTLE_ENDIAN'- Little endian integer data of the
appropriate size (INTEGER*1, INTEGER*2,
or INTEGER*4) and IEEE floating-point
data of the appropriate size and
type (REAL*4, REAL*8, COMPLEX*8, COMPLEX*16).
INTEGER*1 data is the same for little endian
and big endian.
'BIG_ENDIAN' - Big endian integer data of the appropriate
size (INTEGER*1, INTEGER*2, or INTEGER*4)
and IEEE floating-point data of the
appropriate size and type (REAL*4, REAL*8,
COMPLEX*8, COMPLEX*16). INTEGER*1 data is
the same for little endian and big endian.
'CRAY' - Big endian integer data of the appropriate
size (INTEGER*1, INTEGER*2, or INTEGER*4)
and CRAY floating-point data of size REAL*8
or COMPLEX*16.
'IBM' - Big endian integer data of the appropriate
size (INTEGER*1, INTEGER*2, or INTEGER*4)
and IBM System\370 floating-point data of
size REAL*4 or COMPLEX*8 (IBM short 4)
and size REAL*8 or COMPLEX*16 (IBM long 8).
'VAXD' - Little endian integer data of the appropriate
size (INTEGER*1, INTEGER*2, or INTEGER*4)
and Compaq VAX floating-point data of
format F_floating for size REAL*4 or COMPLEX*8,
and D_floating for size REAL*8 or COMPLEX*16.
'VAXG' - Little endian integer data of the appropriate
size (INTEGER*1, INTEGER*2, or INTEGER*4)
and Compaq VAX floating-point data of
format F_floating for size REAL*4 or COMPLEX*8,
and G_floating for size REAL*8 or COMPLEX*16.
'NATIVE' - No data conversion. This is the default.
You can use CONVERT to specify multiple formats in a single
program, usually one format for each specified unit number.
When reading a non-native format, the non-native format on disk is
converted to native format in memory. If a converted non-native
value is outside the range of the native data type, a run-time
message appears.
There are other ways to specify numeric format for unformatted
files: you can specify a VMS logical name or the compiler option
CONVERT (or OPTIONS/CONVERT). The order of precedence is VMS
logical name, OPEN (CONVERT=), OPTIONS/CONVERT, and then compiler
option CONVERT. The CONVERT compiler option and OPTIONS/CONVERT
affect all unit numbers used by the program, while logical names
and OPEN (CONVERT=) affect specific unit numbers.
The following source code shows how to code the OPEN statement to
read unformatted CRAY numeric data from unit 15, which might be
processed and possibly written in little endian format to unit 20:
OPEN (CONVERT='CRAY', FILE='graph3.dat', FORM='UNFORMATTED',
1 UNIT=15)
.
.
.
OPEN (FILE='graph3_native.dat', FORM='UNFORMATTED', UNIT=20)
For more information on transporting data to or from an OpenVMS VAX
system and on supported ranges for data types, see your user
manual.
48. 46.8 - DEFAULTFILE
DEFAULTFILE = ce
ce Is a character expression that specifies a default file
specification string.
This keyword supplies a value to the RMS default file specification
string for the missing components of a file specification. If you
do not specify the DEFAULTFILE keyword, Fortran uses the default
value 'FORnnn.DAT', where nnn is the unit number with leading
zeros.
The default file pathname string is used primarily when accepting
file specifications interactively. File specifications known to a
user program are normally completely specified in the FILE keyword.
You can specify default values for any one of the following file
specification components: node, device, directory, file name, file
type, and file version number.
When you specify any of the above components in the FILE keyword,
they override those values specified in the DEFAULTFILE keyword.
The following example uses the file name supplied by the user and
the default file specification supplied by the DEFAULTFILE keyword
to define the file specification for an existing file:
TYPE *, 'ENTER NAME OF DOCUMENT'
ACCEPT *, DOC
OPEN (UNIT=1, FILE=DOC, DEFAULTFILE='[ARCHIVE].TXT',
1 STATUS='OLD')
48. 46.9 - DISPOSE
DISPOSE = dis
or DISP = dis
dis Is a character expression with one of the following
values:
'KEEP' or 'SAVE' Retain the file after the unit is closed.
(*DEFAULT FOR ALL BUT SCRATCH FILES*)
'DELETE' Delete the file after the unit is closed.
(*DEFAULT FOR SCRATCH FILES*)
'PRINT' Submit the file as a print job and retain it.
Use this value only with sequential files.
'PRINT/DELETE' Submit the file as a print job and then
delete it. Use this value only with sequential
files.
'SUBMIT' Submit the file as a batch job and retain it.
'SUBMIT/DELETE' Submit the file as a batch job and then
delete it.
The disposition specified in a CLOSE statement supersedes the
disposition specified in the OPEN statement, except that a file
opened as a scratch file cannot be saved, printed, or submitted,
nor can a file opened for read-only access be deleted.
48. 46.10 - ERR
ERR = s
s Is the label of an executable statement that is to receive
control when an error occurs.
ERR applies only to the OPEN statement in which it is specified,
and not in following I/O operations on the unit. If an error
occurs, no file is opened or created. However, you can use IOSTAT
in following I/O statements to perform a similar function.
48. 46.11 - EXTENDSIZE
EXTENDSIZE = e
e Is a numeric expression whose value specifies
the number of blocks to extend a disk file when
additional file storage is allocated. The space
used to extend a file is contiguous if possible
otherwise, noncontiguous space is used. Defaults
to the system default for the device.
48. 46.12 - FILE
FILE = fln
fln Is a character scalar reference, numeric scalar memory
reference, or numeric array name reference.
The FILE parameter specifies the name of the file to be connected
to the unit. The name can be any file specification accepted by
the operating system.
If the file name is stored in a numeric scalar or array, the name
must consist of ASCII characters terminated by an ASCII null
character (zero byte). However, if it is stored in a character
scalar or array, it must not contain a zero byte.
48. 46.13 - FORM
FORM = ft
ft Is a character expression with one of the following
values:
'FORMATTED' Formatted *DEFAULT FOR SEQUENTIAL ACCESS*
'UNFORMATTED' Unformatted *DEFAULT FOR DIRECT AND KEYED ACCESS*
48. 46.14 - INITIALSIZE
INITIALSIZE = e
e Is a numeric expression whose value specifies the
number of blocks in the initial allocation of space
for a new file on a disk. Defaults to no initial allocation.
If you do not specify INITIALSIZE or if you specify zero, no
initial allocation is made. The system attempts to allocate
contiguous space for INITIALSIZE. If not enough contiguous space
is available, noncontiguous space is allocated.
INITIALSIZE is effective only at the time the file is created. If
EXTENDSIZE is specified when the file is created, the value
specified is the default value used to allocate additional storage
for the file. If you specify EXTENDSIZE when you open an existing
file, the value you specify supersedes any EXTENDSIZE value
specified when the file was created, and remains in effect until
you close the file. Unless specifically overridden, the default
EXTENDSIZE value is in effect on later openings of the file.
48. 46.15 - IOSTAT
IOSTAT = ios ios Is an integer scalar memory reference. If no error exists, ios is defined as zero; if an error exists, ios is defined as a positive integer. IOSTAT applies only to the OPEN statement in which it appears and not to later I/O operations on the logical unit that it opened. However, you can use the IOSTAT parameter in later I/O statements to perform a similar function. Secondary operating system messages do not display when IOSTAT is specified. To display these messages, remove IOSTAT or use a platform-specific method such as a OpenVMS condition handler. (For more information, see your user manual.)
48. 46.16 - KEY
KEY = (kspec[,kspec]...)
kspec Takes the following form:
e1:e2[:dt[:dr]]
e1 Is the position of the first byte of the
key in the record.
e2 Is the position of the last byte of the
key in the record.
dt Is the data type of the key: CHARACTER (*DEFAULT*)
or INTEGER.
dr Is the direction of the key: ASCENDING (*DEFAULT*)
or DESCENDING.
The length of the key must not exceed 255 bytes. The first byte
position of the key must be at least 1 and the last byte position
must not exceed the length of the record.
If the key type is INTEGER, the key length must be either 2 or 4.
Defining Primary and Alternate Keys:
You must define at least one key in an indexed file. This primary
key is the default key. It usually has a unique value for each
record (no duplicates). Alternate keys can be duplicated.
You can choose to define alternate keys. RMS allows up to 254
alternate keys. However, individual OPEN statements only allow up
to 85 key definitions, a number that is further reduced when
multiple OPEN statements appear together in a program unit.
If a file requires more keys than the OPEN statement limit, you
must create it from another language or with the File Definition
Language (FDL).
Specifying and Referencing Keys:
You must specify the KEY parameter when creating an indexed file.
However, you do not have to respecify it when opening an existing
file because key attributes are permanent aspects of the file.
These attributes include key definitions and reference numbers for
later I/O operations. If you do choose to specify the KEY
parameter for an existing file, your specification must be
identical to the established key attributes.
Following I/O operations use a reference number, called the
key-of-reference number, to identify a particular key. You do not
specify this number; it is determined by the key's position in the
specification list: the primary key is key-of-reference number 0;
the first alternate key is key-of-reference number 1, and so forth.
48. 46.17 - MAXREC
MAXREC = mr
mr Is an numeric expression whose value specifies the
maximum number of records permitted in a direct access
file. The default is the maximum allowed (2**32-1).
48. 46.18 - NAME
NAME is a nonstandard synonym for FILE. (See FILE.)
48. 46.19 - NOSPANBLOCKS
NOSPANBLOCKS Specifies that records are not to cross disk block boundaries. If a record exceeds the size of a physical block, an error occurs.
48. 46.20 - ORGANIZATION
ORGANIZATION = org
org Is a character expression with one of the following
values:
'SEQUENTIAL' Records are stored in the order that
they are written. Access mode must be
sequential, append, or direct (fixed-length
records only). (*DEFAULT FOR NEW FILES*)
'RELATIVE' Records are stored in numbered positions.
Access mode must be direct or sequential.
'INDEXED' Records are stored according to the values
of their keys. Access mode must be indexed
or sequential.
The default for an existing file is its current organization.
48. 46.21 - READONLY
READONLY Prohibits write access to the file. Enables users with read access but not write access to access the file. The Fortran I/O system's default file access privileges are read-write, which can cause run-time I/O errors if the file protection does not permit write access. The READONLY keyword has no effect on the protection specified for a file. Its main purpose is to allow a file to be read simultaneously by two or more programs. For example, if you wish to open a file to read the file but want to allow others to read the same file while you have it open, specify the READONLY keyword.
48. 46.22 - RECL
RECL = rl
rl Is an numeric expression whose value indicates the length
of logical records in a file.
The value of "rl" does not include space for control information,
such as for two segment control bytes (if present) or the bytes
that RMS requires for maintaining record length and deleted record
control information. The specification is for record data only.
The value of "r1" is expressed in units of bytes or longwords,
depending on the record's format. Formatted records use byte units
and unformatted records use longword units (which are equal to 4
bytes).
The following are the maximum values that can be specified for "r1"
for disk files that use the fixed-length record format:
Sequential formatted 32767 bytes
Sequential unformatted 8191 longwords
Relative formatted 32255 bytes
Relative unformatted 8063 longwords
Indexed formatted 32224 bytes
Indexed unformatted 8056 longwords
Tape formatted 9999 bytes
Tape unformatted 2499 longwords
For other record formats and device types, the record size limit
can be less, as described in the "OpenVMS Record Management
Services Reference Manual".
RECL is mandatory when opening new files (STATUS='NEW', 'UNKNOWN,
or 'SCRATCH') and when one or more of the following conditions
exists:
o The record format is fixed length (RECORDTYPE='FIXED').
o The file organization is relative or indexed
(ORGANIZATION='RELATIVE' or 'INDEXED').
o The file is opened for direct access (ACCESS='DIRECT').
RECL is optional in all other cases. Default values for optional
cases depend on the value of the RECORDTYPE parameter.
The following are the RECL default values:
RECORDTYPE value RECL value
---------------- -----------------------------------------
'FIXED' None; value must be explicitly specified.
All other types 133 bytes (for formatted records)
511 longwords (for unformatted records)
The interpretation and effect of the logical record length varies
as follows:
o If the file contains segmented records, RECL specifies the
maximum length for any segment (including the two
segment-control bytes).
o If the file contains fixed-length records, RECL specifies the
size of each record.
o If the file contains variable-length records, RECL specifies
the maximum length for any record.
o If your program attempts to write to an existing file a record
that is longer than the logical record length, an error occurs.
o If you are opening an existing file that contains fixed-length
records or has relative organization and you specify a value
for RECL that is different from the actual length of the
records in the file, an error occurs.
48. 46.23 - RECORDSIZE
RECORDSIZE = e RECORDSIZE is the nonstandard synonym for RECL.
48. 46.24 - RECORDTYPE
RECORDTYPE = typ
typ Is a character expression with one of the following
values:
'FIXED' All records are one size. Short records are padded
with blanks (formatted files) or zeros (unformatted
files).
'VARIABLE' Records can vary in length.
'SEGMENTED' A record consists of one or more variable length
records, which can exist in different physical blocks.
Valid only for unformatted, sequential files with
sequential access.
'STREAM' Data is not grouped into records and contains no
control information.
'STREAM_CR' Variable-length records whose length is indicated by
carriage-returns embedded in the data.
'STREAM_LF' Variable-length records whose length is indicated by
line-feeds (new lines) embedded in the data.
When you open a file, default record types are as follows:
+-------------------------------------+---------------------+
| File Type | Default Record Type |
+-------------------------------------+---------------------+
| Relative or indexed files | 'FIXED' |
| Direct access sequential files | 'FIXED' |
| Formatted sequential access files | 'VARIABLE' |
| Unformatted sequential access files | 'SEGMENTED' |
+-------------------------------------+---------------------+
A segmented record consists of one or more variable-length records.
Using segmented records allows a Fortran logical record to span
several physical records. Only unformatted sequential access files
with sequential organization can use segmented records. You cannot
specify <SINGLE_QUOTE>SEGMENTED<SINGLE_QUOTE> for any other file
type.
If you do not specify the RECORDTYPE parameter when you are
accessing an existing file, the record type of the file is used ---
except for unformatted sequential-access files with sequential
organization and variable-length records. These files have a
default of 'SEGMENTED'.
If you do specify the RECORDTYPE parameter when you are accessing
an existing file, the type that you specify must match the type of
an existing file.
In fixed-length record files, if an output statement does not
specify a full record, the record is filled with spaces in a
formatted file and zeros in an unformatted file.
You cannot use an unformatted READ statement to access an
unformatted sequential organization file containing variable-length
records, unless you specify the corresponding RECORDTYPE value in
your OPEN statement.
Files containing segmented records can be accessed only by
unformatted sequential Fortran I/O statements.
48. 46.25 - SHARED
SHARED Specifies that the file can be accessed by more than one user at the same time.
48. 46.26 - STATUS
STATUS = sta
sta Is a character expression with one of the following
values:
'OLD' Open an existing file
'NEW' Create a new file; if the file already exists an
error occurs
'SCRATCH' Create a new file and delete it when the file is
closed
'UNKNOWN' Open the file as OLD; if it does not exist, then
open the file as NEW
The default is 'UNKNOWN'. However, if you implicitly open a file
using WRITE, or you specify the /NOF77 compiler option, or OPTIONS
/NOF77, the default value is 'NEW'. If you implicitly open a file
using READ, the default value is 'OLD'.
Scratch files (STATUS='SCRATCH') are created on the user's default
disk (SYS$DISK) and are not placed in a directory or given a name
that is externally visible. To specify a different device, use the
FILE keyword.
48. 46.27 - TYPE
TYPE is a nonstandard synonym for STATUS (see STATUS).
48. 46.28 - UNIT
[UNIT=] u
u Is a numeric expression that specifies the logical unit to
which a file is to be connected.
The unit specification must appear in the parameter list, unless
the unit specifier is the first element in the list.
The logical unit may already be connected to a file when an OPEN
statement is executed. If this file is not the same as the one to
be opened, the OPEN statement executes as if a CLOSE statement had
executed just before it.
If the file to be opened is already connected to the unit or if the
file specifier (FILE keyword) is not included in the OPEN
statement, only the blank specifier (BLANK keyword) can have a
value different from the one currently in effect. The position of
the file is unaffected.
48. 46.29 - USEROPEN
USEROPEN = p
p Is the symbolic name of the USEROPEN procedure.
The USEROPEN parameter specifies a user-written
EXTERNAL function that controls the opening of
the file.
The name must be declared EXTERNAL in the program unit with the
OPEN statement, and if typed, it must be INTEGER*4.
48.47 - OPTIONS
Overrides qualifiers specified by the FORTRAN command (for a single
program unit). Statement format:
OPTIONS option [option...]
option Is one of the following:
/ASSUME=(ALL, [NO]ACCURACY_SENSITIVE, [NO]DUMMY_ALIASES,
NONE)
/NOASSUME
/BLAS=(ALL, [NO]INLINE, [NO]MAPPED, NONE)
/NOBLAS
/CHECK=(ALL, [NO]ALIGNMENT, [NO]ASSERTIONS, [NO]BOUNDS,
[NO]OVERFLOW, [NO]UNDERFLOW, NONE)
/NOCHECK
/CONVERT=(BIG_ENDIAN, CRAY, IBM, LITTLE_ENDIAN, NATIVE,
VAXD, VAXG)
/[NO]EXTEND_SOURCE
/[NO]F77
/[NO]G_FLOATING
/[NO]I4
/[NO]RECURSIVE
You must place a slash (/) before the option.
The OPTIONS statement must be the first statement in a program
unit, preceding the PROGRAM, SUBROUTINE, FUNCTION, and BLOCK DATA
statements.
OPTIONS statement options have the same syntax and abbreviations as
their similarly-named OpenVMS compiler options.
OPTIONS statement options override compiler options, but only until
the end of the program unit in which they are defined. Thus, an
OPTIONS statement must appear in each program unit in which you
wish to override the compiler options.
48.48 - PARAMETER
Associates a symbolic name with a constant value. Statement
format:
1. PARAMETER (p=c [,p=c]...)
p Is a symbolic name.
c Is a constant, a compile-time expression, or the
symbolic name of a constant.
The following additional rules apply to symbolic names:
- If the symbolic name is used as the length specifier in a
CHARACTER declaration, it must be enclosed in parentheses.
- If the symbolic name is used as a numeric item in a FORMAT edit
description, it must be enclosed in angle brackets.
- The symbolic name of a constant cannot appear as part of
another constant, although it can appear as either the real or
imaginary part of a complex constant.
- A symbolic name can be defined only once within the same
program unit.
- You can only use a symbolic name defined to be a constant
within the program unit containing the defining PARAMETER
statement.
The data type of a symbolic name associated with a constant is
determined as follows:
- By an explicit type declaration statement preceding the
defining PARAMETER statement
- By the same rules for implicit declarations that determine the
data type of any other symbolic name
For example, the following PARAMETER statement is interpreted
as MU=1 (MU has an integer data type by implication):
PARAMETER (MU=1.23)
If the PARAMETER statement is preceded by an appropriate type
declaration or IMPLICIT statement, it could be interpreted as
MU=1.23; for example:
REAL*8 MU
PARAMETER (MU=1.23)
Once a symbolic name is associated with a constant, it can appear
anywhere in a program that any other constant can appear --- except
in FORMAT statements (where constants can only be used in variable
format expressions) and as the character count for Hollerith
constants. For compilation purposes, writing the name is the same
as writing the value.
A compile-time expression can contain the following intrinsic
subprograms as long as the operands are constants: ABS, CHAR,
CMPLX, CONJG, DIM, DPROD, IAND, ICHAR, IEOR, IMAG, IOR, ISHFT, LGE,
LGT, LLE, LLT, MIN, MAX, MOD, NINT, and NOT.
2. PARAMETER p=c [,p=c]...
p Is a symbolic name.
c Is a constant, the symbolic name of a constant, or a
compile-time constant expression.
This statement is similar to the one described above; they both
assign a symbolic name to a constant. However, this PARAMETER
statement differs from the other one in the following two ways:
its list is not bounded with parentheses; and the form of the
constant, rather than implicit or explicit typing of the symbolic
name, determines the data type of the variable.
48.49 - PAUSE
The PAUSE statement displays a message on the terminal and
temporarily suspends program execution, so that you can take some
action. Statement format:
PAUSE [disp]
disp Is an optional character constant or a string of
up to six digits. (FORTRAN-77 limits digits to five.)
If you do not specify a value for "disp", the system displays the
following default message:
FORTRAN PAUSE
The system then displays the system prompt.
If you specify a value for "disp", this value is displayed instead
of the default message.
EFFECT OF PAUSE IN INTERACTIVE MODE:
In interactive mode, the program is suspended until you enter one
of the following commands:
o CONTINUE - to resume execution at the next executable
statement.
o DEBUG - to resume execution under control of the OpenVMS
Debugger.
o EXIT - to terminate execution.
Note that any command, other than CONTINUE or DEBUG, terminates
execution.
EFFECT OF PAUSE IN BATCH PROCESS MODE:
If a program is a batch process, the program is not suspended. If
you specify a value for "disp", this value is written to the system
output file.
48.50 - PRINT
Transfers data from internal storage to FOR$PRINT (normally, the terminal in interactive mode or the batch log in batch mode). The access mode is sequential.
48. 50.1 - Formatted
Translates data from binary to character format as specified by f.
Statement format:
PRINT f[,iolist]
f Is a format specifier not prefaced by FMT=.
iolist Are the names of the variables from which the
data is transferred, listed in the order of transfer.
48. 50.2 - List-directed
Translates data from binary to character format according to the
data types of the variables in the I/O list. Statement format:
PRINT *[,iolist]
* Specifies list-directed formatting.
iolist Are the names of the variables from which the data
is transferred, listed in the order of transfer.
48. 50.3 - Namelist
Translates data from binary to character format according to the
data types of the list entities in the corresponding NAMELIST
statement. Statement format:
PRINT n
n Is a namelist group name not prefaced by NML=.
48.51 - POINTER
The POINTER statement establishes pairs of variables and pointers,
in which each pointer contains the address of its paired variable.
Statement format:
POINTER ((pointer,pointee) [,(pointer,pointee)]...
pointer Is a variable whose value is used as the
address of the pointee.
pointee Is a variable, array, array declarator, record,
record array, or record array declarator.
The following are rules and behavior for the "pointer" argument:
o Two pointers can have the same value, so pointer aliasing is
allowed.
o When used directly, a pointer is treated like an integer
variable. On VAX systems, a pointer occupies one numeric
storage unit, so it is a 32-bit quantity (INTEGER*4).
o A pointer cannot be pointed to by another pointer; therefore, a
pointer cannot also be a pointee.
o A pointer cannot appear in the following statements:
ASSIGN INTRINSIC
EXTERNAL PARAMETER
A pointer can appear in a DATA statement with integer literals
only.
o Integers can be converted to pointers, so you can point to
absolute memory locations.
o A pointer variable cannot be declared to have any other data
type.
o A pointer cannot be a function return value.
o You can give values to pointers by using the %LOC built-in
function to retrieve addresses. For example:
integer i(10)
integer i1 (10) /10*10/
pointer (p,i)
p = %loc (i1)
i(2) = i(2) + 1
o The value in a pointer is used as the pointee's base address.
The following are rules and behavior for the "pointee" argument:
o A pointee is not allocated any storage. References to a
pointee look to the current contents of its associated pointer
to find the pointee's base address.
o A pointee array can have fixed, adjustable, or assumed
dimensions.
o A pointee cannot appear in the following statements:
AUTOMATIC PARAMETER
COMMON SAVE
DATA STATIC
EQUIVALENCE VOLATILE
NAMELIST
o A pointee cannot be a dummy argument.
o A pointee cannot be a function return value.
o A pointee cannot be a record field or an array element.
48.52 - PROGRAM
Begins a main program. The PROGRAM statement is optional; when
used, it can only be preceded by comment lines or an OPTIONS
statement. Statement format:
PROGRAM nam
nam Is a symbolic name for the program. The name must
be unique among all global names in the program.
If no PROGRAM statement begins the program, the program name
defaults to filename$MAIN, where filename is the name of the file
containing the program.
48.53 - READ
Transfers data from external or internal units to internal storage.
The meanings of the symbolic abbreviations used to represent the
parameters in the READ statement syntax are as follows:
extu Is the logical unit or internal file optionally
or prefaced by UNIT=. UNIT= is required if unit is
intu not the first element in the clist.
fmt Specifies whether formatting is to be used for
data editing, and if it is, the format specification
or an asterisk (*) to indicate list-directed formatting.
The "fmt" is optionally prefaced by FMT=, if "fmt" is
the second parameter in the clist and the first parameter
is a logical or internal unit specifier without the
optional keyword UNIT=.
nml Is the namelist group specification for namelist I/O.
Optionally prefaced by NML=. NML= is required
if namelist is not the second I/O specifier.
rec Is the cell number of a record to be accessed directly.
Optionally prefaced by REC= or by an apostrophe (').
iostat Is the name of a variable to contain the completion
status of the I/O operation. Optionally prefaced
by IOSTAT=.
err Is the label of a statement to which control is
transferred in the event of an error. Optionally
prefaced by ERR=.
end Is the label of a statement to which control is
transferred in the event of an end-of-file.
Optionally prefaced by END=.
iolist Are the names of the variables, arrays, array
elements, or character substrings from which or
to which data will be transferred. Optionally
an implied-DO list.
keyspec Specifies the key of field value of a record to
be accessed. Optionally prefaced by KEY=, KEYEQ=,
KEYGE=, KEYGT=, KEYNXT, KEYNXTNE, KEYLT, or KEYLE.
keyid Specifies the key field index that is to be searched
for the specified key field value. Optionally in-
cluded with keyspec and optionally prefaced by KEYID=.
The control-list parameters are "extu" (or "intu"), "fmt", "nml",
"rec", "iostat", "err", "end", "keyspec", and "keyid". The I/O
list parameter is "iolist".
48. 53.1 - Sequential
48. 53. 1.1 - Formatted
Translates the data from character to binary format as specified by
format specifications. Statement formats:
1. READ(extu,fmt[,iostat][,err][,end])[iolist]
Reads from a specified external unit.
2. READ f[,iolist]
Reads from FOR$READ (normally, the terminal).
48. 53. 1.2 - List-directed
List-directed sequential READ statement formats:
1. READ(extu,*[,iostat][,err][,end])[iolist]
Reads from a specified external unit.
Translates the data from character to binary
format according to the data types of the
variables in the I/O list.
2. READ *[,iolist]
Reads from FOR$READ (normally, the terminal).
Translates the data from character to binary
format according to the data types of the
variables in the I/O list.
48. 53. 1.3 - Namelist
Namelist sequential READ statement formats:
1. READ(extu,nml[,iostat][,err][,end])
Reads from a specified external unit. Translates
the data from character to binary format according
to the data types of the list entities in the
corresponding NAMELIST statement.
2. READ nl
Reads from FOR$READ (normally, the terminal).
Translates the data from character to binary format
according to the data types of the entities in the
corresponding NAMELIST statement.
48. 53. 1.4 - Unformatted
Unformatted sequential READ statement format:
READ(extu,[,iostat][,err][,end])[iolist]
Reads from a specified external unit. Does not translate the data.
48. 53.2 - Direct
48. 53. 2.1 - Formatted
Formatted direct READ statement format:
READ(extu,fmt,rec[,err][,iostat])[iolist]
READ(u'r,fmt[,err][,iostat]) [iolist]
Reads from a specified external unit. Translates the data from
character to binary format as specified by "fmt".
48. 53. 2.2 - Unformatted
Unformatted direct READ statement format:
READ(extu,rec[,err][,iostat])[iolist]
READ(u'r[,err][,iostat])[iolist]
Reads from a specified external unit. Does not translate the data.
48. 53.3 - Indexed
48. 53. 3.1 - Formatted
Formatted Indexed READ statement format:
READ(extu,fmt,keyspec[,keyid][,err][,iostat])[iolist]
Reads from a specified external unit. Translates the data from
character to binary format as specified by "fmt".
48. 53. 3.2 - Unformatted
Unformatted Indexed READ statement format:
READ(extu,keyspec[,keyid][,err][,iostat])[iolist]
Reads from a specified external unit. Does not translate the data.
48. 53.4 - Internal
Internal READ statement format:
READ(intu,fmt[,err][,iostat][,end])[iolist]
Reads from a specified character variable. Translates the data
from character to binary format as specified by "fmt".
48.54 - RECORD
Creates a record consisting of the variables and arrays specified
in a previous structure declaration. Statement format:
RECORD /str/rnlist[,/str/rnlist...]
str Is the name of a previously declared structure.
rnlist Is a list of one or more variable names, array
names, or array declarators, separated by commas.
All the records named in this list have the
same structure and are allocated separately in
memory.
Record variables can be used in COMMON and DIMENSION statements,
but not in DATA or EQUIVALENCE statements.
48.55 - RETURN
Transfers control from a subprogram to the calling program. You
can only use RETURN in a subprogram unit. Statement format:
RETURN [i]
i Is an optional integer constant or expression (such
as 2 or I+J) indicating the position of an alternate
return from the subprogram in the actual argument list.
The "i" is converted to an integer value if necessary.
The argument "i" is valid only for subroutine subprograms. If no
alternate return is specified or the specified alternate return
does not exist in the actual argument list, control returns to the
statement following the CALL statement.
If the subprogram is a function, control returns to the statement
containing the function reference. If the subprogram is a
subroutine, control returns either to the statement following the
CALL statement, or to the label specified by the alternate return
argument.
48.56 - REWIND
Repositions a sequential file currently open for sequential or
append access to the beginning of the file. Do not use a REWIND
statement for a file that is open for indexed or direct access.
Allowed only for files on disk or magnetic tape. Statement format:
REWIND ([UNIT=]u[,ERR=s][,IOSTAT=ios])
REWIND u
u Is an integer variable or constant specifying the
logical unit number of the file, optionally prefaced
by UNIT=. UNIT= is required if unit is not the first
I/O specifier.
s Is the label of a statement to which control is
transferred if an error occurs, prefaced by ERR=.
ios Is an integer variable to which the completion status
of the I/O operation is returned, prefaced by IOSTAT=.
See also BACKSPACE.
48.57 - REWRITE
Transfers data from internal storage and writes the data
(translated if formatted; untranslated if unformatted) to the
current record in the following types of files: an indexed,
sequential (only if the current record and new record are the same
length), or relative file.
The current record is the last record accessed by a preceding,
successful direct access, indexed, or sequential READ statement.
Formatted REWRITE statement format:
REWRITE ([UNIT=]u,[FMT=]f[,ERR=s][,IOSTAT=ios])[iolist]
Translates the data from binary to character format as
specified by FMT.
Unformatted REWRITE statement format:
REWRITE ([UNIT=]u[,ERR=s][,IOSTAT=ios])[iolist]
Does not translate the binary data.
Arguments:
u Is an integer variable or constant specifying the
logical unit number of the file, optionally
prefaced by UNIT=. UNIT= is required if unit is
not the first I/O specifier.
f Is a format specifier.
s Is the label of a statement to which control is
transferred if an error condition occurs, prefaced
by ERR=.
ios Is an integer variable to which the completion
status of the I/O operation is returned, prefaced
by IOSTAT=.
iolist Are the names of the variables from which the data
is transferred, listed in the order of transfer.
--------------------------------------------------------------
Formatted REWRITE Statement Behavior and Errors:
The formatted REWRITE statement performs the following operations:
o It retrieves binary values from internal storage.
o It translates those values to character form as specified by
FORMAT.
o It writes the translated data to a current (existing) record in
a file OPENed with ORGANIZATION='INDEXED', 'RELATIVE', or
'SEQUENTIAL' (For SEQUENTIAL organization, the new record must
be the same length as the existing record.)
The current record is the last record accessed by a preceding,
successful indexed, direct access, or sequential READ
statement.
Errors occur under the following conditions:
o If you attempt to rewrite more than one record in a single
REWRITE statement operation
o If a record is too long (Note that unused space in a rewritten,
fixed-length record is filled with spaces.)
o If the primary key value is changed
In the following example, the REWRITE statement updates the current
record contained in the relative organization file connected to
logical unit 3 with the values represented by NAME, AGE, and BIRTH.
REWRITE (3,10,ERR=99) NAME, AGE, BIRTH
10 FORMAT (A16,I2,A8)
-------------------------------------------------------
Unformatted REWRITE Statement Behavior and Errors:
The formatted REWRITE statement performs the following operations:
o It retrieves binary values from internal storage.
o It writes the untranslated data to a current (existing)
existing record in a file OPENed with ORGANIZATION='INDEXED',
'RELATIVE', or 'SEQUENTIAL' (For SEQUENTIAL organization, the
new record must be the same length as the existing record.)
The current record is the last record accessed by a preceding,
successful indexed, direct access, or sequential READ
statement.
Errors occur under the following conditions:
o If you attempt to rewrite more than one record in a single
REWRITE statement operation
o If a record is too long (Note that unused space in a rewritten,
fixed-length record is filled with zeros.)
o If the primary key value is changed
48.58 - SAVE
Declares that the values of data elements are to be saved across
invocations of a subprogram. Statement format:
SAVE [a[,a]...]
a Is the symbolic name of a common block (enclosed in
slashes), a variable, or an array.
A SAVE statement cannot include a blank common block, names of
entities in a common block, procedure names, and names of dummy
arguments.
Within a program unit, an entity listed in a SAVE statement does
not become undefined upon execution of a RETURN or END statement
within that program unit.
Even though a common block can be included in a SAVE statement,
individual entities within the common block could become undefined
(or redefined) in another program unit.
When a SAVE statement does not explicitly contain a list, it is
treated as though all allowable items in the program unit are
specified on the list.
NOTE: It is not necessary to use SAVE statements in Compaq Fortran
programs. The definitions of data entities are retained
automatically by default, unless you specify the /RECURSIVE
compiler option. (Optimizations can also affect this. See your
user manual for more information.) However, the ANSI FORTRAN
Standard requires using SAVE statements for programs that depend on
such retention for their correct operation. If you want your
programs to be portable, you should include SAVE statements where
your programs require them.
The omission of such SAVE statements in necessary instances is not
flagged, even when you specify the /STANDARD=(SEMANTIC,SYNTAX)
compiler option, because the compiler does not determine whether
such dependences exist.
48.59 - Statement Function
Defines a function consisting of a single expression. The function
must be invoked from the program unit in which it is defined.
Format:
fun([p [,p]...])=e
fun Is the symbolic name for the function. You can
establish its type explicitly or implicitly. The
value of the expression is returned to the function
name when the function is invoked.
p Is an unsubscripted variable name specifying a
dummy argument. The arguments must agree in order,
number, and type with the actual arguments of the
statement invoking the function.
e Is an arithmetic, logical, or character expression.
If the expression contains a reference to another
statement function, the referenced statement
function must precede the statement function
containing the reference.
If you use the name of a dummy argument outside the function
statement, the name defines another separate data entity.
Declarator information does not apply to a dummy argument except
for type. For example, you cannot define a dummy argument as an
array or as part of a common block.
If you use the name of a dummy argument outside the function
statement, the name defines another separate data entity.
48.60 - STOP
Terminates program execution and writes a message to SYS$OUTPUT.
Statement format:
STOP [disp]
disp Is a character constant or a string of up to
six digits. (FORTRAN-77 limits digits to five.)
If you specify the optional argument "disp", the STOP statement
displays the contents of "disp" at your terminal, terminates
program execution, and returns control to the operating system.
If you do not specify a value for "disp", the character constant
FORTRAN STOP is displayed.
48.61 - STRUCTURE
Indicates the beginning of the record structure declaration and
defines the name of the structure. Declaration format:
STRUCTURE [/str/][fnlist]
fdcl
[fdcl]
...
[fdcl]
END STRUCTURE
str Identifies a structure name, which is used in
following RECORD statements to refer to the
structure. A structure name is enclosed in slashes.
fnlist Identifies field names when used in a substructure
declaration.(Only allowed in nested structure
declarations.)
fdcl (Also called the declaration body.) Is any
declaration or combination of declarations of
substructures, unions, or typed data, or
PARAMETER statements.
Following RECORD statements use the structure name to refer to the
structure. A structure name must be unique among structure names,
but structures can share names with variables (scalar or array),
record fields, PARAMETER constants, and common blocks.
Structure declarations can be nested (contain one or more other
structure declarations). A structure name is required for the
structured declaration at the outermost level of nesting, and
optional for the other declarations nested in it. However, if you
wish to reference a nested structure in a RECORD statement in your
program, it must have a name.
Structure, field, and record names are all local to the defining
program unit. When records are passed as arguments, the fields
must match in type, order, and dimension.
Unlike type declaration statements, structure declarations do not
create variables. Structured variables (records) are created when
you use a RECORD statement containing the name of a previously
declared structure. The RECORD statement can be considered as a
kind of type statement. The difference is that aggregate items,
not single items, are being defined.
Within a structure declaration, the ordering of both the statements
and the field names within the statements is important because this
ordering determines the order of the fields in records.
In a structure declaration, each field offset is the sum of the
lengths of the previous fields. The length of the structure,
therefore, is the sum of the lengths of its fields. The structure
is packed; you must explicitly provide any alignment that is needed
by including, for example, unnamed fields of the appropriate
length.
In the following example, the declaration defines a structure named
DATE. This structure contains three scalar fields: DAY
(LOGICAL*1), MONTH (LOGICAL*1), and YEAR (INTEGER*2).
STRUCTURE /DATE/
LOGICAL*1 DAY, MONTH
INTEGER*2 YEAR
END STRUCTURE
48. 61.1 - Type declarations
The syntax of a type declaration within a record structure is
identical to that of a normal Fortran type declaration statement:
it includes a data type (for example, INTEGER), one or more names
of variables or arrays; and optionally, one or more data
initialization values.
The following rules and behavior apply to type declarations in
record structures:
o %FILL can be specified in place of a field name to leave space
in a record for purposes such as alignment. This creates an
unnamed field.
%FILL can have an array declarator; for example:
INTEGER %FILL (2,2)
Unnamed fields cannot be initialized. For example, the
following statement is invalid and generates an error message:
INTEGER*4 %FILL /1980/
o Initial values can be supplied in field declaration statements.
These initial values are supplied for all records that are
declared using this structure. Fields not initialized will
have undefined values when variables are declared by means of
RECORD statements. Unnamed fields cannot be initialized; they
are always undefined.
o Field names must always be given explicit data types. The
IMPLICIT statement has no effect on statements within a
structure declaration.
o All Fortran data types are allowed in field declarations.
o Any required array dimensions must be specified in the field
declaration statements. DIMENSION statements cannot be used to
define field names.
o Adjustable or assumed sized arrays and passed-length CHARACTER
declarations are not allowed in field declarations.
o Field names within the same declaration level must be unique,
but an inner structure declaration (substructure declaration)
can include field names used in an outer structure declaration
without conflict.
48. 61.2 - Substructure declarations
A field within a structure can itself be a structured item composed
of other fields, other structures, or both. You can declare a
substructure in two ways:
o By nesting structure declarations within other structure or
union declarations (with the limitation that you cannot refer
to a structure inside itself at any level of nesting).
One or more field names must be defined in the STRUCTURE
statement for the substructure because all fields in a
structure must be named. In this case, the substructure is
being used as a field within a structure or union.
Field names within the same declaration nesting level must be
unique, but an inner structure declaration can include field
names used in an outer structure declaration without conflict.
%FILL can be specified in place of a field name to leave space
in a record for purposes such as alignment.
o By using a RECORD statement that specifies another previously
defined record structure, thereby including it in the structure
being declared.
48. 61.3 - Union declarations
A union declaration is a multistatement declaration defining a data
area that can be shared intermittently during program execution by
one or more fields or groups of fields. A union declaration must
be within a structure declaration. A union declaration is
initiated by a UNION statement and terminated by an END UNION
statement. Enclosed within these statements are two or more map
declarations, initiated and terminated by MAP and END MAP
statements. Each unique field or group of fields is defined by a
separate map declaration.
A union declaration takes the following form:
UNION
mdcl
[mdcl]
...
[mdcl]
END UNION
Where "mdcl" represents:
MAP
fdcl
[fdcl]
...
[fdcl]
END MAP
fdcl Is any declaration or combination of declarations
of substructures, unions, or type declarations.
As with normal Fortran type declarations, data can be initialized
in field declaration statements in union declarations. However, if
fields within multiple map declarations in a single union are
initialized, the data declarations are initialized in the order in
which the statements appear. As a result, only the final
initialization takes effect and all the preceding initializations
are overwritten.
The size of the shared area established for a union declaration is
the size of the largest map defined for that union. The size of a
map is the sum of the sizes of the fields declared within it.
As the variables or arrays declared in map fields in a union
declaration are assigned values during program execution, the
values are established in a record in the field shared with other
map fields in the union. The fields of only one of the map
declarations are defined within a union at any given point in the
execution of a program. However, if you overlay one variable with
another smaller variable, that portion of the initial variable is
retained that is not overlaid. Depending on the application, the
retained portion of an overlaid variable may or may not contain
meaningful data and can be used at a later point in the program.
Manipulating data using union declarations is similar to the effect
of using EQUIVALENCE statements. The difference is that data
entities specified within EQUIVALENCE statements are concurrently
associated with a common storage location and the data residing
there; with union declarations you can use one discrete storage
location to alternately contain a variety of fields (arrays or
variables).
With union declarations, only one map declaration within a union
declaration can be associated at any point in time with the storage
location that they share. Whenever a field within another map
declaration in the same union declaration is referenced in your
program, the fields in the prior map declaration become undefined
and are succeeded by the fields in the map declaration containing
the newly referenced field.
In the following example, the structure WORDS_LONG is defined.
This structure contains a union declaration defining two map
fields. The first map field consists of three INTEGER*2 variables
(WORD_0, WORD_1, and WORD_2), and the second, an INTEGER*4
variable, LONG:
STRUCTURE /WORDS_LONG/
UNION
MAP
INTEGER*2 WORD_0, WORD_1, WORD_2
END MAP
MAP
INTEGER*4 LONG
END MAP
END UNION
END STRUCTURE
48. 61.4 - PARAMETER Statements
PARAMETER statements: PARAMETER statements can appear in a
structure declaration, but cannot be given a data type within the
declaration block. Consider the following:
STRUCTURE /ABC/
INTEGER*4 P
PARAMETER (P=4)
REAL*4 F
END STRUCTURE
REAL*4 A(P)
In this example, the INTEGER*4 statement does not provide the data
type for PARAMETER constant P, but instead declares a record field
P in structure ABC. The following PARAMETER statement declares a
new, different symbol that is given the implicit data type for
identifiers beginning with the letter P.
Type declarations for PARAMETER symbolic names must precede the
PARAMETER statement and be outside of a STRUCTURE declaration, as
follows:
INTEGER*4 P
STRUCTURE /ABC/
PARAMETER (P=4)
REAL*4 F
END STRUCTURE
REAL*4 A(P)
For more information on PARAMETER statements, see STATEMENTS
PARAMETER in this Help file.
48.62 - SUBROUTINE
Begins a subroutine subprogram and names the dummy arguments. The
CALL statement transfers control to a subroutine subprogram; a
RETURN or END statement returns control to the calling program
unit. Statement format:
SUBROUTINE nam[([p[,p]...])]
nam Is a symbolic name for the subroutine. The name must
be unique among all global names in the program.
p Is an unsubscripted variable name specifying a dummy argument.
An asterisk (*) as a dummy argument specifies that the
actual argument is an alternate return argument.
The arguments must agree in order, number, and type with the actual
arguments of the statement invoking the subroutine. A dummy
argument must not be defined as an array with more elements than
the actual argument holds. When control transfers to the
subroutine, the values of any actual arguments in the CALL
statement are associated with any corresponding dummy arguments in
the SUBROUTINE statement. The statements in the subprogram are
then executed.
The SUBROUTINE statement must be the first statement of a
subroutine, unless an OPTIONS statement is specified.
A subroutine subprogram cannot contain a FUNCTION statement, a
BLOCK DATA statement, a PROGRAM statement, or another SUBROUTINE
statement.
ENTRY statements are allowed to specify multiple entry points in
the subroutine.
The array declarator for a dummy argument can itself contain
integer values that are dummy arguments or are references to a
common block, providing for adjustable size arrays in subroutines.
The upper bound of the array declarator for a dummy argument can be
specified as an asterisk, in which case the upper bound of the
dummy argument assumes the size of the upper bound of the actual
argument. The size in a character string declarator for a dummy
argument can be specified as an asterisk in parentheses, in which
case the size of the actual argument is passed to the dummy
argument.
The values of the actual arguments in the invoking program unit
become the values of the dummy arguments in the function. If you
modify a dummy argument, the corresponding actual argument in the
invoking program unit is also modified; the actual argument must be
a variable if it is to be modified.
If the actual argument is a character constant, the dummy argument
can be either character or numeric in type, unless the name of the
subprogram being invoked is a dummy argument in the invoking
program unit. If the actual argument is a Hollerith constant, the
dummy argument must be numeric.
48.63 - TYPE
Transfers data from internal storage to FOR$TYPE (normally the terminal). The access mode is sequential.
48. 63.1 - Formatted
Translates data from binary to character format as specified by the
format specifications. Statement format:
TYPE f[,iolist]
f Is a format specifier not prefaced by FMT=.
iolist Are the names of the variables from which the
data is transferred, listed in the order of transfer.
48. 63.2 - List-directed
Translates data from binary to character format according to the
data types of the variables in the I/O list. Statement format:
TYPE *[,iolist]
* Specifies list-directed formatting.
iolist Are the names of the variables from which the data
is transferred, listed in the order of transfer.
48. 63.3 - Namelist
Translates data from binary to character format according to the
data types of the list entities in the corresponding NAMELIST
statement. Statement format:
TYPE n
n Is a namelist group name not prefaced by NML=.
48.64 - Type declaration
A type declaration can be specified only once and must precede all executable statements. A type declaration cannot change the type of a symbolic name that has already been implicitly assumed to be another type. Type declarations must precede all executable statements, can be declared only once, and cannot be used to change the type of a symbolic name that has already been implicitly assumed to be another type. Type declaration statements can initialize data in the same way as the DATA statement: by having values, bounded by slashes, listed immediately after the symbolic name of the entity.
48. 64.1 - Numeric
Format:
type[*n] v [*n][/clist/][,v [*n][/clist/]]...
type Is any of the following data type specifiers:
BYTE (equivalent to LOGICAL*1 and INTEGER*1)
DOUBLE PRECISION
LOGICAL
INTEGER
REAL
COMPLEX
DOUBLE COMPLEX
n Is an integer that specifies (in bytes) the length
of "v". It overrides the length that is implied by
the data type.
The value of n must specify an acceptable length
for the type of "v" (see the "DEC Fortran
Language Reference Manual"). BYTE, DOUBLE
PRECISION, and DOUBLE COMPLEX data types have
one acceptable length; thus, for these data types,
the "n" specifier is invalid.
If an array declarator is used, the "n" specifier
must be positioned immediately after the array name.
v Is the symbolic name of a constant, variable,
array, statement function or function
subprogram, or array declarator.
clist Is a list of constants, as in a DATA statement. If
"v" is the symbolic name of a constant, the "clist"
cannot be present.
A numeric data type declaration statement can define arrays by
including array declarators in the list.
A numeric type declaration statement can assign initial values to
variables or arrays if it specifies a list of constants (the
"clist"). The specified constants initialize only the variable or
array that immediately precedes them. The "clist" cannot have more
than one element unless it initializes an array. When the "clist"
initializes an array, it must contain a value for every element in
the array.
48. 64.2 - Character
Format:
CHARACTER[*len[,] v[*len] [/clist/] [,v[*len] [/clist/]]...
len Is an unsigned integer constant, an integer constant
expression enclosed in parentheses, or an asterisk (*)
enclosed in parentheses. The value of "len" specifies
the length of the character data elements.
v Is the symbolic name of a constant, variable, array,
statement function or function subprogram, or array
declarator. The name can optionally be followed by
a data type length specifier (*len or *(*)).
clist Is a list of constants, as in a DATA statement. If
"v" is the symbolic name of a constant, "clist" must
not be present.
If you use CHARACTER*len, "len" is the default length specification
for that list. If an item in that list does not have a length
specification, the item's length is "len". However, if an item
does have a length specification, it overrides the default length
specified in CHARACTER*len.
When an asterisk length specification *(*) is used for a function
name or dummy argument, it assumes the length of the corresponding
function reference or actual argument. Similarly, when an asterisk
length specification is used for the symbolic name of a constant,
the name assumes the length of the actual constant it represents.
For example, STRING assumes a 9-byte length in the following
statements:
CHARACTER*(*) STRING
PARAMETER (STRING = 'VALUE IS:')
The length specification must range from 1 to 2**31-1 on RISC
processors. If no length is specified, a length of 1 is assumed.
Character type declaration statements can define arrays if they
include array declarators in their list. The array declarator goes
first if both an array declarator and a length are specified.
A character type declaration statement can assign initial values to
variables or arrays if it specifies a list of constants (the
clist). The specified constants initialize only the variable or
array that immediately precedes them. The "clist" cannot have more
than one element unless it initializes an array. When the "clist"
initializes an array, it must contain a value for every element in
the array.
48.65 - UNION
See Help topic: (statements) STRUCTURE (subheads Type_declarations and Union_declarations).
48.66 - UNLOCK
Frees the current record (that is, the last record read) in an
indexed, relative, or sequential file. By default, a record is
locked when it is read. The lock is normally held until your
program performs another I/O operation on the unit (for example,
rewriting the record, reading another record, or closing the file).
Statement format:
UNLOCK ([UNIT=]u[,ERR=s][,IOSTAT=ios])
UNLOCK u
u An integer variable or constant specifying the
logical unit number of the file, optionally
prefaced by UNIT=. UNIT= is required if unit is
not the first I/O specifier.
s The label of a statement to which control is
transferred if an error condition occurs.
ios An integer scalar memory reference that is
defined as a positive integer if an error occurs
and zero if no error occurs.
48.67 - VOLATILE
Prevents specified variables, arrays, and common blocks from being
optimized during compilation. Statement format:
VOLATILE nlist
nlist Is a list of one or more names of variables, arrays,
or common blocks (enclosed in slashes), separated
by commas.
Variables that have been equivalenced (either directly or
indirectly) are considered volatile if one element in the
EQUIVALENCE group is declared volatile.
If array names or common block names are used, the entire array or
common block becomes volatile.
48.68 - WRITE
Transfers data from internal storage to external or internal units.
The meanings of the symbolic abbreviations used to represent the
parameters in the WRITE statement syntax are as follows:
extu Is the logical unit or internal file optionally
or prefaced by UNIT=. UNIT= is required if unit is
intu not the first element in the clist.
fmt Specifies whether formatting is to be used for data
editing, and if it is, the format specification or an
asterisk (*) to indicate list-directed formatting.
The "fmt" is optionally prefaced by FMT=, if "fmt"
is the second parameter in the clist and the first
parameter is a logical or internal unit specifier
without the optional keyword UNIT=.
nml Is the namelist group specification for namelist I/O.
Optionally prefaced by NML=. NML= is required if
namelist is not the second I/O specifier.
rec Is the cell number of a record to be accessed directly.
Optionally prefaced by REC= or by an apostrophe (').
iostat Is the name of a variable to contain the completion
status of the I/O operation. Prefaced by IOSTAT=.
err Is the label of a statement to which control is
transferred in the event of an error. Prefaced by
ERR=.
end Is the label of a statement to which control is
transferred in the event of an end of file. Prefaced
by END=.
iolist Are the names of the variables, arrays, array elements,
or character substrings from which or to which data
will be transferred. Optionally an implied-DO list.
.b
The control-list parameters are "extu" (or "intu"), "fmt", "nml",
"rec", "iostat", "err", and "end". The I/O list
parameter is "iolist".
48. 68.1 - Sequential
48. 68. 1.1 - Formatted
Formatted sequential WRITE statement format:
WRITE (extu,fmt[,err][,iostat])[iolist]
Writes to a specified external unit. Translates the data from
binary to character format as specified by "fmt".
48. 68. 1.2 - List-directed
List-directed sequential WRITE statement format:
WRITE (extu,*[,err][,iostat])[iolist]
Writes to a specified external unit. Translates the data from
binary to character format according to the data types of the
variables in the I/O list.
48. 68. 1.3 - Namelist
Namelist sequential WRITE statement format:
WRITE (extu,nml[,err][,iostat])
Writes to a specified external unit. Translates the data from
binary to character format according to the data types of the list
entities in the corresponding NAMELIST statement.
48. 68. 1.4 - Unformatted
Unformatted sequential WRITE statement format:
WRITE (extu[,err][,iostat])[iolist]
Writes to a specified external unit. Does not translate the data.
48. 68.2 - Direct
48. 68. 2.1 - Formatted
Formatted direct WRITE statement format:
WRITE (extu,rec,fmt[,err][,iostat])[iolist]
WRITE (u'r,fmt[,err][,iostat]) [iolist]
Writes to a specified external unit. Translates the data from
binary to character format as specified by fmt.
48. 68. 2.2 - Unformatted
Unformatted direct WRITE statement format:
WRITE (extu,rec[,err][,iostat])[iolist]
WRITE (u'r[,err][,iostat])[iolist]
Writes to a specified external unit. Does not translate the data.
48. 68.3 - Internal
Internal WRITE statement format:
WRITE (intu[,fmt][,err][,iostat])[iolist]
Writes to a specified character variable. Translates the data from
binary to character format as specified by "fmt".
48. 68.4 - Indexed
48. 68. 4.1 - Formatted
Formatted indexed WRITE statement format:
WRITE (extu,fmt,[,err][,iostat])[iolist]
Writes to a specified external unit. Translates the data from
binary to character format as specified by "fmt".
48. 68. 4.2 - Unformatted
Unformatted indexed WRITE statement format:
WRITE (extu,[,err][,iostat])[iolist]
Writes to a specified external unit. Does not translate the data.
|
|
