1 FORTRAN
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.
2 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.
2 /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.
2 /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.
2 /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.
3 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.
3 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.
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.
3 ALL
Same interpretation as /ASSUME=(ACCURACY_SENSITIVE,BYTERECL,
DUMMY_ALIASES).
3 NONE
Same interpretation as
/ASSUME=(NOACCURACY_SENSITIVE,NOBYTERECL,NODUMMY_ALIASES).
2 /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.
3 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).
3 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.
3 ALL
Same interpretation as (INLINE,MAPPED). This is the default.
3 NONE
Same interpretation as (NOINLINE,NOMAPPED).
2 /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.
3 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.
3 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.
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.
3 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.
3 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.
3 ALL
Same interpretation as /CHECK=(ALIGNMENT, ASSERTIONS, BOUNDS,
OVERFLOW, UNDERFLOW). (/CHECK=ALL is equivalent to /CHECK.)
3 NONE
Same interpretation as /CHECK=(NOALIGNMENT, NOASSERTIONS, NOBOUNDS,
NOOVERFLOW, NOUNDERFLOW). (/CHECK=NONE is equivalent to /NOCHECK.)
2 /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.
2 /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.
3 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.
3 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.
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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
2 /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.
2 /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.
2 /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.
3 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.
3 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.
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.
3 ALL
Same interpretation as (PARAMETERS=ALL,SYMBOLS,TRACEBACK).
3 NONE
Same interpretation as (PARAMETERS=USED,NOSYMBOLS,NOTRACEBACK).
2 /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.
3 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.
3 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.
3 ALL
Same interpretation as (COMMENTS,PLACEHOLDERS).
3 NONE
Same interpretation as (NOCOMMENTS,NOPLACEHOLDERS).
2 /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.
2 /DIRECTIVES
/[NO]DIRECTIVES=(option[,...]) D=/DIRECTIVES=DEPENDENCE
Controls whether specified compiler directives are used at
compilation.
3 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.
3 ALL
Same interpretation as /DIRECTIVES=DEPENDENCE.
3 NONE
Same interpretation as /DIRECTIVES=NODEPENDENCE.
2 /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.
2 /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).
2 /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.
2 /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.
2 /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.
2 /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.
2 /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.
2 /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.
2 /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.
2 /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.
3 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.
3 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.
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.
2 /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).
2 /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.
3 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.
2 /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.
2 /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).
3 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.
3 MANUAL
Controls whether the compiler parses CPAR$ directives and generates
parallel code for loops preceded by CPAR$ DO_PARALLEL.
3 ALL
Same interpretation as /PARALLEL=(MANUAL, AUTOMATIC) (or
/PARALLEL).
3 NONE
Same interpretation as /PARALLEL=(NOMANUAL, NOAUTOMATIC) (or
/NOPARALLEL).
2 /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.
2 /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.
3 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.
3 DICTIONARY
Controls whether the listing file includes source representations
of any CDD records referenced by DICTIONARY statements.
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.
3 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.
3 MAP
Controls whether the listing file includes the symbol map. If the
/CROSS_REFERENCE qualifier is specified, MAP is ignored.
3 PREPROCESSOR
Controls whether the listing file includes preprocessor-generated
source lines.
3 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.
3 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.
3 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).
2 /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.
3 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.
3 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.
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.
3 SYNTAX
Controls whether the compiler produces informational diagnostics
for syntax extensions to the current ANSI standard. SYNTAX
extensions include nonstandard statements and language constructs.
3 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).
3 NONE
Same as specifying /NOSTANDARD.
2 /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.
2 /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.
3 STATISTICS
Controls whether the compiler displays the program unit name and
the number of code bytes generated when it completes processing
that program unit.
3 ALL
Same interpretation as /TERMINAL=STATISTICS.
3 NONE
Same interpretation as /TERMINAL=NOSTATISTICS.
2 /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.
2 /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).
3 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.
3 Alpha
Controls whether the compiler generates diagnostics for language
features not supported by Compaq Fortran 77 on Alpha systems.
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.
3 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).
3 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.
3 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.
3 ULTRIX
Controls whether the compiler generates diagnostics for language
features not supported by DEC Fortran on ULTRIX RISC systems.
3 UNCALLED
Controls whether the compiler generates informational diagnostics
for statement functions that are defined but not called.
3 UNINITIALIZED
Controls whether the compiler generates diagnostics for uses of
variables that the compiler believes do not have a defined value.
3 UNREACHABLE
Controls whether the compiler generates diagnostics for unreachable
code.
3 UNUSED
Controls whether the compiler generates informational diagnostics
for variables that are declared but not used.
3 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.
3 VAXELN
Controls whether the compiler issues diagnostics for language
features not supported by Compaq Fortran 77 on a VAXELN system.
3 ALL
Causes the compiler to print all informational and warning
messages, including warning messages for any untyped data items.
3 NONE
Suppresses all informational and warning messages.
2 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.
2 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
2 Built-in_Functions
3 %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.
3 %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.
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.
3 %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.
2 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.
3 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
3 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
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)
3 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.
3 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.
3 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)//'[')
2 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.
3 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.
3 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.
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.
3 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.
3 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.
3 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.
3 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).
3 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
3 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.
2 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.
3 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.
3 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.
4 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
4 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.
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.
3 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.
4 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)
4 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.
4 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)
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.
4 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.
4 Logical
The logical constants are .TRUE. and .FALSE.
4 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
4 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.
4 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
3 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)
4 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.
4 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.
4 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
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.
3 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.
4 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
4 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.
3 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.
3 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
3 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
4 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.
4 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.
4 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.
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.
4 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.
3 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.
4 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.
4 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.
2 Error_Messages
3 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
4 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
4 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.
4 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.
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.
4 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.
4 ALTRETLAB
SEVERITY: F
MESSAGE TEXT: Alternate return label used in invalid context
EXPLANATION: An alternate return argument cannot be used in a
function reference.
4 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
4 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
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 CDDRECDIM
SEVERITY: F
MESSAGE TEXT: CDD record is dimensioned
EXPLANATION: Compaq Fortran does not support dimensioned structures,
for example, arrays of structures.
4 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.
4 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.
4 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.
4 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/
4 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/
4 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)
4 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.
4 CLOSEIN
SEVERITY: F
MESSAGE TEXT: Error closing "file-spec" as input
EXPLANATION: Unable to close the file "file-spec".
4 CLOSEOUT
SEVERITY: F
MESSAGE TEXT: Error closing "file-spec" as output
EXPLANATION: Unable to close the file "file-spec".
4 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.
4 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.
4 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).
4 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.
4 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.
4 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.
4 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.
4 DEPENDITEM
SEVERITY: I
MESSAGE TEXT: CDD description contains Depends Item attribute
(ignored)
EXPLANATION: Fortran does not support the Common Data Dictionary
Depend Item attribute.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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
4 EXTBADCONT
SEVERITY: I
MESSAGE TEXT: Extension to FORTRAN-77: nonstandard continuation
character
EXPLANATION: A nonstandard character was used as a continuation
indicator.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 EXTILDOCNT
SEVERITY: I
MESSAGE TEXT: Extension to FORTRAN-77: Negative implied-Do
iteration count
EXPLANATION: The iteration count of an implied DO was negative.
4 EXTINTRIN
SEVERITY: I
MESSAGE TEXT: Extension to FORTRAN-77: nonstandard intrinsic
function
EXPLANATION: A nonstandard intrinsic function was used.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 EXT_ARIREQ
SEVERITY: I
MESSAGE TEXT: Extension to FORTRAN-77: Arithmetic expression
required
EXPLANATION: A logical expression was used in an arithmetic IF
statement.
4 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).
4 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.
4 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
4 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.
4 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
4 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
4 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.
4 EXT_KEY
SEVERITY: I
MESSAGE TEXT: Extension to FORTRAN-77: nonstandard keyword
EXPLANATION: A nonstandard keyword was used.
4 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'
4 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
4 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.
4 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.
4 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.
4 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.
4 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.
4 EXT_STMT
SEVERITY: I
MESSAGE TEXT: Extension to FORTRAN-77: nonstandard statement type
EXPLANATION: A nonstandard statement type was used.
4 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
4 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 -
4 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.
4 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.
4 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.
4 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.
4 FMTEXTCOM
SEVERITY: W
MESSAGE TEXT: Extra comma in format list
EXPLANATION: A format list contained an extra comma.
Example: FORMAT(I4,)
4 FMTEXTNUM
SEVERITY: E
MESSAGE TEXT: Extra number in format list
EXPLANATION: A format list contained an extraneous number.
Example: FORMAT (I4,3)
4 FMTINVCHA
SEVERITY: E
MESSAGE TEXT: Format item contains meaningless character
EXPLANATION: An invalid character or a syntax error was detected
in a FORMAT statement.
4 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.
4 FMTMISNUM
SEVERITY: E
MESSAGE TEXT: Missing number in format list
EXPLANATION: An expected number was missing from a format list.
Example: FORMAT (F6.)
4 FMTMISSEP
SEVERITY: E
MESSAGE TEXT: Missing separator between format items
EXPLANATION: A required separator character was omitted between
fields in a FORMAT statement.
4 FMTNEST
SEVERITY: E
MESSAGE TEXT: Format groups nested too deeply
EXPLANATION: Format groups cannot be nested beyond eight levels.
4 FMTPAREN
SEVERITY: E
MESSAGE TEXT: Unbalanced parentheses in format list
EXPLANATION: The number of right parentheses does not match the
number of left parentheses.
4 FMTSIGN
SEVERITY: E
MESSAGE TEXT: Format item cannot be signed
EXPLANATION: A signed constant is valid only with the P format
code.
4 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.
4 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.
4 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./
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 IMPSYNERR
SEVERITY: E
MESSAGE TEXT: Syntax error in IMPLICIT statement
EXPLANATION: Improper syntax was used in an IMPLICIT statement.
4 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
4 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.
4 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
4 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)
4 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
4 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.
4 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.
4 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.
4 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.
4 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.)
4 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.
4 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).
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 INVDUMARG
SEVERITY: E
MESSAGE TEXT: Dummy argument invalid in parallel memory directive
EXPLANATION: Dummy arguments cannot be specified on a parallel
memory directive.
4 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.
4 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.
4 INVEQVCOM
SEVERITY: F
MESSAGE TEXT: Invalid equivalence of two variables in common
EXPLANATION: Variables in common blocks cannot be equivalenced to
each other.
4 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)
4 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.
4 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.
4 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
4 INVKEYOPE
SEVERITY: F
MESSAGE TEXT: Incorrect keyword in OPEN, CLOSE, or INQUIRE
statement
EXPLANATION: An OPEN, CLOSE, or INQUIRE statement contained an
invalid keyword.
4 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.
4 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.
4 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.
4 INVNMLELE
SEVERITY: F
MESSAGE TEXT: Invalid namelist element
EXPLANATION: An element other than a variable or array name
appeared in a namelist declaration.
4 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.
4 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.
4 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)
4 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.
4 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.
4 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.
4 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)
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 IOSYNERR
SEVERITY: F
MESSAGE TEXT: Syntax error in I/O list
EXPLANATION: Improper syntax was detected in an I/O list.
4 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.
4 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
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 MISSAPOS
SEVERITY: E
MESSAGE TEXT: Missing apostrophe in character constant
EXPLANATION: A character constant must be enclosed by apostrophes.
4 MISSCOM
SEVERITY: F
MESSAGE TEXT: Missing common block name
EXPLANATION: A common block name was omitted or specified
improperly on a SHARED directive.
4 MISSCONST
SEVERITY: F
MESSAGE TEXT: Missing constant
EXPLANATION: A required constant was not found.
4 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
4 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.
4 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.
4 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.
4 MISSLABEL
SEVERITY: F
MESSAGE TEXT: Missing statement label
EXPLANATION: A required statement label reference was omitted.
4 MISSNAME
SEVERITY: F
MESSAGE TEXT: Missing variable or subprogram name
EXPLANATION: A required variable name or subprogram name was not
found.
4 MISSUNIT
SEVERITY: F
MESSAGE TEXT: Unit specifier keyword missing in I/O statement
EXPLANATION: An I/O statement must include a unit specifier
subparameter.
4 MISSVAR
SEVERITY: F
MESSAGE TEXT: Missing variable or constant
EXPLANATION: An expression, or a term of an expression, was
omitted. Examples:
WRITE ( )
DIST = *TIME
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 MULSTRNAM
SEVERITY: F
MESSAGE TEXT: Multiply defined STRUCTURE name
EXPLANATION: A STRUCTURE name must be unique among STRUCTURE
names.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.)
4 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.
4 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.
4 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).
4 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
4 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.
4 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.
4 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.
4 NONCONSUB
SEVERITY: F
MESSAGE TEXT: Nonconstant subscript where constant required
EXPLANATION: Subscript and substring expressions used in DATA and
EQUIVALENCE statements must be constants.
4 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
4 NOPPARVEC
SEVERITY: W
MESSAGE TEXT: /NOOPTIMIZE conflicts /PARALLEL=AUTOMATIC or /VECTOR
EXPLANATION: When you specify /PARALLEL=AUTOMATIC or /VECTOR, you
must omit /NOOPTIMIZE.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 NOVECSUBP
SEVERITY: I
MESSAGE TEXT: Vectorization inhibition: Reference to subprogram
EXPLANATION: Vectorization is not performed for data that can be
modified in the subprogram.
4 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.
4 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.
4 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
4 OPENIN
SEVERITY: F
MESSAGE TEXT: Error opening "file-spec" as input
EXPLANATION: Unable to open the file "file-spec".
4 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.
4 OPENOUT
SEVERITY: F
MESSAGE TEXT: Error opening "file-spec" as output
EXPLANATION: Unable to open the file "file-spec".
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 PLACENOTVAL
SEVERITY: E
MESSAGE TEXT: Placeholder not valid in this context
EXPLANATION: A placeholder was found in a context that is not
supported.
4 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.
4 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.
4 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.
4 READERR
SEVERITY: F
MESSAGE TEXT: Error reading "file-spec"
EXPLANATION: Unable to read from file "file-spec".
4 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.
4 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.
4 REFERENCE
SEVERITY: I
MESSAGE TEXT: CDD description contains Reference attribute
(ignored)
EXPLANATION: Fortran does not support the CDD Reference attribute.
4 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.
4 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.
4 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.
4 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.
4 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.
4 SOURCETYPE
SEVERITY: I
MESSAGE TEXT: CDD description contains Source Type attribute
(ignored)
EXPLANATION: Compaq Fortran does not support the CDD Source Type
attribute.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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
4 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.
4 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.
4 TOOMANCON
SEVERITY: E
MESSAGE TEXT: Too many continuation lines, remainder ignored
EXPLANATION: Up to 99 continuation lines are permitted.
4 TOOMANDIM
SEVERITY: E
MESSAGE TEXT: More than 7 dimensions specified, remainder ignored
EXPLANATION: An array cannot have more than seven dimensions.
4 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.
4 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.
4 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.
4 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.
4 UNRECSTMT
SEVERITY: F
MESSAGE TEXT: Unrecognized statement
EXPLANATION: The statement encountered was not recognized as
valid.
4 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.
4 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.
4 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.
4 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))
4 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.
4 VARUNUSED
SEVERITY: I
MESSAGE TEXT: Variable was declared but not used
EXPLANATION: The specified variable was declared but never used.
4 VAXELNUNS
SEVERITY: W
MESSAGE TEXT: This feature is unsupported on VAXELN
EXPLANATION: The specified Compaq Fortran feature is not supported on
a VAXELN system.
4 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.
4 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
4 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
4 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
4 WRITEERR
SEVERITY: F
MESSAGE TEXT: Error writing "file-spec"
EXPLANATION: Unable to write to file "file-spec".
4 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.
4 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.
3 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.
4 General
5 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.
5 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.
5 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.
5 CLOERR
NUMBER: 28
ERROR CODE: F
MESSAGE TEXT: CLOSE error
EXPLANATION: An error condition was detected by RMS during
execution of a CLOSE statement.
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.
5 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.
5 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.
5 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.
5 ERRDURREA
NUMBER: 39
ERROR CODE: F
MESSAGE TEXT: error during read
EXPLANATION: RMS detected an error condition during execution of a
READ statement.
5 ERRDURWRI
NUMBER: 38
ERROR CODE: F
MESSAGE TEXT: error during write
EXPLANATION: RMS detected an error condition during execution of a
WRITE statement.
5 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.
5 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.
5 FINERR
NUMBER: 57
ERROR CODE: F
MESSAGE TEXT: FIND error
EXPLANATION: RMS detected an error condition during execution of a
FIND statement.
5 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.
5 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.
5 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.
5 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.
5 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.
5 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.
5 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.
5 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.
5 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.
5 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.
5 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.
5 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.
5 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
5 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.
5 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.
5 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.
5 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.
5 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.
5 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.
5 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.
5 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.
5 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.
5 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.
5 INVARGMAT
NUMBER: 81
ERROR CODE: F
MESSAGE TEXT: invalid argument to math library
EXPLANATION: One of the mathematical procedures detected an
invalid argument value.
5 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.
5 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.
5 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.
5 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.
5 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.
5 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.
5 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.
5 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.
5 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.
5 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.
5 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.
5 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'.
5 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.
5 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.
5 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.
5 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.
5 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.
5 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.
5 REWRITERR
NUMBER: 54
ERROR CODE: F
MESSAGE TEXT: REWRITE error
EXPLANATION: RMS detected an error condition during execution of a
REWRITE statement.
5 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.
5 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.
5 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.
5 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.
5 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.
5 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.
5 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.
5 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.
5 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.
5 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).
5 UNIALROPE
NUMBER: 34
ERROR CODE: F
MESSAGE TEXT: unit already open
EXPLANATION: A DEFINE FILE statement specified a logical unit that
was already opened.
5 UNLERR
NUMBER: 56
ERROR CODE: F
MESSAGE TEXT: UNLOCK error
EXPLANATION: RMS detected an error condition during execution of
an UNLOCK statement.
5 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.
5 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.
5 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.
4 Parallel_Processing_Specific
5 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.
5 DEFVALUSED
SEVERITY: I
MESSAGE TEXT: Default value of xx used for logical name
EXPLANATION: A default value was used for the specified logical
name.
5 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.
5 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.
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.
5 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.
5 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.
5 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.
5 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.
5 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.
5 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.
5 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.
5 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.
5 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.
5 INVLOGNAM
SEVERITY: E
MESSAGE TEXT: Invalid logical name definition
EXPLANATION: A logical name was defined incorrectly.
5 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.
5 INVUNWIND
SEVERITY: F
MESSAGE TEXT: Invalid stack unwinding encountered
EXPLANATION: The Fortran Run-Time Library detected an invalid
attempt to unwind the stack.
5 LOCALACCESS
SEVERITY: F
MESSAGE TEXT: Subprocess unable to access the shared $LOCAL PSECT
EXPLANATION: A subprocess could not access the shared $LOCAL
PSECT.
5 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.
5 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.
5 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.
5 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.
5 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.
5 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.
5 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.
5 SUBPRCDIED
SEVERITY: F
MESSAGE TEXT: Subprocess PID: xx terminated
EXPLANATION: A subprocess with the specified process ID was
terminated.
5 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.
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.
2 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.
3 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
3 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.
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.
3 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.
3 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.
3 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.
3 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.
3 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 | : |
+--------------------------+--------------+
3 '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.
3 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.
3 $
(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.
3 :
(Format Control)
Terminates the I/O operation if no more items remain in the I/O
list.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
4 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.
4 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.
4 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.
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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
2 Intrinsic_Procedures
3 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.
3 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 |
+------+---------+----------+------------+-------------+
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 |
+------+---------+----------+------------+-------------+
3 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.
3 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.
3 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.
3 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.
3 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.
3 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 |
+------+---------+----------+------------+-------------+
3 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 |
+------+---------+----------+------------+-------------+
3 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 |
+------+---------+----------+------------+-------------+
3 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 |
+------+---------+----------+------------+-------------+
3 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.
3 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.
3 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 |
+------+---------+----------+------------+-------------+
3 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.
3 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 |
+-------+---------+----------+------------+-------------+
3 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 |
+------+---------+----------+------------+-------------+
3 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 |
+------+---------+----------+------------+-------------+
3 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 |
+------+---------+----------+------------+-------------+
3 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 |
+------+---------+----------+------------+-------------+
3 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.
3 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.
3 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 |
+------+---------+----------+------------+-------------+
3 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 |
+-------+---------+----------+------------+-------------+
3 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 |
+------+---------+----------+------------+-------------+
3 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.
3 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.
3 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.
3 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).
3 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 |
+------+---------+----------+------------+-------------+
3 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 |
+------+---------+----------+------------+-------------+
3 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.
3 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 |
+------+---------+----------+------------+-------------+
3 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.
3 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.
3 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 |
+------+---------+----------+------------+-------------+
3 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 |
+------+---------+----------+------------+-------------+
3 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 |
+------+---------+----------+------------+-------------+
3 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.
3 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.
3 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.
3 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.
3 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.
3 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 |
+------+---------+----------+------------+-------------+
3 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).
3 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 |
+--------------------------------------------------------+
3 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.
3 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.
3 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 |
+------+---------+----------+------------+-------------+
3 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.
3 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.
3 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 |
+------+---------+----------+------------+-------------+
3 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 |
+------+---------+----------+------------+-------------+
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.).
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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 |
+------+---------+----------+------------+-------------+
3 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.
3 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.
3 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 |
+------+---------+----------+------------+-------------+
3 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.
3 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 |
+------+---------+----------+------------+-------------+
3 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 |
+------+---------+----------+------------+-------------+
3 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.
3 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 |
+------+---------+----------+------------+-------------+
3 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.
3 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.
3 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 |
+------+---------+----------+------------+-------------+
3 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 |
+------+---------+----------+------------+-------------+
3 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 |
+------+---------+----------+------------+-------------+
3 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. | |
+------+---------+----------+---------------------------+-------------+
3 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.
3 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 |
+------+---------+----------+------------+-------------+
3 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 |
+------+---------+----------+------------+-------------+
3 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 |
+------+---------+----------+------------+-------------+
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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 |
+------+---------+----------+------------+-------------+
2 Logical_Names
Various VMS logical names can be defined to modify the behavior of
the Compaq Fortran compiler or an executing application.
3 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.
3 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.
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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
2 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.
3 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)
3 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.
2 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 |
+----------------------------------------------------------------+
3 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 (/ /).
4 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.
4 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
4 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.
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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
4 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.
3 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.
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.
3 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.
3 ASSERT
See CDEC$ ASSERT under Statements Directive_Statements in this Help
file.
3 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.
3 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.
4 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 | |
----------------------------------------------------------------
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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
3 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.
3 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.
3 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'
3 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.
3 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.
3 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.
3 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
3 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.
3 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
3 END_DO
Terminates the block of statements following a DO or DO WHILE
statement when a label is not used. Statement format:
END DO
3 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
3 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
3 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
3 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.
3 END_IF
Terminates a block IF construct. Statement format:
END IF
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
3 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.
4 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.
4 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.
4 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.
3 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.
4 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.
4 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.
4 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
3 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.
3 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.
3 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
3 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
4 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]
4 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]
4 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]
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])
3 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.)
4 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
4 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.
4 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
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.
4 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
4 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".
4 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.
4 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
4 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
4 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.
4 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
4 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.
4 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
4 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.
4 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.
4 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
4 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
4 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.
4 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
4 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
4 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
3 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.
3 MAP
See STRUCTURE (subheads Unions and Type_declarations).
3 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.
3 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.
4 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
4 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.
4 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'.
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.
4 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.
4 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'.
4 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.
4 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')
4 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.
4 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.
4 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.
4 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.
4 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*
4 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.
4 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.)
4 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.
4 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).
4 NAME
NAME is a nonstandard synonym for FILE. (See FILE.)
4 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.
4 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.
4 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.
4 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.
4 RECORDSIZE
RECORDSIZE = e
RECORDSIZE is the nonstandard synonym for RECL.
4 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.
4 SHARED
SHARED
Specifies that the file can be accessed by more than one user at
the same time.
4 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.
4 TYPE
TYPE is a nonstandard synonym for STATUS (see STATUS).
4 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.
4 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.
3 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.
3 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.
3 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.
3 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.
4 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.
4 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.
4 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=.
3 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.
3 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.
3 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".
4 Sequential
5 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).
5 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.
5 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.
5 Unformatted
Unformatted sequential READ statement format:
READ(extu,[,iostat][,err][,end])[iolist]
Reads from a specified external unit. Does not translate the data.
4 Direct
5 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".
5 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.
4 Indexed
5 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".
5 Unformatted
Unformatted Indexed READ statement format:
READ(extu,keyspec[,keyid][,err][,iostat])[iolist]
Reads from a specified external unit. Does not translate the data.
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".
3 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.
3 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.
3 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.
3 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
3 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.
3 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.
3 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.
3 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
4 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.
4 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.
4 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
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.
3 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.
3 TYPE
Transfers data from internal storage to FOR$TYPE (normally the
terminal). The access mode is sequential.
4 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.
4 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.
4 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=.
3 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.
4 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.
4 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.
3 UNION
See Help topic: (statements) STRUCTURE (subheads Type_declarations
and Union_declarations).
3 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.
3 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.
3 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".
4 Sequential
5 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".
5 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.
5 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.
5 Unformatted
Unformatted sequential WRITE statement format:
WRITE (extu[,err][,iostat])[iolist]
Writes to a specified external unit. Does not translate the data.
4 Direct
5 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.
5 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.
4 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".
4 Indexed
5 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".
5 Unformatted
Unformatted indexed WRITE statement format:
WRITE (extu,[,err][,iostat])[iolist]
Writes to a specified external unit. Does not translate the data.