Invokes the Digital Fortran 77 (FORTRAN-77) compiler. This command
can also invoke other software components (such as preprocessors,
or the ld linker), depending on which files or options are
specified on the command line. The f77 command produces object
code files in ULTRIX RISC or Digital UNIX Alpha extended coff
format; it is described in detail in your DEC Fortran user manual.
(See also f77(1).)
Format:
f77 [options] filename [options]
If you specify more than one option or filename, separate each with
a space. Some options include keywords. For more information, see
Parameters.
f77 sends its output to "stderr". Upon program completion, the f77
driver returns one of the following status values:
0 - SUCCESS
1 - FAILURE
2 - SUBPROCESS_FAILURE (preprocessor, decfort, or ld)
3 - SIGNAL
If the environment variable DECFORT is set, the value is used as
the name of the compiler to invoke. If the environment variable
TMPDIR is set, the value is used as the directory for temporary
files.
If the environment variable DECFORT_INIT is defined, its value has
to have the form
[[pre] [:: [post]]
where the items in "[...]" are optional and can be empty, and where
"pre" and "post" are strings to be added to the command line.
"pre" is added to the front of the command line, before any
characters the user typed; "post" is added to the end of the
command line.
Your Digital Fortran kit contains a Help file in text format. To
search for information in this file, enter the following command to
display the file:
% more /usr/lib/cmplrs/fort/decfortran.hlp
To search for a specific item, enter a slash (/) followed by the
item. For example, once the Help file is displayed, you can search
for run-time error message number 138 by entering the following:
/138
Options
Indicates either special actions to be performed by the compiler or
linker, or special properties of input or output files.
If you specify more than one option, separate each option with a
space.
Certain options have the format of -option "keyword", where the
"keyword" can be abbreviated to its shortest unique prefix. For
example, -assume noaccuracy can be abbreviated as -assume noac.
For more information about command line options, see f77(1). If
you are using LSE, you can see f77(1) by entering the following
command at the LSE prompt:
LSE> cli man f77
Filename
Specifies one (or more) source programs to be compiled. If you
specify more than one filename, separate each filename with a
space.
The f77 command interprets filename suffixes as follows:
o Arguments with the suffix .f, .for, or .FOR are interpreted as
FORTRAN-77 source programs. These programs are compiled, and
the name of the resulting object program is the basename of the
source file with a .o substituted for the .f, .for, or .FOR.
(For example, in source file myfile.f, myfile is the basename;
so, the object program is named myfile.o.) If the source
program is compiled and loaded, the .o file is deleted.
o Arguments with the suffix .F are interpreted as FORTRAN source
programs, which must be processed by the C preprocessor
(cpp(1)) before being compiled.
o Arguments with the suffixes .r or .e are interpreted as ratfor
or efl source programs, respectively. These programs are first
transformed by the appropriate preprocessor and then compiled.
o Arguments with the suffix .i are interpreted as FORTRAN-77
source programs that have been preprocessed by cpp(1). They
are compiled without further preprocessing.
When a source program requires preprocessing by cpp(1), efl(1),
ratfor(1), or m4(1), the name of the output file generated by the
preprocessor consists of the basename of the source input file with
the appropriate preprocessor suffix. For example:
m4 myfile.r => myfile.p
efl myfile.e => myfile.f
ratfor myfile.r => myfile.f
cpp myfile.F => myfile.i
Note that if you have myfile.F and myfile.f as distinct files,
cpp(1) overwrites myfile.f to produce an output file with the same
name.
Depending on which platform you are using, the f77 command defines
the following cpp(1) macros to cpp(1):
o All platforms: LANGUAGE_FORTRAN, __LANGUAGE_FORTRAN__, unix,
__unix__
o RISC only: host_mips, __host_mips__
o Alpha only: __alpha
o Digital UNIX only: __osf__
o ULTRIX RISC only: MIPSEL, mips, __mips__
For example, if you are using an Digital UNIX Alpha system, the
following cpp(1) macros are defined to cpp(1): LANGUAGE_FORTRAN,
__LANGUAGE_FORTRAN__, unix, __unix__, __alpha, and __osf__.
Indicate either special actions to be performed by the compiler or
linker, or special properties of input or output files.
You can override some options specified on the command line by
using the OPTIONS statement, the AUTOMATIC and STATIC statements,
and directives (CDEC$) in your FORTRAN source program. The options
specified by the OPTIONS statement affect only the program unit
where the statement occurs.
For descriptions of all command line options, see f77(1) by
entering the following command at the LSE prompt:
LSE> cli man f77
1. % f77 -V aaa.f bbb.f ccc.f
This command causes the files aaa.f, bbb.f, and ccc.f to be
compiled into one temporary object file, which is then passed
to the ld linker. The ld linker produces the executable file
a.out. The -V option causes the compiler to create the listing
file aaa.1.
2. % f77 -o foo ax.f bx.f cx.f
This command causes the files ax.f, bx.f, and cx.f to be
compiled as one program, with the resulting executable file
foo.
3. % f77 -c -O4 ax.f bx.f cx.f
This command causes the files ax.o, bx.o and cx.o to be
created. Inter-procedural optimization is hindered because
these input files are separately compiled.
4. % f77 -c -o foo.o -O4 ax.f bx.f cx.f
This command causes the files ax.f, bx.f and cx.f to be
compiled as one program, with the resulting object file foo.o.
This produces better optimization.
For Digital Fortran 77 release notes, refer to:
/usr/lib/cmplrs/fort/relnotes
Built-in functions perform utility operations that are useful in communicating with subprograms written in languages other than Fortran. See also Intrinsic_Functions.
%LOC (arg) Returns the internal address of a storage item. The argument can be a variable, an array or record field reference, a procedure, or a constant; it can be of any data type. The result is an INTEGER*8 data type. The %LOC built-in function serves the same purpose as the LOC intrinsic.
%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.
%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.
Digital Fortran 77 supports the following characters:
o The Fortran character set, consisting of those ASCII characters
which can appear in Fortran language syntax and which is a
superset of the FORTRAN-77 standard character set. This set
includes space and tab characters.
o Other printable characters, which may appear in comments and
character and Hollerith constants.
o Nonprintable characters.
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
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
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)
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)
" (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.
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.
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.
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 the command line option -vms is specified.
All other control characters are valid, except 00(hex) and 01(hex).
If you must use a nonprintable character in a character constant,
use the CHAR intrinsic function, in conjunction with the
concatenation operator if necessary. For example:
CHARACTER*(*) ESC_BRACKET
PARAMETER (ESC_BRACKET = CHAR(27)//'[')
Digital Fortran 77 provides the following language features to facilitate 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 The AND, OR, XOR, IMAG, LSHIFT, and RSHIFT intrinsic functions o An alternative syntax for bit constants o C-style escape sequences o An alternative syntax for a record specifier These language features are particularly useful in transporting older Fortran programs to systems on Alpha processors. 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.
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 direct access
sequential file is opened, or created if necessary. 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.
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.
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.
If you specify the -nof77 compiler option, you get an
interpretation of the EXTERNAL statement that facilitates
compatibility with older versions of Fortran. (The ANSI FORTRAN-77
interpretation is incompatible with the previous standard and
previous Digital 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.
Octal forms of integer constants allow compatibility with PDP-11
FORTRAN. You must specify the -vms compiler option to use octal
notation. 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.
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.
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).
Digital Fortran 77 allows certain intrinsic functions for
compatibility with FORTRAN for RISC. The following list shows
these functions and their equivalents:
Function Equivalent Function
-------- -------------------
AND IAND
OR IOR
XOR IEOR
IMAG AIMAG and DIMAG
LSHIFT ISHFT with a positive second argument
RSHIFT ISHFT with a negative second argument
Digital Fortran 77 allows 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
In all above syntax forms, you can use a quotation mark(") in place
of an apostrophe (').
Digital Fortran 77 allows the following C-style escape sequences in
character constants, if you do not specify the -vms or -assume
backslash compiler options:
Escape Sequence Represents
--------------- ----------
\n A new line
\t A horizontal tab
\b A backspace
\f A formfeed
\0 A null character
\' An apostrophe
\" A quotation mark
\\ A backslash
\x Any other character (x)
Digital Fortran 77 allows 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.
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 Digital Fortran 77 are integer, REAL (REAL*4), DOUBLE PRECISION (REAL*8), REAL*16 (Alpha only), COMPLEX (COMPLEX*8), DOUBLE COMPLEX (COMPLEX*16), BYTE (equivalent to 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 language reference manual to identify what can be included in a particular statement or expression.
An aggregate reference resolves into 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 --- A record name
RECARY(1) --- A record array reference
REC.RECFLD --- A reference to a substructure
REC.RECFLDARY(1) --- A reference to a substructure array element
RECARY(1).RECFLD --- A reference to a substructure in a record
array element
RECARY(1).RECFLDARY(1) --- A reference to a substructure array
element in a record array
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.
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
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.
Adjustable arrays are dummy arguments in subprograms. The
dimensions of an adjustable array are determined in the reference
to the subprogram.
The array declarator for an adjustable array can contain integer
variables that are either dummy arguments or variables in a common
block.
When the subprogram is entered, each dummy argument used in the
array declarator must be associated with an actual argument, and
each variable in a common block used in an array declarator must
have a defined value. The dimension declarator is evaluated using
the values of the actual arguments, variables in common blocks, and
constants specified in the array declarator.
Argument association is not retained between one reference to a
subprogram and the next reference to that subprogram.
The size of the adjustable array must be less than or equal to the
size of the array that is its corresponding actual argument.
You can also declare adjustable arrays in RECORD statements not
contained within structure declarations.
To avoid possible errors in subscript evaluation, make sure that
the bounds expressions used to declare multidimensional adjustable
arrays match the bounds as declared by the caller.
In the following example, the function computes the sum of the
elements of a two-dimensional array. Notice how the dummy
arguments M and N control the iteration:
FUNCTION SUM(A,M,N)
DIMENSION A(M,N)
SUM = 0.0
DO 10 J=1,N
DO 10 I=1,M
10 SUM = SUM + A(I,J)
RETURN
END
The following statements are sample calls on SUM:
DIMENSION A1(10,35), A2(3,56)
SUM1 = SUM(A1,10,35)
SUM2 = SUM(A2,3,56)
SUM3 = SUM(A1,10,10)
An adjustable array is undefined if a dummy argument array is not
currently associated with an actual argument array. It is also
undefined if any of the variables in the adjustable array
declarator are either not currently associated with an actual
argument or not in a common block.
Digital Fortran 77 also allows the following form for an adjustable
array:
SUBROUTINE SUB1(A,B)
DIMENSION A(B(1)) ! An array element is allowed
A and B must be dummy arguments; B can be in COMMON.
An assumed-size array is a dummy array for which the upper bound of
the last dimension is specified as an asterisk (*), for example:
SUBROUTINE SUB(A,N)
DIMENSION A(1:N,1:*)
If the lower bound of an assumed-size array is not specified, it is
assumed to be 1. Therefore, the previous DIMENSION statement is
equivalent to the following:
DIMENSION A(1:N,*)
The size of an assumed-size array and the number of elements that
can be referenced are determined as follows:
o If the actual argument corresponding to the dummy array is a
name of a noncharacter array, the size of the dummy array is
the size of the actual-argument array.
o If the actual argument corresponding to the dummy argument is a
name of a noncharacter array element, with a subscript value of
"s" in an array of size "a", the size of the dummy array is
"a + 1 - s".
o If the actual argument is a name of a character array,
character array element, or character array element substring
and begins at character storage unit "b" of an array with n
character storage units, the size of the dummy array is
"INT(n + 1 - b)/y", where "y" is the length of an element of
the dummy array.
Because the actual size of an assumed-size array is unknown, an
assumed-size array name cannot be used as any of the following
items in an I/O statement:
o An array name in the I/O list
o A unit identifier for an internal file
o A run-time format specifier
An automatic array is a local array that is created when you enter a subprogram. The dimensions are determined by dummy arguments or variables in COMMON when the subprogram is called. For example: SUBROUTINE SUB1(N) DIMENSION A(N) ! Variable A is local N must be a dummy argument or it must be in a common block.
An array name reference resolves into 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 --- Numeric or character array
RECARY --- Array of records
REC.INTFLDARY --- Numeric or character array field of a record
REC.RECFLDARY --- Array of substructures within a record
RECARY(1).INTFLDARY --- Numeric or character array field of a
record array element
RECARY(1).RECFLDARY --- Array of substructures within a record
array element
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.
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, if the bit
constant is greater than 4 bytes, INTEGER*8 is assumed;
otherwise, INTEGER*4 is assumed.
o When the constant is used in any other context, an INTEGER*4
data type is assumed (unless the -noi4 or -i8 (Alpha only)
compiler option specifies otherwise).
A character constant is a string of printable ASCII characters
enclosed by delimiters. It takes one of the following forms:
'c1,c2,c3...cn'
"c1,c2,c3...cn"
where c is a printable character
The length of the character constant is the number of characters
between the delimiters. In the apostrophe format, two consecutive
apostrophes represent a single apostrophe. In the quotation mark
format, two consecutive quotation marks represent a single
quotation mark.
The length of a character constant must be in the range 1 to 2000.
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.
Digital Fortran 77 supports COMPLEX*8 and COMPLEX*16 complex
constants.
A COMPLEX (COMPLEX*8) constant has the form:
(c,c) c is an integer or REAL (REAL*4) constant
A DOUBLE COMPLEX (COMPLEX*16) constant has the form:
(c,c) c is an integer, REAL (REAL*4), or
DOUBLE PRECISION (REAL*8) constant (at
least one of the pair must be a DOUBLE
PRECISION constant)
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.
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 (leading
zeros are ignored)
You can use integer constants to assign values to data. The
integer data types have the following ranges:
BYTE Same range as 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*8 Signed integers: -9223372036854775808 to
(Alpha only) 9223372036854775807 (-2**63 to 2**63-1)
(8 bytes)
NOTE: On Alpha processors, the value of an
integer constant must be within this range.
Note that logical data type ranges correspond to their comparable
integer data type ranges. For example, the LOGICAL*2 range is the
same as the INTEGER*2 range.
The value of an integer constant is normally INTEGER*2, INTEGER*4,
or INTEGER*8 (Alpha only). If a value is within INTEGER*2 range,
it is treated as an INTEGER*2 value; if a value is outside
INTEGER*2 range, but within INTEGER*4 range, it is treated as an
INTEGER*4 value, and so forth.
The logical constants are .TRUE. and .FALSE. Note that logical data type ranges correspond to their comparable integer data type ranges. For example, the LOGICAL*2 range is the same as the INTEGER*2 range. For more information on integer data type ranges, see DATA CONSTANTS INTEGER in this online Help file.
A REAL (REAL*4) constant is 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
The approximate range of a nonzero REAL constant is 1.175E-38 to
3.403E38 (S_floating).
S_floating computational results smaller than 1.17549429E-38 are
denormalized numbers that gradually underflow and lose precision,
until they reach approximately 1.40129846E-46. You cannot write a
constant for a denormalized number.
A DOUBLE PRECISION (REAL*8) constant is a basic real constant or an
integer constant followed by a decimal exponent. A decimal
exponent has the form:
Dsnnn s is an optional sign
nnn is a string of decimal digits
NOTE: Digital Fortran 77 also allows the syntax Qsnnn, if the
exponent field is within the T_floating double precision range.
On Digital UNIX systems, the DOUBLE PRECISION data type implements
the IEEE T_floating format.
T_floating computational results smaller than
2.2250738585072012D-308 are denormalized numbers that gradually
underflow and lose precision, until they reach approximately
4.9406564584124654D-324. You cannot write a constant for a
denormalized number.
A REAL*16 constant is 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
This type of constant is only available on Alpha systems.
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 1 (lowest) LOGICAL*1 1 LOGICAL*2 2 LOGICAL*4 3 LOGICAL*8 (Alpha only) 4 INTEGER*1 5 INTEGER*2 6 INTEGER*4 7 INTEGER*8 (Alpha only) 8 REAL (REAL*4) 9 REAL*16 (Alpha only) 10 DOUBLE PRECISION (REAL*8) 11 COMPLEX (COMPLEX*8) 12 DOUBLE COMPLEX (COMPLEX*16) 13 (highest)
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 Ranking 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.
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 may 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.
Logical expressions may 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
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.
A record is a named data entity, consisting of one or more fields, which you can use when you need to declare and operate on multi-field data structures in your programs. To create a record, you must have a structure declaration (to describe the fields in the record) and a RECORD statement to establish the record in memory.
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 illustrate 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
Fields within a record may 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, for example:
rname[.cfname...cfname]
rname Is the name used in the RECORD statement to
identify a record.
cfname Is a substructure field name within the record
identified by record-name.
afname Is the name of a typed data item within a structure
declaration.
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 --- Numeric variable
INTARY(1) --- Numeric array element
REC.INTFLD --- Numeric field
REC.INTFLDARY(1) --- Numeric element of an array field
CHARVAR(5:10) --- Substring expression of a character variable
REC.CHARFLD(5:10) --- Substring expression of a character field
Note: A scalar memory reference is the same as a scalar reference,
excluding constants, character substrings, and expressions.
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
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 (Alpha only) - 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) - like 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
o BYTE - equivalent to INTEGER*1
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.
Real and complex numbers are floating-point representations. COMPLEX (COMPLEX*8) data is eight contiguous bytes aligned on an arbitrary byte boundary. The low-order four bytes contain REAL (REAL*4) data that represents the real part of the complex number. The high-order four bytes contain REAL data that represents the imaginary part of the complex number. For information on the ranges of REAL data, see REAL (within the Data Constants section of Help). DOUBLE COMPLEX (COMPLEX*16) data is 16 contiguous bytes aligned on an arbitrary byte boundary. The low-order bytes contain DOUBLE PRECISION (REAL*8) data that represents the real part of the complex number. The high-order eight bytes contain DOUBLE PRECISION data that represents the imaginary part of the complex data. For information on the ranges of DOUBLE PRECISION data, see DOUBLE_PRECISION (within the Data Constants section of Help).
The integer data types have the following ranges:
BYTE Same range as 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*8 Signed integers: -9223372036854775808 to
(Alpha only) 9223372036854775807 (-2**63 to 2**63-1)
(8 bytes)
NOTE: On Alpha processors, the value of an
integer constant must be within this range.
INTEGER*2, INTEGER*4, and INTEGER*8 values are stored in two's
complement form.
Note that logical data type ranges correspond to their comparable
integer data type ranges. For example, the LOGICAL*2 range is the
same as the INTEGER*2 range.
The value of an integer constant is normally INTEGER*2, INTEGER*4,
or INTEGER*8 (Alpha only). If a value is within INTEGER*2 range,
it is treated as an INTEGER*2 value; if a value is outside
INTEGER*2 range, but within INTEGER*4 range, it is treated as an
INTEGER*4 value, and so forth.
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.
When a logical value is stored in memory, all of its bits are
stored. For example, consider the following:
LOGICAL*4 L1, L2, L3
L1 = L2 .AND. L3
This example does a full 32-bit AND of L2 and L3, and stores all 32
resulting bits in L1.
Real and complex numbers are floating-point representations. The exponent for REAL (REAL*4) (S_floating) and DOUBLE PRECISION (REAL*8) (T_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. For 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 (REAL*4) (S_floating) numbers occupy four contiguous bytes and the precision is approximately one part in 2**23, that is, typically 7 decimal digits. DOUBLE PRECISION (REAL*8) (T_floating) numbers occupy eight contiguous bytes and the precision is approximately one part in 2**55, that is, typically 16 decimal digits. On Alpha systems, REAL*16 (H_floating) numbers occupy sixteen contiguous bytes and the precision is approximately 2**112, that is, typically 33 decimal digits. For more information on real data type ranges, see DATA CONSTANTS REAL and DATA CONSTANTS DOUBLE_PRECISION in this online Help file.
A variable is represented by a symbolic name which 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.
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 (REAL*4) variables.
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 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 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 (*n). For character
entities, the length specifier can be *len or *(*).
clist An initial value or values to be assigned to the
immediately preceding variable or array element.
Compiler diagnostic messages have the following format:
fort: severity: file-line:message_text
fort Identifies the source as the Digital Fortran 77
compiler
severity Possibilities: fatal, severe, error, warning, or
informational
file-line Indicates the source file and line number in the
source file
message_text Explains the event that caused the message
Must be corrected before the program can be compiled. Compilation
stops at the point where the fatal error is encountered. An object
file is not produced (linking does not occur).
The fatal messages follow (in alphabetical order):
o MESSAGE: 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.
o MESSAGE: Aggregate reference where scalar reference required
EXPLANATION: An aggregate reference was used where a scalar
reference was required.
o MESSAGE: Alternate return label used in invalid context
EXPLANATION: An alternate return argument cannot be used in a
function reference.
o MESSAGE: 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. The following
example shows a FUNCTION declaration that contains an asterisk:
INTEGER FUNCTION TCB(ARG,*,X)
The following example shows a RETURN statement in a function
subprogram that specifies an alternate return.
FUNCTION IMAX
.
.
.
RETURN I
o MESSAGE: Arithmetic expression where character value required
EXPLANATION: An expression that must be of type CHARACTER was
of another data type.
o MESSAGE: Assumed size array name used in invalid context
EXPLANATION: An assumed-size array name was used in a context
in which the size of the array was required, for example, in an
I/O list.
o MESSAGE: Automatic class variable not permitted here
EXPLANATION: Specified automatic variable cannot be used in
this context.
o MESSAGE: Case expression value used previously
EXPLANATION: More than one CASE statement has used the logical
value .TRUE. or .FALSE. in a SELECT CASE construct. For
example:
LOGICAL L
SELECT CASE (L)
CASE (.TRUE.)
J=3
CASE (.TRUE.)
K=7
ENDSELECT
o MESSAGE: CASE or ENDSELECT statement must follow SELECT CASE
statement
EXPLANATION: A statement other than a CASE statement (or END
SELECT or INCLUDE) directly follows a SELECT CASE statement.
This usually means that a CASE statement is missing. For
example:
SELECT CASE (I)
J=5
CASE (6)
J=6
END SELECT
o MESSAGE: CASE value/range overlaps previous CASE value/range
EXPLANATION: The value, or range of values, in this CASE
statement overlaps a previous value, or range of values, within
the set of CASE statements belonging to the current SELECT CASE
construct. The program must be modified so that the values do
not overlap. For example:
SELECT CASE (I)
CASE (0:20)
X=3.0
CASE (15:30)
Y=5.0
END SELECT
The two ranges (0:20) and (15:30) must be modified so they do
not overlap.
o MESSAGE: Character expression where arithmetic value required
EXPLANATION: An expression that must be arithmetic (INTEGER,
REAL, LOGICAL, or COMPLEX) was of type CHARACTER.
o MESSAGE: Character substring limits out of order
EXPLANATION: The first character position of a substring
expression was greater than the last character position. For
example:
C(5:3)
o MESSAGE: Conflicting values for xxx
EXPLANATION: Command line error. For example:
$ f77 -convert vaxg -convert ibm x.f
Only one -convert value may be specified.
o MESSAGE: Compiler expression stack overflow
EXPLANATION: An expression was too complex or too many actual
arguments were included 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.
o MESSAGE: Construct names must match on DO and ENDDO statements
EXPLANATION: Either there is a missing construct name, or the
construct names do not agree for matching DO and ENDDO
statements. Several examples:
FOO: DO I=1,10
...
ENDDO BAR ! BAR does not match FOO
DO J=1,20 ! There is no construct name to match
... ! UNMATCHED (on the ENDDO)
ENDDO UNMATCHED
EXTRA: DO K=1,30
...
ENDDO ! There is no construct name to match EXTRA
o MESSAGE: DO or IF statement incorrectly nested
EXPLANATION: One of the following conditions was encountered:
- A statement label specified in a DO statement was used
previously. For example:
10 I = I + 1
J = J + 1
DO 10 K=1,10
- A DO loop contains an incomplete DO loop or IF block.
For example:
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:
DO 10 I=1,10
J = J + I
IF (J .GT. 20) THEN J = J - 1
ELSE J = J + 1
10 CONTINUE
END IF
o MESSAGE: DO and IF statements nested too deeply
EXPLANATION: DO loops and block IF statements cannot be nested
beyond 128 levels.
o MESSAGE: 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.
o MESSAGE: 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.
o MESSAGE: ENTRY dummy variable previously used in executable
statement
EXPLANATION: The dummy arguments of an ENTRY statement were
not used in a previous executable statement in the same program
unit.
o MESSAGE: EQUIVALENCE statement incorrectly expands a common
block
EXPLANATION: An EQUIVALENCE statement cannot cause a common
block to be extended back past the first element specified in
the COMMON statement.
o MESSAGE: Error limit exceeded; compilation terminated
EXPLANATION: The number of error-level and fatal-error errors
has reached the limit given in -error_limit nn (or the default
of 30 errors). Recompile with a larger -error_limit value or
correct the errors displayed up to the point of termination and
then recompile.
o MESSAGE: EXIT or CYCLE statement must be within the scope of
some DO loop
EXPLANATION: A simple CYCLE or EXIT statement occurred outside
the scope of any DO loop. Since these statements are used to
increment or exit the nearest enclosing DO loop, this is an
error.
o MESSAGE: Fatal BE error
EXPLANATION: Internal error related to error code passing
between the compiler front end and back end. Submit an SPR.
o MESSAGE: Field name not defined for this structure
EXPLANATION: A field name not defined in a structure was used
in a qualified reference.
o MESSAGE: Format specifier in error
EXPLANATION: The format specifier in an I/O statement was
invalid. It must be one of the following:
- Label of a FORMAT statement
- Asterisk (*) in a list-directed I/O statement
- Run-time format specifier: variable, array element,
or character substring reference
- Integer variable that was assigned a FORMAT label
by an ASSIGN statement
o MESSAGE: INCLUDE files nested too deeply
EXPLANATION: A maximum of 10 levels of nested INCLUDE files
are allowed.
o MESSAGE: 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 COMPLEX*16
Group 2: COMPLEX*16
Group 3: Character
Example:
CHARACTER*15 FUNCTION I
REAL*4 G
ENTRY G
o MESSAGE: Inconsistent use of statement label
EXPLANATION: Labels of executable statements were confused
with labels of FORMAT statements or with labels of
nonexecutable statements. For example:
GO TO 10
10 FORMAT (I5)
o MESSAGE: Incorrect keyword in OPEN, CLOSE, or INQUIRE
statement
EXPLANATION: An OPEN, CLOSE, or INQUIRE statement contained a
keyword that was not valid for that statement.
o MESSAGE: Incorrect length modifier in declaration
EXPLANATION: An unacceptable length was specified in a data
type declaration. For example:
INTEGER PIPES*8
o MESSAGE: Internal error, xxxxxxxxxxx
EXPLANATION: Internal error. The xxxxxxxxx is replaced by
information about the error. Submit an SPR.
o MESSAGE: Invalid argument to %VAL, %REF or %LOC
EXPLANATION: The argument specified for one of the built-in
functions was not valid. For example:
%VAL (3.5D0) - Error: Argument cannot be REAL*8,
character, or complex.
%LOC (X+Y) - Error: Argument must not be an expression.
o MESSAGE: Invalid ASSIGN variable
EXPLANATION: Attempted to use an ASSIGN variable in an invalid
context, such as trying to assign a value to a pointer
variable. For example:
POINTER (P,A)
ASSIGN 1 TO P
GOTO P
o MESSAGE: Invalid control structure using CASE or END SELECT
EXPLANATION: A CASE statement or an ENDSELECT statement
occurred without an initial SELECT CASE statement, or was used
in some other incomplete context that makes it invalid. For
example:
SELECT CASE (J)
CASE (5)
K=2
IF (I.GT.0) THEN
ENDSELECT
ELSE
CASE (6)
K=3
ENDSELECT
o MESSAGE: Invalid control structure using ELSE IF, ELSE, or END
IF
EXPLANATION: The order of ELSE IF, ELSE, or END IF statements
was 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. For example:
DO 10 I=1,10
J = J + I
ELSE IF (J .LE. K) THEN
Error: The ELSE IF is preceded by a DO statement
IF (J .LT. K) THEN J = I + J
ELSE
J = I - J
ELSE IF (J .EQ. K) THEN
END IF
Error: The ELSE IF is preceded by an ELSE statement
o MESSAGE: 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.
o MESSAGE: Invalid equivalence of two variables in common
EXPLANATION: Variables in common blocks cannot be equivalenced
to each other.
o MESSAGE: 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.
o MESSAGE: Invalid I/O specification for this type of I/O
statement
EXPLANATION: A syntax error was found in the portion of an I/O
statement that precedes the I/O list. For example:
TYPE (6), J
WRITE 100, J
o MESSAGE: 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.
o MESSAGE: Invalid NAMELIST element
EXPLANATION: A dummy argument or element other than variable
or array name appeared in a NAMELIST declaration.
o MESSAGE: 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. For example:
DATA (A(SIN(REAL(I))), I=1,10) /101./
o MESSAGE: 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.
For 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.
o MESSAGE: Invalid use of function name in CALL statement
EXPLANATION: A CALL statement referred to a subprogram name
that was used as a CHARACTER or COMPLEX*16 function. For
example:
IMPLICIT CHARACTER*10(C)
CSCAL = CFUNC(X)
CALL CFUNC(X)
o MESSAGE: Invalid use of record or array name
EXPLANATION: A statement in the program violated one of the
following rules:
- An aggregate cannot be assigned to a nonaggregate or to
an aggregate with a structure that is not the same.
- An array name reference cannot be qualified.
- Aggregate references cannot be used in I/O lists of
formatted I/O statements.
o MESSAGE: 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.
o MESSAGE: 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.
o MESSAGE: Low bound exceeds high bound in CASE range
EXPLANATION: The INTEGER or CHARACTER CASE statement contains
a range where the lower bound is greater than the upper bound.
For example:
CASE (30:20)
CASE ('OMEGA':'ALPHA')
o MESSAGE: Missing constant
EXPLANATION: A required constant was not found.
o MESSAGE: Missing keyword
EXPLANATION: A required keyword, such as TO, was omitted from
a statement such as ASSIGN 10 TO I.
o MESSAGE: 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. For example:
CIRCUM = 3.14 DIAM ! * is missing
IF (I 10,20,30 ! ) is missing
o MESSAGE: 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.
o MESSAGE: Missing statement label
EXPLANATION: A required statement label reference was omitted.
o MESSAGE: Missing variable or constant
EXPLANATION: An expression or a term of an expression was
omitted. For example:
WRITE ( )
DIST = *TIME
o MESSAGE: Missing variable or subprogram name
EXPLANATION: A required variable name or subprogram name was
not found.
o MESSAGE: 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.
o MESSAGE: Multiple use of DEFAULT CASE statement
EXPLANATION: There is more than one CASE DEFAULT statement in
this SELECT CASE construct. For example:
SELECT CASE (I)
CASE DEFAULT
J=4
CASE (5)
K=5
CASE DEFAULT
L=6
END SELECT
o MESSAGE: Multiply defined field name
EXPLANATION: Each field name within the same level of a given
structure declaration must be unique.
o MESSAGE: Multiply defined STRUCTURE name
EXPLANATION: A STRUCTURE name must be unique among STRUCTURE
names.
o MESSAGE: 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.
o MESSAGE: No digits in octal (or hex) notation integer constant
EXPLANATION: An incorrectly formed octal or hex constant has
been detected, possibly because the user intended -novms to use
" as a character constant delimiter instead of an octal
constant delimiter. The constant should be corrected or the
proper switch used.
o MESSAGE: No enclosing DO loop begins with this construct name
EXPLANATION: There is a construct name used in either a CYCLE
or EXIT statement that does not appear on a DO statement for
any enclosing loop. In particular, if there are no loops at
all, the error will be generated for:
CYCLE FOO
EXIT BAR
o MESSAGE: Nonconstant subscript where constant required
EXPLANATION: Subscript and substring expressions used in DATA
and EQUIVALENCE statements must be constants.
o MESSAGE: Non-integer expression where integer value required
EXPLANATION: An expression that must be of type integer was of
some other data type.
o MESSAGE: Non-logical expression where logical value required
EXPLANATION: An expression that must have a LOGICAL data type
has another data type.
o MESSAGE: No source file specified
EXPLANATION: A command line was entered that specified only
library file names and no source files to compile.
o MESSAGE: Number of subscripts does not match array declaration
EXPLANATION: Too many or too few dimensions than were declared
for the array were referenced.
o MESSAGE: Only one of: xxx, xxx, xxx may be specified
EXPLANATION: Command line error. For example:
$ f77 -call_shared -non_shared x.f
Only one of the following options can be used at a time:
-call_shared, -non_shared, or -shared.
o MESSAGE: Open failure on INCLUDE file
EXPLANATION: The specified file could not be opened, possibly
due to an incorrect file specification, nonexistent file,
unmounted volume, or a protection violation.
o MESSAGE: Operation not permissible on these data types
EXPLANATION: An invalid operation was specified, such as an
.AND. of two real variables.
o MESSAGE: 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.
o MESSAGE: 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.
o MESSAGE: Range not allowed for CASE of type logical
EXPLANATION: In a CASE statement of type logical, the user has
specified a "range" of values. A range is valid only in a CASE
statement of type INTEGER or CHARACTER. For example:
LOGICAL L
SELECT CASE (L)
CASE (.TRUE.:.FALSE.)
I=15
ENDSELECT
Possibly the program intended CASE (.TRUE.,.FALSE) instead.
o MESSAGE: Requested source is not available on ULTRIX
EXPLANATION: The program attempted to use one of the following
VAX FORTRAN I/O features that are not available on ULTRIX or
Digital UNIX systems, such as using the DICTIONARY statement or
using an INCLUDE statement for a text module from a library
file.
o MESSAGE: 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.
o MESSAGE: Statement not allowed within structure; structure
definition closed
EXPLANATION: A statement not allowed in a structure
declaration block was encountered. When this situation occurs,
the compiler assumes that you omitted one or more END STRUCTURE
statements.
o MESSAGE: Statement too complex
EXPLANATION: A statement was too complex to be compiled. It
must be subdivided into two or more statements.
o MESSAGE: 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.
o MESSAGE: 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.
o MESSAGE: STRUCTUREs/UNIONs/MAPs nested too deeply
EXPLANATION: The combined nesting level limit for structures,
unions, and maps is 20 levels.
o MESSAGE: Subqualifier not allowed with negated qualifier
EXPLANATION: A negated qualifier specified on the command line
also specified subqualifier values; for example: -nocheck
underflow.
o MESSAGE: Subscripted reference to non-array variable
EXPLANATION: A variable that is not defined as an array cannot
appear with subscripts.
o MESSAGE: Syntax error in implied-DO
EXPLANATION: Improper syntax was detected in an implied-DO
list in data initialization, for instance, improperly nested
parentheses.
o MESSAGE: Syntax error in INCLUDE file specification
EXPLANATION: The file-name string was not acceptable (invalid
syntax, invalid qualifier, undefined device, and so on).
o MESSAGE: Syntax error in I/O list
EXPLANATION: Improper syntax was detected in an I/O list.
o MESSAGE: This language feature is not supported on this system
EXPLANATION: Attempted to use an unsupported feature. Such
features may be supported by Digital Fortran 77 but are not
available on this platform (for example, the %DESCR built-in
function). See your user manual for information about Digital
Fortran 77 compatibility.
o MESSAGE: Too many named common blocks
EXPLANATION: Digital Fortran 77 allows a maximum of 250 named
common blocks. You must reduce the number in your program.
o MESSAGE: Unclosed DO loop, IF block, or SELECT CASE
EXPLANATION: The terminal statement of a DO, IF, or SELECT
CASE statement was not found. For example:
DO 20 I=1,10
X = Y
END
o MESSAGE: Undefined statement label
EXPLANATION: A reference was made to a statement label that
was not defined in the program unit or a nonexecutable
statement label was used where an executable statement label
was required.
o MESSAGE: 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.
o MESSAGE: Unit specifier keyword missing in I/O statement
EXPLANATION: An I/O statement must include a unit specifier
subparameter.
o MESSAGE: Unrecognized statement
EXPLANATION: The statement encountered was not recognized as
valid.
o MESSAGE: Variable inconsistently equivalenced to itself
EXPLANATION: EQUIVALENCE statements specified inconsistent
relationships between variables or array elements. For
example:
EQUIVALENCE (A(1), A(2))
o MESSAGE: 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.
Must be corrected before the program can be compiled. An object
file is not produced (linking does not occur).
The severe messages follow (in alphabetical order):
o MESSAGE: Implied DO loop increment is 0
EXPLANATION: The value of the implied DO loop increment was
zero.
o MESSAGE: This DATA implied-DO list name must be subscripted
EXPLANATION: In a DATA statement, an implied DO loop referred
to a variable missing a subscript. For example:
INTEGER A(10)
DATA (A,I=3,5) /3*20/
The correct use for this example is DATA (A(I),I=3,5) /3*20/.
Must be corrected before the program can be compiled. An object
file is not produced (linking does not occur).
The error messages follow (in alphabetical order):
o MESSAGE: Adjustable array bound contains invalid data item
EXPLANATION: A dimension declarator expression for an
adjustable array contained an operand other than a constant,
variable in a common block, or variable associated with a
subprogram dummy argument.
o MESSAGE: Alternate return omitted in SUBROUTINE or ENTRY
statement
EXPLANATION: An asterisk was missing in the argument list of a
subroutine for which an alternate return was specified. For
example:
ENTRY ABC(Q,R)
.
.
.
RETURN 1
o MESSAGE: Arithmetic error while evaluating constant or
constant expression
EXPLANATION: The specified value of a constant was too large
or too small to be represented.
o MESSAGE: Character name incorrectly initialized with numeric
value
EXPLANATION: A character data item with a length greater than
one was initialized with a numeric value in a DATA statement.
For example:
CHARACTER*4 A
DATA A/14/
o MESSAGE: Character scalar memory reference or array required
for internal files
EXPLANATION: Attempted use of internal file I/O using a type
of variable that is not valid. For more information, see your
user manual.
o MESSAGE: Constant in format item out of range
EXPLANATION: A numeric value in a FORMAT statement exceeds the
allowable range. See the language reference manual for
information about range limits.
o MESSAGE: Declaration of globally visible name conflicts with a
previous declaration
EXPLANATION: The name specified in a PROGRAM, BLOCK DATA,
COMMON, ENTRY, FUNCTION, or SUBROUTINE statement has already
been used. For instance, a COMMON block has the same name as
an external routine.
o MESSAGE: ENDDO cannot close both labeled (line !UL) and
unlabeled (line !UL) DO statements.
EXPLANATION: A labeled ENDDO statement was found that ended
both a labeled and an unlabeled DO statement. This is
corrected by inserting a separate ENDDO statement before the
labeled ENDDO to close the innermost unlabeled DO statement.
For example, consider the following:
DO 100 I=1, 10
DO J=1, 20
IARRAY(J,I) = 0
100 ENDDO
......^
%FORT-E-INVENDDO, ENDDO cannot close both labeled (line 1) and
unlabeled (line 2) DO statements.
END
The code can be corrected as follows:
DO 100 I=1, 10
DO J=1, 20
IARRAY(J,I) = 0
ENDDO
100 ENDDO
END
o MESSAGE: ENTRY within DO loop or IF block
EXPLANATION: An ENTRY statement is not allowed within the
range of a DO loop or IF block.
o MESSAGE: 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.
o MESSAGE: Extra number in format list
EXPLANATION: A format list contained an extraneous number.
For example:
FORMAT (I4,3)
o MESSAGE: Feedback file does not match current program, in
routine !AD
EXPLANATION: The information in the feedback file cannot be
correlated with the current program. Confirm that the same
compiler options were passed with this compilation as were
passed for the -gen_feedback compilation. Also confirm that
the program and any included files have not changed.
o MESSAGE: Feedback file not found !AD
EXPLANATION: Either no feedback file was named or it cannot be
found. Confirm that the syntax of the f77 command was correct.
Also confirm that the correct file was passed.
o MESSAGE: Format groups nested too deeply
EXPLANATION: Format groups cannot be nested beyond eight
levels.
o MESSAGE: Format item cannot be signed
EXPLANATION: A signed constant is valid only with the P format
code.
o MESSAGE: Format item contains meaningless character
EXPLANATION: An invalid character or a syntax error was
detected in a FORMAT statement.
o MESSAGE: Global offset table is full for module !AD. Object
file not created.
EXPLANATION: The number of address constants in the module
exceeded a system threshold. For more information, see the
Digital UNIX Assembly Language Guide.
o MESSAGE: 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.
o MESSAGE: Intrinsic function !AD not allowed in !AD
EXPLANATION: The IARGCOUNT and IARGPTR intrinsic functions are
not allowed in the MAIN program and BLOCK DATA. The IARGPTR
function is also not allowed in statement functions.
o MESSAGE: Invalid ASSOCIATEVARIABLE specification
EXPLANATION: An ASSOCIATEVARIABLE specification in an OPEN or
DEFINE FILE statement was a dummy argument or an array element.
o MESSAGE: Invalid character after a backslash
EXPLANATION: In a character literal, the character specified
after the backslash (\) was not one of the allowable characters
(such as \n for new line) used to produce a nonprinting
character. For information on the allowable characters for
C-style escape sequences, see the language reference manual.
o MESSAGE: Invalid character used in constant
EXPLANATION: An invalid character was detected in a constant.
Only the characters 0-9, A-F, and a-f are valid for hexadecimal
constants. The entire hexadecimal constant is set to zero.
o MESSAGE: Invalid format for feedback file
EXPLANATION: The file passed as a feedback file did not have
the expected format. Confirm that the correct file was passed.
Try recreating the file using the steps discussed in the f77(1)
reference page.
o MESSAGE: 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 is
encountered, the count is ignored.
o MESSAGE: Invalid use of intrinsic function name as actual
argument
EXPLANATION: A generic intrinsic function name was used as an
actual argument.
o MESSAGE: I/O list not permitted with namelist I/O
EXPLANATION: An I/O statement with a namelist specifier
incorrectly contained an I/O list.
o MESSAGE: Missing apostrophe in character constant
EXPLANATION: A character constant must be enclosed in
apostrophes.
o MESSAGE: 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.
o MESSAGE: Missing number in format list
EXPLANATION: An expected number was missing from a format
list. For example:
FORMAT (F6.)
o MESSAGE: Missing separator between format items
EXPLANATION: A required separator character was omitted
between fields in a FORMAT statement.
o MESSAGE: 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.
o MESSAGE: More than 7 dimensions specified
EXPLANATION: An array can be defined as having up to seven
dimensions.
o MESSAGE: Multiple definition of statement label
EXPLANATION: The same label appeared on more than one
statement. When this error is encountered, the first
occurrence of the label is used.
o MESSAGE: Nonstandard operation
EXPLANATION: One of the following operations was detected:
- Logical operand and a nonlogical operand were used
in the same operation.
- Real type expression and a complex type expression
were used in the same statement.
- Character operand and a noncharacter operand were
used in the same operation.
- Nonlogical expression was assigned to a logical
variable.
- Noncharacter expression was assigned to a character
variable.
- Character dummy argument appeared in a concatenation
operation and the result of the expression was not
assigned to a character variable.
- Logical operators were used with nonlogical operands.
- Arithmetic operators were used with nonnumeric operands.
o MESSAGE: 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.
o MESSAGE: Preprocessor record: error opening specified file
EXPLANATION: Internal information from cpp is not in the
correct format. This could be caused by a pound sign (#)
character in column 1 of the Fortran source code that is not a
cpp directive or internal information from cpp.
o MESSAGE: Preprocessor record file spec misspelled
EXPLANATION: Internal information from cpp is not in the
correct format, possibly caused by a pound sign (#) character
in column 1 of the Fortran source code that is not a cpp
directive or internal information from cpp.
o MESSAGE: Preprocessor record line number not integer
EXPLANATION: Internal information from cpp is not in the
correct format, possibly caused by a pound sign (#) character
in column 1 of the Fortran source code that is not a cpp
directive or internal information from cpp.
o MESSAGE: Preprocessor record missing file spec
EXPLANATION: Internal information from cpp is not in the
correct format, possibly caused by a pound sign (#) character
in column 1 of the Fortran source code that is not a cpp
directive or internal information from cpp.
o MESSAGE: Preprocessor record missing line number
EXPLANATION: Internal information from cpp is not in the
correct format, possibly caused by a pound sign (#) character
in column 1 of the Fortran source code that is not a cpp
directive or internal information from cpp.
o MESSAGE: Recursive routine defined; recursive option required
EXPLANATION: An ENTRY point was defined that had been previous
called within the function or subroutine. This is only allowed
when the recursive option is used. For example:
INTEGER FUNCTION IFUNC (I)
IFUNC = IFUNCA(I-1)
RETURN
ENTRY IFUNCA (I) ! This line causes the error
IFUNCA = I * 100
RETURN
END
o MESSAGE: Recursive routine referenced; recursive option
required
EXPLANATION: The function or entry was referenced recursively.
This is only allowed when the recursive option is used. For
example:
INTEGER FUNCTION FACT (N)
IF(N .EQ. 1) THEN
FACT = N
RETURN
ENDIF
FACT = N*FACT(N-1) ! This line causes the error
RETURN
o MESSAGE: Statement not allowed within structure definition
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.
o MESSAGE: Statement not valid in this program unit
EXPLANATION: A program unit contained a statement that is not
allowed; for example, a BLOCK DATA subprogram containing an
executable statement.
o MESSAGE: Statement out of order
EXPLANATION: The order of statements was invalid. When this
error is encountered, the statement found to be out of order is
ignored.
o MESSAGE: Subscript or substring expression value out of bounds
EXPLANATION: An array element beyond the specified dimensions
or a character substring outside the specified bounds was
referenced.
o MESSAGE: Substring reference used in invalid context
EXPLANATION: A substring reference to a variable or array that
is not of type character was detected. For example:
REAL X(10)
Y = X(J:K)
o MESSAGE: Syntax error in IMPLICIT statement
EXPLANATION: Improper syntax was used in an IMPLICIT
statement.
o MESSAGE: Too many continuation lines
EXPLANATION: You cannot use more than 99 continuation lines.
o MESSAGE: Unbalanced parentheses in format list
EXPLANATION: The number of right parentheses must match the
number of left parentheses.
o MESSAGE: Undimensioned array reference or scalar is
subscripted
EXPLANATION: The variable appearing in a DATA statement or
namelist has not been dimensioned, yet appears with a
subscript.
o MESSAGE: Unknown keyword value
EXPLANATION: The specified keyword value is not valid. For
more information, see the language reference manual.
o MESSAGE: 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. For example:
DO 10 I = 1.10
The apparent DO statement is really an assignment to the
accidentally created variable DO10I.
o MESSAGE: %VAL or %REF used in invalid context
EXPLANATION: The argument list built-in functions %VAL and
%REF cannot be used outside an actual argument list. For
example:
X = %REF(Y)
o MESSAGE: Variable cannot be reinitialized (xxxx)
EXPLANATION: Attempted to initialize a variable more than
once, such as in a DATA statement.
o MESSAGE: Zero-length string
EXPLANATION: The length specified for a character or Hollerith
constant must not be zero.
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.
Warning messages are produced unless you specify the -w or -nowarn
option on the f77 command line.
The warning messages follow (in alphabetical order):
o MESSAGE: Actual argument data type (actual_type) not equal to
routine's dummy argument type (dummy_type)
EXPLANATION: A mismatch was detected between an actual
parameter type and the dummy type in the called routine. This
may be caused by a programming error which needs to be
corrected. For example:
CALL FOO ( 1.5 )
...
SUBROUTINE FOO ( X )
DOUBLE PRECISION X
Since the 1.5 is a REAL number (not DOUBLE PRECISION), this can
result in a variety of problems, depending upon the passing
mechanism of the system. In this case the "1.5" should be
changed to "1.5D0".
o MESSAGE: Alignment of common block is inconsistent with
previous declaration
EXPLANATION: Occurs when using CDEC$ OPTIONS/ALIGN if same
COMMON is declared in multiple pieces within a single
compilation unit and /ALIGN has changed between pieces. 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
END
o MESSAGE: Argument data type error, not equal to the routine's
dummy argument type
EXPLANATION: A mismatch was detected between an actual
parameter type and the dummy type in the called routine. This
can be caused by a programming error which needs to be
corrected.
o MESSAGE: Error limit exceeded; compilation terminated
EXPLANATION: The number of error-level and fatal-error errors
has reached the limit given in -errorlimit nn (or the default
of 30 errors). Recompile with a larger -errorlimit value or
correct the errors displayed up to the point of termination and
then recompile.
o MESSAGE: Alignment of variable or array is inconsistent with
its data type
EXPLANATION: Scalar or array data cannot be naturally aligned
when alignment had been requested (-align xxxx) option),
possibly because of an EQUIVALENCE statement. See your user
manual for alignment information.
o MESSAGE: 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 is encountered, the function is assumed to be
supplied by you as an EXTERNAL function.
o MESSAGE: Assignment to DO variable within loop
EXPLANATION: The control variable of a DO loop was altered
within the range of a DO statement.
o MESSAGE: CDEC$ OPTIONS directives nested too deeply - this one
ignored
EXPLANATION: CDEC$ OPTIONS directives cannot be nested beyond
100 levels.
o MESSAGE: Constant size exceeds variable size in data
initialization
EXPLANATION: A constant used for data initialization was
larger than its corresponding variable.
o MESSAGE: Count of Hollerith constant too large, reduced
EXPLANATION: The value specified by the integer preceding the
H was greater than the number of characters remaining in the
source statement.
o MESSAGE: EQUIVALENCE may not be used to put a SAVE variable
into COMMON
EXPLANATION: You cannot use an EQUIVALENCE statement to put
variables declared with the SAVE statement into a COMMON data
block. For example:
common/c1/ a,b,c
dimension x(3)
save x
equivalence (x(1),a)
end
In this case, the SAVE statement is ignored.
o MESSAGE: Expression does not contribute to result
EXPLANATION: Part of a concatenated character string
expression is beyond the number of characters required to
completely fill the assignment. In the following example, TEST
will not be used:
CHARACTER NEW, OLD, TEST
NEW(1:10) = OLD(1:10)//TEST
o MESSAGE: Extra characters in source line were truncated
EXPLANATION: The compiler read a source line with a statement
field that exceeds the maximum column width. The compiler
truncates such lines at column 72 or 132, depending on the
value of -extend_source or the OPTIONS statement option in
effect.
o MESSAGE: Extra comma in format list
EXPLANATION: A format list contained an extra comma. For
example:
FORMAT (I4,)
o MESSAGE: Inconsistent declaration for an AUTOMATIC variable
EXPLANATION: Data declared as automatic (AUTOMATIC statement
or -automatic option) can not be made equivalent to another
variable using a EQUIVALENCE statement, nor can it be
initialized using a DATA statement or any data declaration
statement (such as REAL or INTEGER statement that gives it a
value).
o MESSAGE: Invalid END= keyword, ignored
EXPLANATION: The END keyword was used illegally in a WRITE or
direct access READ statement.
o MESSAGE: 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.
o MESSAGE: Invalid statement label ignored
EXPLANATION: An improperly formed statement label (namely, a
label containing letters) was detected in columns 1 to 5 of an
initial line. When this error is encountered, the statement
label is ignored.
o MESSAGE: Length specified must match CHARACTER FUNCTION
declaration
EXPLANATION: The length specifications for all ENTRY names in
a character function subprogram must be the same. For example:
CHARACTER*15 FUNCTION F
CHARACTER*20 G
ENTRY G
o MESSAGE: Letter mentioned twice in IMPLICIT statement, last
type used
EXPLANATION: A letter was given an implicit data type more
than once. When this error is encountered, the last data type
given is used.
o MESSAGE: 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.
o MESSAGE: Missing END statement, END is assumed
EXPLANATION: An END statement was missing at the end of the
last input file. When this error is encountered, an END
statement is inserted.
o MESSAGE: 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 is encountered, the
first type declaration is used.
o MESSAGE: Name longer than 31 characters
EXPLANATION: A symbolic name cannot exceed 31 characters.
When this error is encountered, the symbolic name is truncated
to 31 characters.
o MESSAGE: Name used in INTRINSIC statement is not an intrinsic
function
EXPLANATION: A function name that appeared in the INTRINSIC
statement was not an intrinsic function.
o MESSAGE: No matching CDEC$ END OPTIONS for CDEC$ OPTIONS
EXPLANATION: A CDEC$ OPTIONS directive must be terminated by
CDEC$ END OPTIONS.
o MESSAGE: No matching CDEC$ OPTIONS for CDEC$ END OPTIONS
EXPLANATION: A CDEC$ END OPTIONS directive terminates a CDEC$
OPTIONS section.
o MESSAGE: Non-blank characters truncated in string constant
EXPLANATION: A character or Hollerith constant was converted
to a data type that was not large enough to contain all of the
significant characters.
o MESSAGE: Non-zero digits truncated in hex constant
EXPLANATION: A hexadecimal constant was converted to a data
type that was not large enough to contain all the significant
digits.
o MESSAGE: No value
EXPLANATION: A value returned by a function is undefined.
o MESSAGE: 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.
o MESSAGE: 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.
o MESSAGE: Pointer and integer declarations conflict, using
pointer declaration
EXPLANATION: If a pointer variable is also declared to be an
integer of specific size (for example, INTEGER*4), and if a
pointer requires a different size on this platform (for
example, INTEGER*8 on Digital UNIX on Alpha systems), the
required pointer size is used instead of the integer size.
This may affect COMMON sizes and equivalenced variables.
o MESSAGE: Program may contain only one main entry routine
EXPLANATION: Two or more main program units were found,
possibly caused by missing FUNCTION or SUBROUTINE statements.
o MESSAGE: Record contains one or more misaligned fields
EXPLANATION: One or more fields are not naturally aligned in a
RECORD structure because the -vms or -align norecords option
was specified (causing Digital Fortran 77 to pack records
instead of naturally aligning them).
o MESSAGE: Record too long - record truncated
EXPLANATION: Source file line exceeded the maximum line
length.
o MESSAGE: Redundant continuation mark ignored
EXPLANATION: A continuation mark was detected where an initial
line is required. When this error is encountered, the
continuation mark is ignored.
o MESSAGE: Statement cannot terminate a DO loop
EXPLANATION: The terminal statement of a DO loop cannot be a
GO TO, arithmetic IF, RETURN, block IF, ELSE, ELSE IF, END IF,
DO, or END statement.
o MESSAGE: String constant truncated to maximum length
EXPLANATION: A character or Hollerith constant can contain up
to 2000 characters.
o MESSAGE: String too long - truncated to 31 characters
EXPLANATION: A character constant specified in a CDEC$ TITLE,
CDEC$ SUBTITLE, or CDEC$ IDENT directive exceeded 31
characters. The truncated character value will be used.
o MESSAGE: This feature is unsupported on ULTRIX
EXPLANATION: The program attempted to use a VAX FORTRAN I/O
feature that is not available on ULTRIX or Digital UNIX
systems. If the resulting program is run on either system,
this construct will be ignored. See your user manual for
information on VAX FORTRAN compatibility.
o MESSAGE: This intrinsic routine name is not supported on this
system, assumed EXTERNAL
EXPLANATION: The specified intrinsic name is not known and is
assumed to be EXTERNAL.
o MESSAGE: Unexpected Hollerith constant in integer context,
integer value will be used
EXPLANATION: A Hollerith constant was specified in a context
where an integer value was expected.
o MESSAGE: Use of implicit with declaration warnings
EXPLANATION: An IMPLICIT statement was used in a program
compiled with the -warn declarations option.
o MESSAGE: Value for xxx out of range, defaulting to xxx
EXPLANATION: Command line error. For example:
$ f77 -O15 x.f
The range of values allowed for -O is 0-4. 15 is out of range.
The default value of 4 is used instead.
o MESSAGE: Variable is used before its value has been defined
EXPLANATION: The specified variable has not been assigned a
value before it is used in an assignment or similar statement.
You can disable this message by compiling with -warn
nouninitialized.
o MESSAGE: Volatile access appears unaligned, but must be
aligned at run-time
EXPLANATION: The compiler found a usage of a volatile data
item that is an unaligned reference. This kind of volatile
unaligned access may cause an unrecoverable alignment fault or
incorrect results. For example:
common /b/ c, s, l
character c
integer*2 s
integer*4 l
volatile s, l
l=2
The store to l is unaligned. The fix is to change the data
layout so that l is aligned properly.
Not an error message and does not call for corrective action.
However, the informational message informs you that either a
correct Digital Fortran 77 statement may have unexpected results or
you have used a Digital Fortran 77 extension to FORTRAN-77.
The informational messages follow (in alphabetical order):
o MESSAGE: Character or Hollerith constant continued across
lines; may be non-portable
EXPLANATION: If you need long character strings that don't fit
conveniently on a single line, use the concatenate operator
(//) to do it in a portable manner. For example:
A = 'ABC' //
x 'DEF'
o MESSAGE: Default STATUS='UNKNOWN' used in OPEN statement
EXPLANATION: The OPEN statement default STATUS='UNKNOWN' may
cause an old file to be inadvertently modified.
o MESSAGE: Do loop increment is 0
EXPLANATION: The value of the DO loop increment was zero.
o MESSAGE: Duplicate IDENT ignored
EXPLANATION: Two or more CDEC$ IDENT directives were used in a
source module to specify the identification field of the object
module. The first CDEC$ IDENT directive is used.
o MESSAGE: Extension to FORTRAN-77: arithmetic expression
required
EXPLANATION: A logical expression was used in an arithmetic IF
statement.
o MESSAGE: Extension to FORTRAN-77: CHARACTER*(*) argument used
as function
EXPLANATION: A formal argument used as a function was declared
as CHARACTER*(*). The FORTRAN-77 standard requires the length
to be an integer constant.
o MESSAGE: Extension to FORTRAN-77: Character required
EXPLANATION: A character variable was initialized with a
noncharacter value by means of a DATA statement.
o MESSAGE: Extension to FORTRAN-77: COMMON block has same name
as PARAMETER constant
EXPLANATION: A COMMON block was declared to have the same name
as a PARAMETER constant, or a PARAMETER constant was declared
to have the same name as a previously declared COMMON block.
o MESSAGE: Extension to FORTRAN-77: Concatenation of dummy
argument
EXPLANATION: A character dummy argument appeared as an operand
in a concatenation operation.
o MESSAGE: Extension to FORTRAN-77: DATA statement out of order
EXPLANATION: A DATA statement occurred prior to a declaration
statement. All DATA statements must occur after the
declaration section of a program.
o MESSAGE: Extension to FORTRAN-77: Function or Entry name
undefined
EXPLANATION: A value was not assigned to either the function
name or the entry point name within the body of the function.
o MESSAGE: Extension to FORTRAN-77: Integer expression required
EXPLANATION: One of the following items was not of type
integer:
- Logical unit number
- Record specifier, REC=recspec
- Arithmetic expression of a computed GOTO statement
- RETURN [I]
- Subscript expression
- Array dimension bounds
- Character substring bounds expressions
o MESSAGE: Extension to FORTRAN-77: Logical expression required
EXPLANATION: One of the following syntax extensions was
detected:
- Numeric expression in a logical IF statement
- Numeric expression in a block IF statement
- Value other than .TRUE. or .FALSE. assigned to a
logical variable
- Logical variable initialized with a nonlogical value
by means of a DATA statement
o MESSAGE: Extension to FORTRAN-77: Missing array subscripts
EXPLANATION: Only one subscript was used to reference a
multidimensional array in an EQUIVALENCE statement.
o MESSAGE: Extension to FORTRAN-77: Mixed numeric and character
elements in COMMON
EXPLANATION: A common block must not contain both numeric and
character data.
o MESSAGE: 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.
o MESSAGE: Extension to FORTRAN-77: More than 19 continuation
lines
EXPLANATION: More than 19 continuation lines were defined for
the statement.
o MESSAGE: Extension to FORTRAN-77: Negative implied-DO
iteration count
EXPLANATION: The iteration count of an implied DO was
negative.
o MESSAGE: Extension to FORTRAN-77: Nonstandard array bound
EXPLANATION: An error was found in a DIMENSION statement
during standards syntax checking (-stand syntax). One of the
bounds of the variable being dimensioned contains something
that is not allowed by the standard. For example:
subroutine foo (a,jjj)
dimension jjj(10,10)
dimension a(jjj(2,3), jjj(5,6))
The bounds for a (jjj(2,3) and jjj(5,6)) are array references,
and these are not allowed by the standard.
o MESSAGE: Extension to FORTRAN-77: Nonstandard branch into
block
EXPLANATION: A nonstandard branch into a DO loop or IF block
was detected.
o MESSAGE: Extension to FORTRAN-77: nonstandard list directed
internal I/O
EXPLANATION: A nonstandard list-directed internal read or
write statement was used.
o MESSAGE: 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.
o MESSAGE: Extension to FORTRAN-77: nonstandard constant
EXPLANATION: The following constant forms are extensions to
FORTRAN-77:
Form Example
---- -------
Hollerith nH.....
Typeless 'xxxx'X or 'oooo'O
Hexadecimal Zxxxx
Complex with
PARAMETER components
COMPLEX*16 (www.xxxDn, yyy.zzzDn)
o MESSAGE: Extension to FORTRAN-77: nonstandard continuation
character
EXPLANATION: A nonstandard character was used as a
continuation indicator.
o MESSAGE: 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)
LOGICAL*4 LOGICAL
INTEGER*1 --
INTEGER*2 INTEGER (with -noi4 specified)
INTEGER*4 INTEGER
REAL*4 REAL
REAL*8 DOUBLE PRECISION
COMPLEX*8 COMPLEX
COMPLEX*16 --
DOUBLE COMPLEX --
o MESSAGE: Extension to FORTRAN-77: Nonstandard DATA
initialization
EXPLANATION: An element was initialized in either of the
following ways:
- In a blank common block
- Outside the BLOCK DATA structure (and the element
is in a named COMMON block)
o MESSAGE: Extension to FORTRAN-77: nonstandard FORMAT
statement item
EXPLANATION: The following format field descriptors are
extensions to FORTRAN-77:
Descriptor Aspect
---------- ------
$ All forms
A,L,I,F,E,G,D Default field width forms
P Without scale factor
o MESSAGE: Extension to FORTRAN-77: Nonstandard function return
type
EXPLANATION: A function or entry point was declared with a
nonstandard data type.
o MESSAGE: Extension to FORTRAN-77: nonstandard intrinsic
function
EXPLANATION: A nonstandard intrinsic function was used.
o MESSAGE: Extension to FORTRAN-77: nonstandard keyword
EXPLANATION: A nonstandard keyword was used.
o MESSAGE: Extension to FORTRAN-77: nonstandard lexical item
EXPLANATION: One of the following nonstandard lexical items
was used:
- Alternate return specifier with an ampersand (&)
in a CALL statement
- Apostrophe (') form of record specifier in a direct
access I/O statement
- Variable format expression
o MESSAGE: 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.
o MESSAGE: Extension to FORTRAN-77: nonstandard name
EXPLANATION: A name longer than six characters or one that
contained a dollar sign ($) or an underscore (_) was used.
o MESSAGE: Extension to FORTRAN-77: nonstandard operator
EXPLANATION: The operators .XOR., %VAL, %REF, 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.
o MESSAGE: Extension to FORTRAN-77: nonstandard sharing of
ENDDO terminator.
EXPLANATION: ENDDO is an extension to FORTRAN-77, although it
is standard in Fortran 90. The Fortran 90 standard does not
include ENDDO as a valid action-statement for terminating
multiple nested DO-loops. It should also be noted that Fortran
90 considers shared DO termination obsolescent.
Consider the following:
DO 100 I=1,10
DO 100 J=1,20
IARRAY(J,I) = 0
100 ENDDO
......^
%FORT-I-EXT_ENDDO, Extension to FORTRAN-77: nonstandard sharing of
ENDDO terminator.
END
The code can be corrected as follows:
DO I=1,10
DO J=1,20
IARRAY(J,I) = 0
ENDDO
ENDDO
END
o MESSAGE: Extension to FORTRAN-77: nonstandard statement type
EXPLANATION: A nonstandard statement type was used.
o MESSAGE: Extension to FORTRAN-77: nonstandard syntax
EXPLANATION: One of the following syntax extensions was
specified:
PARAMETER name = value --> Error: No parentheses
type name/value/ --> Error: Data initialization in
type declaration
DATA (ch(exp1:exp2),i=lb,ub,inc)/values/)
--> Error:Substring initialization with
implied-DO in DATA statement
CALL name(arg2,,arg3) --> Error: Null actual argument
READ (...),iolist --> Error: Comma between I/O control
and element lists
PARAMETER (name2=ABS(name1)) --> Error: Function use in
PARAMETER statement
e1 ** -e2 --> Error: Two consecutive operators
o MESSAGE: Extension to FORTRAN-77: Nonstandard use of array
EXPLANATION: One of the following extensions was detected:
- An array was used as a FILE specification in an
OPEN statement.
- The file name of an INQUIRE statement was a numeric
scalar reference or a numeric array name reference.
o MESSAGE: 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.
o MESSAGE: 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
-stand syntax.
o MESSAGE: Extension to FORTRAN-77: nonstandard use of
intrinsic!/!function as actual argument
EXPLANATION: The FORTRAN 77 standard does not allow the use of
type conversion (INTEGER, REAL, etc.), lexical relationship
(LGE, LGT, etc.) or minimum and maximum functions (MIN, MAX,
etc.) as actual arguments.
o MESSAGE: 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).
o MESSAGE: Extension to FORTRAN-77: tab indentation or
lowercase source
EXPLANATION: The use of tab indentation or lowercase letters
in source code is an extension to FORTRAN-77.
o MESSAGE: Invalid qualifier or qualifier value in OPTIONS
statement
EXPLANATION: An invalid qualifier or qualifier value was
specified in the OPTIONS statement. When this error is
encountered, the qualifier is ignored.
o MESSAGE: Missing CASE statement in SELECT CASE construct
EXPLANATION: There are no CASE statements between a SELECT
CASE and its ENDSELECT statement. While this is legal, it is
usually a mistake in the program.
o MESSAGE: No path to this statement
EXPLANATION: Program control could not reach this statement.
When this situation occurs, the statement is deleted. For
example:
10 I = I + 1
GO TO 10
STOP
You can disable this message by compiling with -warn
nounreachable.
o MESSAGE: Not yet implemented
EXPLANATION: The specified feature has not been implemented.
o MESSAGE: Routine xxx does not return a value
EXPLANATION: A subroutine which doesn't return a value was
used where a value is expected. For example:
T = SUB(J)
...
SUBROUTINE SUB(I)
o MESSAGE: Statement function xxx is never called
EXPLANATION: A statement function (named xxx) was declared but
never used. This could be caused by a missing DIMENSION
statement that caused a variable assignment to be interpreted
as a statement function.
You can disable this message by compiling with -warn
nouncalled.
o MESSAGE: Unrecognized directive ignored
EXPLANATION: A directive was detected in the first five
columns of a source code statement. The directive was not
recognized or the remainder of the directive contains illegal
syntax.
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 the Digital Fortran 77 I/O system, 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.
Run-Time diagnostic messages have the following format:
forrtl: severity: message_text
forrtl: Identifies the source as the Digital Fortran
Run-Time Library
severity: Possibilities: severe, error, warning, or
informational
message_text: Explains the event that caused the message
Must be corrected. The program's execution is terminated when the
error is encountered, unless for I/O statements the program uses
the END or ERR I/O statement specifiers to transfer control,
perhaps to a routine that uses the IOSTAT specifier (see your user
manual).
The severe messages follow (in alphabetical order):
o MESSAGE: Adjustable array dimension error
NUMBER: 93
EXPLANATION: Upon entry to a subprogram, one of the following
errors was detected during the evaluation of dimensioning
information:
- An upper-dimension bound was less than a
lower-dimension bound.
- The dimensions implied an array that was larger
than addressable memory.
o MESSAGE: Attempt to access non-existent record
NUMBER: 36
EXPLANATION: A direct-access READ or FIND statement attempted
to access beyond the end of a relative file (or a sequential
file on disk with fixed-length records) or access a record that
was previously deleted in a relative file.
o Array index out of bounds (SIGTRAP)
NUMBER: 138
EXPLANATION: Break exception generated a SIGTRAP signal
(described in signal(3)). Core dump file created.
The cause is an array subscript that is outside the dimensioned
boundaries of that array. Try recompiling using the -check
bounds option (perhaps with the f77_dump_flag environment
variable set) or examine the core dump file to determine the
source code in error.
o MESSAGE: Array index out of bounds for index n (SIGTRAP)
NUMBER: 139
EXPLANATION: Break exception generated a SIGTRAP signal
(described in signal(3)). Core dump file created.
The cause is an array subscript that is outside the dimensioned
boundaries of the array index n. Try recompiling using the
-check bounds option (perhaps with the f77_dump_flag
environment variable set) or examine the core dump file to
determine the source code in error.
o MESSAGE: BACKSPACE error
NUMBER: 23
EXPLANATION: An error condition was detected during execution
of a BACKSPACE statement.
o MESSAGE: Cannot overwrite existing file
NUMBER: 10
EXPLANATION: Specified file xxx already existed when OPEN
statement specified STATUS='NEW' (create new file) using I/O
unit x. Make sure correct file name, directory path, unit, and
so forth were specified in the source program. Decide whether
to:
- Rename or remove the existing file before rerunning
the program.
- Modify the source file to specify different file
specification, I/O unit, or OPEN file STATUS.
o MESSAGE: Cannot stat file
NUMBER: 108
EXPLANATION: Attempted stat operation on the indicated file
failed. Make sure correct file and unit were specified.
o MESSAGE: CLOSE error
NUMBER: 28
EXPLANATION: An error condition was detected by the Digital
Fortran RTL I/O system during execution of a CLOSE statement.
o MESSAGE: DELETE error
NUMBER: 55
EXPLANATION: An error condition was detected by the Digital
Fortran RTL I/O system during execution of a DELETE statement.
o MESSAGE: Divide by zero check (SIGTRAP)
NUMBER: 137
EXPLANATION: Break exception generated a SIGTRAP signal
(described in signal(3)). Core dump file created.
Examine core dump file for possible cause.
o MESSAGE: Duplicate file specifications
NUMBER: 21
EXPLANATION: Multiple attempts were made to specify file
attributes without an intervening close operation. For
example, a DEFINE FILE statement was followed by another DEFINE
FILE statement or an OPEN statement.
o MESSAGE: ENDFILE error
NUMBER: 33
EXPLANATION: One of the following conditions occurred:
- The file was not a sequential organization file with
variable-length records.
- The file was not opened for sequential or append access.
- An unformatted file did not contain segmented records.
- The Digital Fortran RTL I/O system detected an error during
execution of an ENDFILE statement.
o MESSAGE: End-of-file during read
NUMBER: 24
EXPLANATION: One of the following conditions occurred:
- A Digital Fortran RTL I/O system end-of-file condition
was encountered during execution of a READ statement
that did not contain an END, ERR, or IOSTAT specification.
- 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.
- 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.
o MESSAGE: Error during read
NUMBER: 39
EXPLANATION: The Digital Fortran RTL I/O system detected an
error condition during execution of a READ statement.
o MESSAGE: Error during write
NUMBER: 38
EXPLANATION: The Digital Fortran RTL I/O system detected an
error condition during execution of a WRITE statement.
o MESSAGE: File name specification error
NUMBER: 43
EXPLANATION: The file name was specified erroneously.
o MESSAGE: File not found
NUMBER: 29
EXPLANATION: A file with the specified name could not be found
during an open operation.
o MESSAGE: FIND error
NUMBER: 57
EXPLANATION: The Digital Fortran RTL I/O system detected an
error condition during execution of a FIND statement.
o MESSAGE: Floating inexact
NUMBER: 140
EXPLANATION: A floating-point arithmetic or conversion
operation gave a result that differs from the mathematically
exact result. This trap is reported if the rounded result of
an IEEE operation is not exact.
o MESSAGE: Floating overflow in math library
NUMBER: 88
EXPLANATION: A floating-point overflow condition was detected
during execution of a math library procedure.
o MESSAGE: Floating underflow in math library
NUMBER: 89
EXPLANATION: A floating-point underflow condition was detected
during execution of a math library procedure. The result
returned was zero.
o MESSAGE: Format/variable-type mismatch
NUMBER: 61
EXPLANATION: An attempt was made either to read or write a
real variable with an integer field descriptor (I, L, B, O, or
Z), or to read or write an integer or logical variable with a
real field descriptor (D, E, F, or G).
o MESSAGE: Formatted I/O to unit open for unformatted transfers
NUMBER: 257
EXPLANATION: Attempted formatted I/O (such as list-directed or
namelist I/O) to a unit where the OPEN statement indicated the
file was unformatted (FORM keyword). Check that the correct
unit (file) was specified.
If the FORM keyword was not specified in the OPEN statement and
the file should contain formatted data, specify
FORM='FORMATTED' in the OPEN statement. Otherwise, if
appropriate, use unformatted I/O.
o MESSAGE: Inconsistent file organization
NUMBER: 51
EXPLANATION: The file organization specified in an OPEN
statement did not match the organization of the existing file.
o MESSAGE: Inconsistent OPEN/CLOSE parameters
NUMBER: 46
EXPLANATION: Specifications in an OPEN or CLOSE statement were
inconsistent. Some invalid combinations follow:
- READONLY with STATUS='NEW' or STATUS='SCRATCH'
- ACCESS='APPEND' with READONLY, STATUS='NEW' or
STATUS='SCRATCH'
- DISPOSE='SAVE', 'PRINT', or 'SUBMIT' with
STATUS='SCRATCH'
- DISPOSE='DELETE' with READONLY
o MESSAGE: Inconsistent record length
NUMBER: 37
EXPLANATION: One of the following conditions occurred:
o An attempt was made to create a new relative 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.
o An attempt was made to write to a relative or direct access
file that was not correctly created or opened.
o MESSAGE: Inconsistent record type
NUMBER: 44
EXPLANATION: The RECORDTYPE value in an OPEN statement did not
match the record type attribute of the existing file that was
opened.
o MESSAGE: Infinite format loop
NUMBER: 60
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.
o MESSAGE: Input conversion error
NUMBER: 64
EXPLANATION: During a formatted input operation, 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.
o MESSAGE: Input record too long
NUMBER: 22
EXPLANATION: A record was read that exceeded the explicit or
default record length specified when the file was opened. To
read the file, use an OPEN statement with a RECL value (record
length) of the appropriate size. The RECL unit is bytes for
formatted files and longwords for unformatted files.
o MESSAGE: Input statement requires too much data
NUMBER: 67
EXPLANATION: An unformatted READ statement attempted to read
more data than existed in the record being read.
o MESSAGE: Insufficient virtual memory
NUMBER: 41
EXPLANATION: The Digital Fortran RTL attempted to exceed its
available virtual memory while dynamically allocating space.
To overcome this problem, increase the per-process data limit
by using the limit (C shell) or ulimit (Bourne and Korn shell)
commands before you run this program again (see your user
manual).
Determine whether the maximum per-process data size is already
allocated by checking the value of the maxdsiz parameter in the
system configuration or sysconfigtab file. If necessary,
increase its value. Changes do not take effect until the
system has been rebooted. (You do not need to rebuild the
kernel if you modify sysconfigtab.)
For more information about system configuration parameters, see
the "Digital UNIX System Tuning and Performance Management"
guide.
Before you try to run this program again, wait until the new
system resources take effect.
o MESSAGE: Integer overflow
NUMBER: 70
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. Consider specifying
a larger integer data size. (Modify the source program or, for
an INTEGER declaration, possibly use the f77 flag -integer_size
nn).
For ranges of the various integer data types, see your user
manual.
o MESSAGE: Integer divide by zero
NUMBER: 71
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 1.
o MESSAGE: Internal consistency check failure
NUMBER: 8
EXPLANATION: Internal error. Please check that the program is
correct. Recompile if an error exists in the program.
If this error persists, submit an SPR.
o MESSAGE: Invalid argument to Fortran Run-Time Library
NUMBER: 48
EXPLANATION: The compiler passed an invalid or improperly
coded argument to the Digital Fortran RTL. This can occur if
the compiler is newer than the RTL in use.
o MESSAGE: Invalid argument to math library
NUMBER: 81
EXPLANATION: One of the mathematical procedures detected an
invalid argument value.
o MESSAGE: Invalid logical unit number
NUMBER: 32
EXPLANATION: A logical unit number greater than 2,147,483,647
or less than zero was used in an I/O statement.
o MESSAGE: Invalid reference to variable in NAMELIST input
NUMBER: 19
EXPLANATION: One of the following conditions occurred:
- The variable was not a member of the namelist group.
- An attempt was made to subscript a scalar variable.
- A subscript of the array variable was out-of-bounds.
- An array variable was specified with too many or too
few subscripts for the variable.
- An attempt was made to specify a substring of a non-
character variable or array name.
- A substring specifier of the character variable was
out-of-bounds.
- A subscript or substring specifier of the variable was
not an integer constant.
- An attempt was made to specify a substring using an
unsubscripted array variable.
o MESSAGE: Kernel breakpoint (SIGTRAP)
NUMBER: 131
EXPLANATION: Break exception generated a SIGTRAP signal
(described in signal(3)). Core dump file created.
Examine core dump for possible cause.
o MESSAGE: Keyword value error in OPEN statement
NUMBER: 45
EXPLANATION: An improper value was specified for an OPEN or
CLOSE statement keyword requiring a value.
o MESSAGE: List-directed I/O syntax error
NUMBER: 59
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.
o MESSAGE: Logarithm of zero or negative value
NUMBER: 83
EXPLANATION: An attempt was made to take the logarithm of zero
or a negative number. The result returned was the reserved
operand, -0.
o MESSAGE: Mixed file access modes
NUMBER: 31
EXPLANATION: An attempt was made to use any of the following
combinations:
- Formatted and unformatted operations on the same unit
- An invalid combination of access modes on a unit,
such as direct and sequential
- A Digital Fortran RTL I/O statement on a logical unit that
was opened by a program coded in another language
o MESSAGE: No current record
NUMBER: 53
EXPLANATION: An attempt was made to REWRITE a record when the
current record was undefined. To define the current record,
execute a successful READ statement. You can optionally
perform an INQUIRE statement on the logical unit after the READ
statement and before the REWRITE statement. No other
operations on the logical unit can be performed between the
READ and REWRITE statements.
o MESSAGE: No such device
NUMBER: 42
EXPLANATION: A pathname included an invalid or unknown device
name when an OPEN operation was attempted.
o MESSAGE: Not a Fortran-specific error
NUMBER: 1
EXPLANATION: An error occurred in the user program or in the
RTL that was not a Digital Fortran 77-specific error and was
not reportable through any other Digital Fortran run-time
messages.
o MESSAGE: Not taken branch delay emulation (SIGTRAP)
NUMBER: 134
EXPLANATION: Break exception generated a SIGTRAP signal
(described in signal(3)). Core dump file created.
Examine core dump for possible cause.
o MESSAGE: OPEN or DEFINE FILE required
NUMBER: 26
EXPLANATION: A direct access READ, WRITE, or FIND, statement
was attempted for a file when no DEFINE FILE or OPEN statement
with ACCESS='DIRECT' was performed for that file.
o MESSAGE: Open failure
NUMBER: 30
EXPLANATION: An error was detected by the Digital Fortran RTL
I/O system while attempting to open a file in an OPEN, INQUIRE,
or other I/O statement. This message is issued when the error
condition is not one of the more common conditions for which
specific error messages are provided. It can occur if an OPEN
operation is attempted for one of the following files:
- A segmented file that was not on a disk or a raw
magnetic tape.
- A standard I/O file that had been closed.
o MESSAGE: Operation requires seek ability
NUMBER: 120
EXPLANATION: Attempted an operation on a file that requires
the ability to perform seeks on that file. Make sure the
correct unit, directory path, and file were specified.
o MESSAGE: Output statement overflows record
NUMBER: 66
EXPLANATION: An output statement attempted to transfer more
data than would fit in the maximum record size.
o MESSAGE: Overflow check (SIGTRAP)
NUMBER: 136
EXPLANATION: Break exception generated a SIGTRAP signal
(described in signal(3)). Core dump file created.
The cause is an integer overflow. Try recompiling using the
-check overflow option (perhaps with the f77_dump_flag
environment variable set) or examine the core dump file to
determine the source code in error.
o MESSAGE: Pathname error
NUMBER: 43
EXPLANATION: A pathname (or file name) given to an OPEN or
INQUIRE statement was not acceptable to the Digital Fortran RTL
I/O system.
o MESSAGE: Permission to access file denied, unit x, file xxx
NUMBER: 9
EXPLANATION: Check the mode (protection) of the specified
file. Make sure the correct file was being accessed. Change
the protection, specified file, or process used before
rerunning program.
o MESSAGE: Range error
NUMBER: 150
EXPLANATION: An integer value appeared in a context where the
value of the integer is outside the permissible range.
o MESSAGE: Record number outside range
NUMBER: 25
EXPLANATION: A direct access READ, WRITE, or FIND statement
specified a record number outside the range specified when the
file was opened.
o MESSAGE: Recursive I/O operation
NUMBER: 40
EXPLANATION: While processing an I/O statement for a logical
unit, another I/O operation on the same logical unit was
attempted, such as 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 MESSAGE: REWIND error
NUMBER: 20
EXPLANATION: One of the following conditions occurred:
- The file was not a sequential file.
- The file was not opened for sequential or append access.
- The Digital Fortran RTL I/O system detected an error condition
during execution of a REWIND statement.
o MESSAGE: Segmented record format error
NUMBER: 35
EXPLANATION: An invalid segmented record control data word was
detected in an unformatted sequential file. The file was
probably either created with RECORDTYPE='FIXED' or 'VARIABLE'
in effect, or was created by a program written in a language
other than Fortran.
o MESSAGE: Significance lost in math library
NUMBER: 87
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.
o MESSAGE: Square root of negative value
NUMBER: 84
EXPLANATION: An argument required the evaluation of the square
root of a negative value. The result returned was the reserved
operand, -0.
o MESSAGE: String length error
NUMBER: 148
EXPLANATION: During a string operation, an integer value
appeared in a context where the value of the integer is outside
the permissible string length range. Try recompiling with the
-check bounds flag (perhaps with the f77_dump_flag environment
variable set) or examine the core file to determine the source
code causing the error.
o MESSAGE: Subscript out of range
NUMBER: 77
EXPLANATION: An array reference was detected outside the
declared array bounds.
o MESSAGE: Substring error
NUMBER: 149
EXPLANATION: An array subscript is outside the dimensioned
boundaries of an array. Try recompiling with the -check bounds
flag (perhaps with the f77_dump_flag environment variable set)
or examine the core file to determine the source code causing
the error.
o MESSAGE: Syntax error in format
NUMBER: 62
EXPLANATION: A syntax error was encountered while the RTL was
processing a format stored in an array or character variable.
o MESSAGE: Syntax error in NAMELIST input
NUMBER: 17
EXPLANATION: The syntax of input to a namelist READ statement
was incorrect.
o MESSAGE: Taken branch delay emulation (SIGTRAP)
NUMBER: 133
EXPLANATION: Break exception generated a SIGTRAP signal
(described in signal(3)). Core dump file created.
Examine core dump for possible cause.
o MESSAGE: Too many records in I/O statement
NUMBER: 27
EXPLANATION: An attempt was made to do one of the following:
- Read or write more than one record with an ENCODE
or DECODE statement.
- Write more records than existed.
o MESSAGE: Too many values for NAMELIST variable
NUMBER: 18
EXPLANATION: An attempt was made to assign too many values to
a variable during a namelist READ statement.
o MESSAGE: Undefined exponentiation
NUMBER: 82
EXPLANATION: An exponentiation that is mathematically
undefined was attempted, for example, 0.**0. The result
returned for floating-point operations was the reserved
operand, -0, and for integer operations, zero.
o MESSAGE: Unformatted I/O to unit open for formatted transfers
NUMBER: 256
EXPLANATION: Attempted unformatted I/O to a unit where the
OPEN statement indicated the file was formatted (FORM keyword).
Check that the correct unit (file) was specified.
If the FORM keyword was not specified in the OPEN statement and
the file should contain unformatted data, specify
FORM='UNFORMATTED' in the OPEN statement. Otherwise, if
appropriate, use formatted I/O (such as list-directed or
namelist I/O).
o MESSAGE: Unit already open
NUMBER: 34
EXPLANATION: A DEFINE FILE statement specified a logical unit
that was already opened.
o MESSAGE: User breakpoint (SIGTRAP)
NUMBER: 130
EXPLANATION: Break exception generated a SIGTRAP signal
(described in signal(3)). Core dump file created.
Examine core dump for possible cause.
o MESSAGE: User single step (SIGTRAP)
NUMBER: 135
EXPLANATION: Break exception generated a SIGTRAP signal
(described in signal(3)). Core dump file created.
Examine core dump for possible cause.
o MESSAGE: Variable format expression value error
NUMBER: 68
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 1 was
assumed, except for a P edit descriptor, for which a value of
zero was assumed.
o MESSAGE: Write to READONLY file
NUMBER: 47
EXPLANATION: A write operation was attempted to a file that
was declared READONLY in the OPEN statement that is currently
in effect.
o MESSAGE: Wrong number of arguments
NUMBER: 80
EXPLANATION: An improper number of arguments was used to call
a math library procedure.
Should be corrected. The program may continue execution, but the
output from this execution may be incorrect.
The error messages follow (in alphabetical order):
o MESSAGE: Floating divide by zero
NUMBER: 73
EXPLANATION: During a floating-point arithmetic operation, an
attempt was made to divide by zero.
o MESSAGE: Floating invalid
NUMBER: 65
EXPLANATION: During an arithmetic operation, the
floating-point values used in a calculation were invalid for
the type of operation requested, or invalid exceptional values.
For example, this occurs when requesting a log of the
floating-point values 0.0 or a negative number.
For certain arithmetic expressions, specifying the -check
nopower option can suppress this message. For information on
allowing exceptional IEEE values, see your user manual.
o MESSAGE: Floating overflow
NUMBER: 72
EXPLANATION: During an arithmetic operation, a floating-point
value exceeded the largest representable value for that data
type. For ranges of the various data types, see your user
manual.
o MESSAGE: Floating point exception
NUMBER: 75
EXPLANATION: A floating-point exception occurred. Core dump
file created. Possible causes include:
o Divide by zero
o Overflow
o An invalid operation, such as subtraction of infinite
values, multiplication of zero by infinity (without signs),
division of zero by zero or infinity by infinity
o Conversion of floating-point to fixed-point format when an
overflow prevents conversion
o MESSAGE: Floating underflow
NUMBER: 74
EXPLANATION: During an arithmetic operation, a floating-point
value became less than the smallest finite value for that data
type. On Alpha systems, the underflowed result is set to zero.
For ranges of the various data types, see the Data
Representation chapter in your user manual.
o MESSAGE: Fortran abort routine called
NUMBER: 266
EXPLANATION: The program called abort to terminate the
program.
o MESSAGE: IOT trap signal
NUMBER: 76
EXPLANATION: Core dump file created. Examine core dump for
possible cause of this IOT signal.
o MESSAGE: Output conversion error
NUMBER: 63
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 situation
is encountered, the field is filled with asterisks.
o MESSAGE: Process interrupted (SIGINT)
NUMBER: 69
EXPLANATION: The process received the signal SIGINT.
Determine source of this interrupt signal (described in
signal(3)).
o MESSAGE: Process killed (SIGTERM)
NUMBER: 78
EXPLANATION: The process received the signal SIGTERM.
Determine source of this software termination signal (described
in signal(3)).
o MESSAGE: Process quit (SIGQUIT)
NUMBER: 79
EXPLANATION: The process received the signal SIGQUIT. Core
dump file created. Determine source of this quit signal
(described in signal(3)).
Should be investigated. The program continues execution, but the
output from this execution may be incorrect.
The warning messages follow (in alphabetical order):
o MESSAGE: Could not open message catalog: formsg.cat
NUMBER: none
EXPLANATION: The Digital Fortran 77 message catalog file was
not found on this system. For more information, see your user
manual or installation guide.
For informational purposes only. Unless it accompanies another
message, the program continues.
The informational messages follow (in alphabetical order):
o MESSAGE: Check environment variable NLSPATH and protection of
path-name/for_msg.dat
NUMBER: none
EXPLANATION: The Digital Fortran 77 message catalog file was
not found on this system. For more information, see your user
manual or your installation guide.
o MESSAGE: Check location/protection of NLS and
/usr/lib/formsg.dat
NUMBER: none
EXPLANATION: The Digital Fortran 77 message file was not found
on this system. See your user manual for more information.
o MESSAGE: nn floating divide-by-zero traps
NUMBER: 299
EXPLANATION: The total number of floating-point divide-by-zero
traps encountered during program execution was nn. This
summary message appears at program completion.
o MESSAGE: nn floating invalid traps
NUMBER: 297
EXPLANATION: The total number of floating-point invalid data
traps encountered during program execution was nn. This
summary message appears at program completion.
o MESSAGE: nn floating overflow traps
NUMBER: 298
EXPLANATION: The total number of floating-point overflow traps
encountered during program execution was nn. This summary
message appears at program completion.
o MESSAGE: Floating-point conversion failed
NUMBER: 95
EXPLANATION: The attempted unformatted read or write of
non-native floating-point data failed. One of the following
conditions occurred for a non-native floating-point value:
o The value exceeded the allowable maximum value for the
equivalent native format and was set equal to infinity
(plus or minus).
o The value was infinity (plus or minus) and was set to
infinity (plus or minus).
o The value was invalid and set to Not-a-Number (NaN).
Make sure the correct file was specified. Make sure the record
layout matches the format Digital Fortran 77 is expecting.
Check that the correct non-native floating-point data format
was specified, as described in your user manual.
o MESSAGE: nn floating underflow traps
NUMBER: 300
EXPLANATION: The total number of floating-point underflow
traps encountered during program execution was nn. This
summary message appears at program completion.
o MESSAGE: Format syntax error at or near xx
NUMBER: 58
EXPLANATION: Check the statement containing xx, a character
substring from the format string, for a format syntax error.
For information about FORMAT statements, refer to the language
reference manual.
o MESSAGE: Fortran error message number is nnn
NUMBER: none
EXPLANATION: The Digital Fortran 77 message catalog file was
not found on this system. For information about the message
catalog file location, see your user manual or installation
guide.
o MESSAGE: Unit not connected
NUMBER: 11
EXPLANATION: The specified unit was not open at the time of
the attempted I/O operation. Check to see if the correct unit
number was specified. If appropriate, use an OPEN statement to
explicitly open the file (associates the file with the unit
number).
A FORMAT statement specifies the format in which data is to be transferred as well as the conversion (editing) required to achieve that format. FORMAT statements are nonexecutable statements used with formatted I/O statements and with ASSIGN, 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.
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
I,O,Z INTEGER*8(Alpha),LOGICAL*8(Alpha) 23
O,Z REAL*4 12
O,Z REAL*8 23
O,Z REAL*16 (Alpha) 44
O,Z CHARACTER*n MAX(7,3*n)
L LOGICAL*1,LOGICAL*2, 2
LOGICAL*4,LOGICAL*8(Alpha)
F,E,G,D REAL*4,COMPLEX*8 15 7 2
F,E,G,D REAL*8,COMPLEX*16 25 16 2
F,E,G,D REAL*16 (Alpha) 42 33 3
A LOGICAL*1 1
A LOGICAL*2,INTEGER*2 2
A LOGICAL*4,INTEGER*4 4
A LOGICAL*8(Alpha),INTEGER*8(Alpha) 8
A REAL*4,COMPLEX*8 8
A REAL*8,COMPLEX*16 8
A REAL*16 (Alpha) 16
A CHARACTER*n n
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.
The ranges for "r", "w", "m", "d", and "e" are as follows:
Term Range
---- __________
r 1 to 2147483647 (2**31-1)
w 1 to 2147483647
m 0 to 32767 (2**15-1)
d 0 to 32767
e 1 to 32767
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 2147483647 (2**31-1); actual useful ranges may be
constrained by record sizes (RECL) and the file system.
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.
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.
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.
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)
When the format is scanned, the preceding statement performs an I
(integer) 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.