Compaq KAP Fortran/OpenMP
for Tru64
UNIX
User Guide
Appendix F
Listing File Messages
KAP can generate a listing file. As the default, this file contains the
original program with notes concerning what KAP did with the program.
Other information can be selected with the
-listoptions
command-line switch. See Chapter 9 for examples of the available
information.
Source and transformed code listings include an Actions section noting
what KAP did do, or could not do, with each loop. The notations
indicate which class of message was issued for the marked statement.
Section F.1, Classes of Messages explains these classes.
The list of error and diagnostic messages in Section F.2, Messages is organized
by class, and within each class is sorted alphabetically.
These messages are written only to the listing file, and only when a
program listing is selected (by default, or explicitly with
-listoptions=o or =t
). In addition, syntax error and warning messages are written only as
part of the original (
-listoptions=o
) code listing. If syntax errors or warnings are found, a brief note
stating that syntax errors or warnings were found is written to the
error file.
The Loop Table requested with
-listoptions=l
has a status column with a short description of what KAP did with the
loop, or why it could not optimize it. Section 9.1.4, Loop Table (L) contains the
possible messages that can appear there, with a longer explanation of
each.
In addition to the messages written to the listing file, there is a
small number of messages that can appear in the error file. Most of
these are issued for conditions like command-line switch errors or
missing files, which prevent KAP from running at all. These messages
are brief and self-explanatory.
F.1 Classes of Messages
The following lists classes of messages:
- Data Dependence (DD) on a statement indicates it could not be
optimized because a data dependence involving the statement exists.
- Error (E) indicates a syntax error. These may include missing or
extra characters, illegal keywords, or text in the wrong column. If a
syntax error is encountered, KAP will not process the program unit, but
will pass it to the compilable output unchanged. The listing file will
indicate where the error is located. If a syntax error is encountered,
the program should be corrected and rerun.
- Extension (EX) indicates where a construct in the original program
is not allowed in the language KAP is producing. Some KAP products
accept one form of Fortran, and produce another form. In some cases, an
operation or type is allowed in the input language, but not in the
output language. The statements containing these constructs will be
marked as an extension.
- Informational (INF) points out where a condition exists that must
be brought to the programmer's attention. Unreachable statements are an
example.
- Inserted (I) indicates in the transformed listing where a
statement has been inserted. In several of the transformations,
statements must be inserted. These statements appear only in the
transformed code.
- Inlining/IPA (INL) The subroutine or function called on this line
was inlined or analyzed. If inlined, the CALL or reference has been
replaced with the text of the routine. If analyzed, information about
the routine is available for optimizing the code surrounding the CALL.
- Loop Reordering (LR) informs you that a Compaq Fortran statement
is modified in the process of interchanging loops. KAP looks at outer
loops in the process of optimizing a program. If an outer loop would be
more efficient if innermost, and it is legal to reorder the loops, KAP
will place the outer loop inside. In the process of doing this, KAP may
have to change loop bounds (for triangular loops) or distribute loops
or float IF assignments. These modifications are marked. Only the
statements modified to do the exchange will be marked, not all
statements in the exchanged loops.
- Miscellaneous (MIS) informs you that some KAP information has been
lost. This does not mean the program has not been transformed properly,
but that some messages generated in the process have been lost.
- Not Vectorized (NV) indicates that a statement was not vectorized
because it has no vector version (for instance, an assigned GOTO or an
I/O statement).
- Output Translation (OT) shows where constructs, which are valid in
the input language but are not allowed in the output language (if
different), were changed.
- Output Trans Fails (OTF) marks statements that have constructs
that exist in the input language but are not representable in the
output language (if different).
- Option Error (OW) tells you of a syntax error in a KAP directive
or assertion. This error does not cause processing of a program unit to
stop, but the directive or assertion is ignored. See Chapter 5 and
Chapter 6 for the proper syntax for directives and assertions.
- Program Too Large (NO) tells you either that the program unit
being processed is too large for KAP to optimize, or that the
subprogram structure is too complex to maintain a calling tree. This
class of message rarely appears.
- Question (Q) informs you that KAP attempted to optimize a loop
nest, and in the process came across a data dependence it could not
break at compile time without some knowledge not available to it. This
knowledge may be available to you, so KAP will generate a question in
the listing file. If you can answer the question by placing an
assertion (see Chapter 6) before the loop the question referred to
and rerunning the program, KAP may be able to optimize the loop.
It
should be noted that if the question is answered incorrectly, the
transformation that KAP performs will be invalid, and may give
incorrect answers.
- Scalar Optimization (SO) marks places in the transformed listing
where a scalar loop optimization, for example, loop unrolling, has been
performed.
- Standardized (STD) marks where a program has been changed to
improve the chances of finding optimizable code. The dusty-deck
transformations KAP performs use this notation. Examples of these are
IF...GOTO to block IF, loop rerolling, and IF loop to DO loop
conversion.
- Translator Error (TE) informs you of an internal KAP error. A
notification is written to the error message file and a traceback is
written to the listing file. The software vendor must be notified of
this class of error so a correction can be made. If the code that
causes the traceback can be sent along with the traceback, that will
aid diagnosis. (If the error can be reproduced in a small program unit,
that small program unit would be preferable to a large program.)
- Vector Enhanced (VE) informs you that transformations have been
applied to this statement to improve optimization. KAP performs several
transformations (such as forward substitution) intended to make the
program easier to optimize. These transformations are not themselves
major enhancements to the program, but allow other optimizations to
work more effectively.
- Warning (W) are errors that are correctable. KAP found an illegal
construct in the program, but the intent of the programmer is clear. If
a syntax warning is encountered, KAP will still process the program
unit. The listing file will indicate where the warning occurred.
F.2 Messages
In the following messages, the characters "#1" indicate where
a substitution will take place when the actual message is issued. For
instance, you may see the message: "The type "#1" cannot
appear here." If the type of the incorrect object is INTEGER, the
actual message will be "The type "INTEGER" cannot appear
here."
F.2.1 Data Dependence (DD)
Data dependence involving this line due to variable
"#1." An upwards data dependence arc results from
the way the variable is used. This may mean that the DO loop cannot be
optimized.
F.2.2 Error (E)
The following are error messages:
- Variable or array "#1" cannot be assigned an
expression of this type. The type of the expression cannot be
coerced to the type of the target variable or array.
- A .NOT. cannot be applied to an expression of type
"#1." The logical operator .NOT. cannot be applied
to expressions of the given type. Some Fortran dialects allow mixing of
logical and other types in expressions, others do not.
- A closing Parallel directive must be preceded by an opening
Parallel directive.
- All parameters to the indicated intrinsic function must
have the same shape (or be conformable).
- An arithmetic expression was expected but not
found.
- Arithmetic operations are not allowed between these types
of operands. The arithmetic operator at the position given
cannot be applied to the mentioned types.
- Array "#1" must be explicitly typed.
IMPLICIT NONE or UNDEFINED disables automatic typing. All variables
occurring within the scope of IMPLICIT NONE or UNDEFINED must be
explicitly typed.
- Array bound "#1" is neither a formal parameter
nor in a COMMON block. A symbol was used in a place where only
a formal parameter or a variable specified as being in a COMMON block
is allowed.
- Array declared and referenced with different number of
subscripts. The array reference has more or less subscripts
than the number of dimensions in the declaration of this variable.
- Array not declared or statement function declared after
executable statements. A statement function declaration must
appear before any executable statements.
- ASSIGN statement must include the word TO before the
integer variable name. The format of an ASSIGN statement is
ASSIGN s TO i, where s is a statement label and i is the name of a
scalar integer variable. The word TO is missing in this case.
- Assign variable "#1" was never assigned a
label. The label assign variable has never been assigned.
- Assigned GOTO variable "#1" is not a
scalar. The variable used to select a branch address must be a
scalar (not an array element).
- Assigned GOTO variable "#1" is not an
integer. The variable used to select a branch address must be
of type integer.
- ASSIGNed variable "#1" is not a scalar.
The variable used to store a statement label must be a scalar (not an
array element).
- ASSIGNed variable "#1" is not an
integer. The variable used to hold a statement label must be
of type integer.
- Assumed size arrays must specify the upper bound of the
assumed size dimension. Assumed size arrays may be used in
array assignments, but the upper bound of the assumed size dimension
must be specified.
- Asterisk (*) as a dimension bound was specified for an
invalid dimension. Asterisk may be specified in a dimension
bound only as the upper bound of the final dimension.
- At least one parameter is required to this intrinsic
function. At least one parameter must appear in the invocation
of this intrinsic function. Lookup the intrinsic function and code the
correct number of parameters.
- At least two MAP/ENDMAP statements must appear within a
UNION/ENDUNION. At least two map declaration constructs must
appear within any UNION/ENDUNION declaration.
- Bit constant is too long or contains characters that are
not 0 or 1. A bit constant may contain only the digits 0 or 1.
The specified constant contained one or more characters that were not 0
or 1.
- Bit operations are only valid on operands of type
bit. One or more of the operands found were not of type bit.
- Block IF or block WHERE has not been closed.
During label resolution (after examining the entire program), a block
construct has been discovered that has not been closed. The message is
attached to the block IF, ELSEIF, ELSE, block WHERE, or OTHERWISE that
begins the block that is not closed. Check the structure of the program
to determine where the error lies.
- Cannot associate entire equivalence group with the same
storage unit. An EQUIVALENCE statement must not specify that
the same storage unit is to occur more than once in a storage sequence,
or that consecutive storage units are to be nonconsecutive.
- Cannot reference format label here. The label used
in the format statement is a target of a branch statement.
- Character variable must have a length of one
character. The character entity must have a length of one
character if the entity is being initialized by a numeric constant.
- Closing > is missing from this format
expression. Expressions within a FORMAT must be enclosed by
angle brackets.
- Colon in this key specification is missing. Colon
separating first and last byte position is missing.
- Colon in this substring reference is missing.
Colon separating lower and upper bounds in a substring reference is
missing.
- Comma was expected here but not found. A comma was
expected in the indicated column, but another symbol was found instead.
- Comparisons are not allowed between these types of
operands. The comparison operator at position given cannot be
applied to the mentioned types.
- Compiler directive does not have correct syntax.
This line seems to have a !*kap* compiler directive on it, but it
contains a syntax error.
- Concatenation is valid only on character strings.
Concatenation can only be applied to character strings. One of the
operands in this concatenation is not a string.
- Constant must have a value in the range 0 through
255. The constant used to initialize a character entity must
have a value less than or equal to 255.
- Definition of the label "#1" is not unique. An
earlier definition exists. Each statement label must be unique
within a program unit. This statement has a label that has been defined
earlier.
- Dimension must be a constant. The dimension in
question must be a compile-time constant.
- DO loop ends on a nonexecutable statement. A DO
loop ends on a statement that is nonexecutable. Insert a CONTINUE or
renumber the DO.
- DO loop has not been closed. The end of a DO loop
has not been found within this program unit. Find the mismatched DO and
correct.
- DO loop is improperly nested. This DO loop does
not begin and end in the same block.
- DO-variable "#1" is not a scalar
variable. The format of the DO statement is DO [,] i = e1, e2
[,e3]. The i is the name of an integer, real, or
double-precision variable, called the DO-variable. In this statement,
i is the name of a nonscalar variable, such as an array. Check
your array names, or change the name of the DO-variable.
- DO-variable "#1" is not a variable. The
format of the DO statement is DO [,] i = e1, e2 [,e3]. The i
is the name of an integer, real, or double-precision variable, called
the DO-variable. In this statement, i is the name of an entity
that cannot be used as a variable. Check your SUBROUTINE and FUNCTION
names.
- DO-variable "#1" is not INTEGER, REAL or DOUBLE
PRECISION. The format of the DO statement is DO [,] i = e1, e2
[,e3]. The i is the name of an integer, real, or
double-precision variable, called the DO-variable. In this statement,
i is not INTEGER, REAL or DOUBLE PRECISION. Check your
specification statements or IMPLICIT statements, or change the name of
the DO-variable.
- DO-variable is being assigned within the DO loop.
The format of the DO statement is DO s [,] i = e1, e2 [,e3]. The
i is the name of an integer, real, or double-precision
variable, called the DO-variable. It is being assigned within this loop.
- Each DO-WHILE DO-loop must be terminated by a separate
ENDDO statement. A DO-WHILE loop must be terminated by a
unique ENDDO statement. The label on the DO-WHILE is optional, but if
it is specified, the terminating ENDDO must be labeled accordingly.
- Elements in named COMMON blocks must be initialized within
a block data subprogram. Entities in a named COMMON block must
be initialized only within a block data subprogram.
- Elements in unnamed COMMON blocks must not be initialized
by DATA statements. Variables and arrays that are contained in
unnamed COMMON blocks must not be initialized by data statements or by
type specification statements.
- ELSE IF statement must be followed by the keyword
THEN. The format of the ELSE IF statement is ELSE IF (e) THEN.
A statement other than "THEN" was found after the right
parenthesis.
- ELSE occurred with no matching Block IF. Every
ELSE statement must be lexically preceded by a Block IF statement that
has not been closed with an ENDIF. This ELSE is not preceded by an
"open" Block IF structure.
- ELSEIF occurred with no matching Block IF. Every
ELSEIF statement must be lexically preceded by a Block IF statement
that has not been closed with an ENDIF. This ELSEIF is not preceded by
an "open" Block IF structure.
- END MAP statement must be used inside a STRUCTURE
declaration block. The END MAP statement must be used inside a
STRUCTURE declaration block.
- End of this statement was encountered
unexpectedly. The end of this statement was encountered where
more characters were expected.
- END STRUCTURE statement found unexpectedly. The
END STRUCTURE statement was scanned during a parse state where KAP was
expecting another declaration type for the present structure
declaration block.
- END STRUCTURE statement must be preceded by a STRUCTURE
declaration. The END STRUCTURE statement must be preceded by a
STRUCTURE declaration statement.
- END UNION statement must be preceded by a UNION
statement. The END UNION statement was scanned during a parse
state where KAP was expecting another declaration type for the present
structure declaration block.
- END UNION statement must be used inside a STRUCTURE
declaration block.
- ENDDO occurred with no matching DO or DO-WHILE.
Every ENDDO statement must be lexically preceded by a DO or DO- WHILE.
If the DO or DO-WHILE statement specifies a label, the corresponding
ENDDO must have a matching label.
- ENDIF occurred with no matching Block IF. Every
ENDIF statement must be lexically preceded by a Block IF statement that
has not been closed with an ENDIF. This ENDIF is not preceded by an
"open" Block IF structure.
- ENTRY statement may appear only within a SUBROUTINE or a
FUNCTION. This compilation unit is a BLOCK DATA, PROGRAM, or
untyped (and hence a main program). The current statement is an ENTRY
statement, and an ENTRY statement can appear only inside compilation
units of type SUBROUTINE or FUNCTION.
- Equals sign is not at the expected column in this
assignment statement. The format of an assignment statement is
V=E. Either the specification of V was in error (there should be a
previous message for this statement), or the equals sign was missing
(or misplaced).
- Equivalence would cause leftward extension of a COMMON
block. Equivalence association must not cause a COMMON block
storage sequence to be extended by adding storage units preceding the
first storage unit of the first entity specified in a COMMON statement
for the COMMON block.
- Error in array reference. An illegal array
reference has been detected. A variable may not have been declared as
an array, or the array reference may be incorrectly constructed.
- Error in intrinsic function parameter. An
intrinsic function has been specified, but there is an error in one or
more of its parameters.
- Executable statement found inside a block data
subprogram. Executable statements are not allowed inside a
block data subprogram.
- Expected type name for this IMPLICIT statement is missing
or in error. The format of the IMPLICIT statement is IMPLICIT
typ (a [,a]...) [,typ(a[,a])]... "typ" must be a legal Compaq
Fortran type name (for example, INTEGER, REAL, LOGICAL, and so on). The
type name was either missing or was not one of the allowed names.
- Expression given in a RETURN statement is not scalar
arithmetic. The format of the RETURN statement is RETURN [e],
where e is a scalar arithmetic expression. The expression given in this
statement was not arithmetic type and shape scalar.
- Expression given in a RETURN statement is not scalar
integer. The format of the RETURN statement is RETURN [e],
where e is a scalar integer expression. The expression given in this
statement was not of type integer and shape scalar.
- Expression in a logical, block, or ELSE IF must be of type
logical. The expression tested by a logical or block IF or by
an ELSE IF statement must be of type logical. The expression given in
this statement evaluates to a different type.
- Expression in a subarray must be scalar. The
expression in a subarray specifier must have shape scalar.
- Expression in a subarray must have type integer.
- Expression in an arithmetic IF is not of an allowed
type. The expression in an arithmetic IF must be of type
integer, real, or double precision. The expression given in this
statement evaluates to a different type.
- Expression in this statement is too complicated for KAP to
handle. The expression in this statement is too complicated to
be parsed by KAP. This could be either because a function call has too
many parameters, or because an expression has too many operators and
operands, or a combination of the two.
- Expression or variable value of this I/O control element is
invalid. The expression or variable that is at the current
column is not well formed. The I/O control specifier in error is
somewhere to the left of the current column.
- Extended operator/operand is missing the last
period. An extended operator (like .LE.) or operand (like
.TRUE.) was coded, but the rightmost period was missing.
- Extra text encountered after this statement is
ignored. After this statement was parsed, more text was found
that was not recognizable as part of the statement, starting in the
given column.
- Field names cannot be defined more than once within a
STRUCTURE. A field name cannot be defined more than once
within a STRUCTURE declaration block.
- File already being included. An include directive
specifies a file that is already open as an include file. Recursive
includes are not allowed.
- FORALL index "#1" is not used in the assignment
part of this statement. All indices must be used in the array
reference on the left side of the forall assignment.
- Forall statement ends on a non-executable
statement. A forall statement has been improperly constructed.
- Form of record specification used is not valid
here. The apostrophe form of the record specification can only
come after a nonkeyword unit without a comma.
- Formal parameter cannot be in a SAVE statement. A
subroutine or function parameter cannot be an argument in a SAVE
statement.
- Formal parameter or allocatable array "#1" in
COMMON block. Formal parameters or allocatable array may not
be in a COMMON statement. The mentioned symbol is the name of a formal
parameter or allocatable array that appears in a COMMON statement.
- Formal parameter or allocatable array "#1" may
not be equivalenced. Formal parameters or allocatable array
may not be equivalenced. The mentioned symbol is the name of a formal
parameter or allocatable array that appears in an EQUIVALENCE statement.
- Format item is not repeatable. A format item
preceded by an integer was encountered. The ANSI standard specifies
that this particular item cannot be repeated.
- Format item requires a leading integer. The ANSI
standard requires that certain format items be preceded by an integer.
- Format specifier is not a statement label, asterisk, or
other legal form. The format specifier must be a statement
label, integer variable name, character array name, character
expression, or an asterisk. The format specifier to the left of the
current column is none of these.
- Function reference must include a parameter list.
A function call must include a parameter list. The list can be empty,
specified by "( )."
- FUNCTION/ENTRY name "#1" may not be
equivalenced. A variable name that is also a function name may
not be equivalenced. The mentioned symbol is the name of a FUNCTION
subprogram, or the name specified as an ENTRY name in a function
subprogram.
- Group name in this NAMELIST statement was previously
defined. The group name specified in this statement was used
previously.
- Hex constant contains characters that are not 0-9 or
A-F. A hex constant may contain only the digits
0,1,2,3,4,5,6,7,8,9 or the letters a,b,c,d,e,f (case does not matter).
The specified constant contained one or more characters that were not
0-9 or A-F.
- Hex constant too long. Only 32 digits are allowed.
A hex constant can only be 128 bits long. The specified constant
contained more than 32 digits.
- Hollerith with invalid length encountered.
Hollerith with an invalid length (<= 0) or longer than the number of
characters that are left in the statement was encountered.
- I/O control entry's operand is not a specific
type. The I/O control entry requires the operand to be a
specific type. It was not. The I/O control entry to the left of the
current column is in error. Each I/O control entry requires that its
operand be of a specific type (character, logical, or integer). The
type of the expression or variable that was the operand to this I/O
control entry does not match the required type.
- Identifier "#1" already used as name of
function. The symbolic name of an external function is a
global name and must not be the same as any other global or local name
except a variable name in the function subprogram.
- Identifier "#1" being ASSIGNed must be a variable
name. The identifier used to hold a statement label must be
the name of a variable.
- Identifier "#1" following GOTO in an assigned
goto must be a variable name. The identifier used to select a
branch address must be the name of a variable.
- Identifier "#1" in SAVE statement is not a
variable. The form of the SAVE statement is SAVE [a [, a]...],
where each a is a named COMMON block name preceded and followed by a
slash, a variable name, or an array name. The indicated identifier was
previously used in a context such that it may not also be a variable.
- Identifier "#1" is not the name of
subroutine.
- Identifier was expected here but not found. An
identifier was expected in the indicated column, but another symbol was
found instead.
- IF block is improperly nested. This IF block does
not begin and end in the same block.
- Illegal escape sequence. An escape sequence
consists of the escape character and two hexadecimal digits. The escape
character was found, but not the proper digits.
- Illegal expression for special call parameter. An
illegal expression was detected in a special subroutine call (Compaq
Fortran extension).
- Illegal index expression. Array reference has an
incorrect subscript expression, possibly an illegal subarray reference.
- Illegal number of subscripts in ARRAY. Some
products put restrictions on the number of subscripts allowed in arrays.
- Illegal statement label. The indicated token is an
illegal statement label because it is not an integer, or because it is
more than 5 digits long.
- IMPLICIT NONE must be the only IMPLICIT statement in the
program unit. If you specify IMPLICIT NONE, no other IMPLICIT
statements can be included in the program unit.
- Implied DO list in this I/O statement is not terminated by
a right parenthesis. The implied DO list that should have
ended with a right parenthesis in the current column did not. A right
parenthesis is assumed.
- Improper DO or WHILE statement. The DO or WHILE
statement was improperly typed.
- Include file "#1" not found. A file
specified in an INCLUDE statement was not in the directory specified.
Either the file does not exist or it is not in the correct directory.
- Include nesting level has been exceeded. The
number of nested includes allowed has been exceeded.
- Incompatible storage class for "#1".
Incompatible storage class(PRIVATE,STATIC,AUTOMATIC,SHARED) for the
specified variable/COMMON block.
- Increment expression of the DO statement has an
error. The format of the DO statement is DO s [,] i = e1, e2
[,e3]. The expressions "e1," "e2," and
"e3" are each an INTEGER, REAL, or DOUBLE PRECISION
expression. In this statement, "e3" has a syntax error.
- Increment of the DO statement must not be zero.
The format of the DO statement is DO s [,] i = e1, e2 [,e3]. The
expressions "e1," "e2," and "e3" are each
an INTEGER, REAL, or DOUBLE PRECISION expression. "e3" must
not be zero, when evaluated and converted to the type of the DO index
variable.
- Individual parts of a COMMON block cannot be in a SAVE
statement. A variable in a COMMON block cannot be saved
without the rest of the COMMON block.
- Initialization of "#1" by this constant is not
allowed. A type mismatch has been found between the variable
being initialized and the constant being used for initialization.
- Integer encountered was too large to represent
internally. The scanner encountered and tried to convert an
integer too large to represent internally. This normally is a semantic
error.
- Integer was expected here but not found. An
integer was expected in the indicated column.
- Intrinsic function call has the wrong number of
parameters. An incorrect number of parameters (usually too
few) was coded in the invocation of this intrinsic function. Look up
the intrinsic function and code the correct number of parameters.
- Intrinsic function is not allowed in a constant
expression. The constant expression required here may not
contain the given intrinsic function.
- Intrinsic function parameter has the wrong
dimensionality. The indicated parameter to this intrinsic
function has the wrong number of dimensions. Either an array was
specified where a scalar is required, or a scalar was specified where
an array is required.
- Intrinsic function parameter has the wrong type.
The indicated parameter to this intrinsic function has the wrong type.
See the Compaq Fortran Language Reference Manual to find the
correct intrinsic to use.
- Intrinsic function requires at least two
parameters. This intrinsic function requires at least two
parameters. See the Compaq Fortran Language Reference Manual
for details.
- Intrinsic functions not allowed here. The constant
expression required here may not contain intrinsic functions.
- Intrinsic may not be used as an actual parameter.
Some intrinsic functions may not be used as actual parameters. These
include type conversion intrinsics, lexical relationship intrinsics,
and max/min variations.
- Intrinsic parameter cannot have this value. A
constant value has been specified for an intrinsic function that only
allows a specified range of legal values. The constant is not in this
range.
- Invalid character found in this constant. The
character was not expected to occur in this constant. The constant may
be hex, octal, bit, or hollerith.
- Invalid syntax for the INQUIRE statement. The
INQUIRE statement may have either FILE and DEFAULTFILE or UNIT, but not
both.
- Invalid unit specifier. The unit specifier must be
one of: an integer expression, a character expression, or an asterisk.
Which of these is allowed varies depending on the specific type of I/O
statement.
- Item involved in the transfer is incorrectly
specified. The I/O list parser expected a comma to be at the
current column, and a valid I/O list element to be to the left. This
error can result from using an expression in a READ I/O list, or from
an incorrectly formed expression in WRITE, PRINT, or PUNCH I/O lists.
- Keyword parameter not allowed at this point in call to this
intrinsic function. Keyword parameters are not allowed at this
position in the parameter list of this intrinsic function. See the
Compaq Fortran Language Reference Manual for details.
- Label "#1" is not the label of a format
statement. The mentioned statement label was used as a format
specifier in this statement. The mentioned label is a label used in the
program, but is not the label on a format statement.
- Label "#1" on non-executable statement cannot be
branched to. The mentioned label is the label on a
nonexecutable statement. The current statement attempts to branch to
that statement. Only executable statements can be branched to.
- Label of the terminator statement is missing from the DO
statement. The format of the DO statement is DO s [,] i = e1,
e2 [,e3]. The "s" is the statement label of an executable
statement, called with terminal statement. In this statement, the
statement label is missing or it has an illegal format for a Compaq
Fortran statement label. The label need not appear if the DO is
terminated by an ENDDO in Compaq Fortran.
- Left and right sides have different number of dimensions in
array assignment. The left and right sides of an array
assignment must have the same number of array section selectors or the
right side must be a scalar. Check the declarations of each variable
appearing in the statement.
- Left parenthesis was expected here but not found.
A left parenthesis was expected in the indicated column, but another
symbol was found instead.
- Left side of an assignment is not a scalar or array
shape. The shape of the left side expression could not be
determined. If other errors have not been noted with an earlier column
number for this same statement, then there is a translator error.
- Length field must be an integer constant or enclosed in
parentheses. If a length is given for a type and the length is
not enclosed in parentheses, that length must be an unsigned, nonzero
integer constant. A more general expression is allowed for type
Character if the expression is enclosed in parentheses.
- Length given is not valid for type character. The
length of a character variable must be an unsigned, nonzero integer
constant, an integer constant expression enclosed in parentheses with a
positive value, or an asterisk in parentheses.
- Length specified for this data type is illegal. An
incorrect explicit length has been specified for a noncharacter type.
- List directed or namelist formatting not allowed for an
internal file. If the unit_specifier specifies an internal
file, the control information list must contain a format identifier
other than an asterisk or a namelist group name.
- Logical IF ends on a non-executable statement. The
statement part of a logical IF must be executable.
- Logical operations are invalid between these types of
operands. The logical operator at the position given cannot be
applied to types of operands it is between.
- Lower bound expression of the DO statement has an
error. The format of the DO statement is DO s [,] i = e1, e2
[,e3]. The expressions e1, e2, and e3 are
each an INTEGER, REAL, or DOUBLE PRECISION expression. In this
statement, e1 has a syntax error.
- MAP statement must be preceded by a UNION
statement. The MAP statement was scanned during a parse state
where KAP was not expecting a MAP declaration type for the present
structure declaration block.
- MAP statement must be used inside a STRUCTURE declaration
block.
- MAP/ENDMAP statements must have at least one
field-declaration.
- Missing operand. An operator has been found that
does not have enough operands.
- Multiple declaration of variable. Variable has
been declared in previous type declaration statement.
- Multiple initialization of the same variable is not
allowed. Variable has been initialized previously.
- Name enclosed in slashes "#1" is not the name of
a named COMMON block. In a save statement, a COMMON block name
is specified by enclosing it in slashes. The name found between the
slashes has not been used as the name of a COMMON block previously in
this compilation unit.
- Name is not a legal external identifier. The
indicated name is not a legal external name for the target language. It
either has too many characters or contains a character that is not
allowed in external names.
- Name was previously used in a conflicting way. The
name was used previously in a declaration statement, an expression, or
other manner such that the current use is no longer legal. For example,
a name may not be dimensioned more than once.
- Negation cannot be applied to an expression of type
"#1". Negation "-" cannot be applied to
expressions of the given type.
- Nested loops with same variable "#1".
The index variable for nested loops should not be the same.
- Number of items in the variable list is not the same as in
the constant list. The number of items specified in the
variable list must be the same number in its corresponding constant
list.
- Number of places in edit descriptor must not exceed field
width. The number of places (m) required in Iw.m edit
descriptor must not exceed the field width (w).
- Octal constant contains characters that are not
0-7. An octal constant may contain only the digits
0,1,2,3,4,5,6, or 7. The specified constant contained one or more
digits that were 8 or 9.
- Octal constant too long. Only 43 digits are
allowed. An octal constant can only be 128 bits long. The
specified constant contained more than 43 digits.
- Only constants are allowed in this expression. The
indicated expression element is illegal in this context.
- Only equality comparisons can be made on complex
values. Logical operators .GT., .GE., .LT., .LE. cannot be
applied to complex values.
- Only formal parameters and constants are allowed in this
expression.
- Only simple parameters and constants are allowed in this
expression. Only scalar variable parameters and constants are
allowed in this expression.
- Operands are not conformable. The operands
involved must have the same number of array section selectors.
- Operator was not expected here. An operator was
found in the wrong place.
- Parameter U is required but was not found. The
letter U is required as the third parameter for DEFINE FILE.
- Parallel constructs are not contained in the same statement
flow-control block. Currently, KAP only allows each Parallel
construct to be started and ended in the same statement flow-control
block.
- Periods can only be used to form numbers or extended
operators/operands. A period was encountered, but it was not
part of a number or part of an extended operator/operand.
- Preceding EQUIVALENCE group must have more than one
entry. A single name was specified inside an EQUIVALENCE
group. At least two names must be specified in each group.
- Previous I/O control entry has already been
specified. Each type of I/O control entry can be specified at
most once. The I/O control entry that was specified just prior to the
current column had been specified earlier.
- Previous I/O control entry may not be specified in this
type of I/O statement. Each type of I/O statement allows
certain I/O control entries to be specified. The I/O control entry that
was specified just prior to the current column may not be specified
with this I/O statement.
- Range of first letters specified in this IMPLICIT statement
is invalid. An IMPLICIT statement must specify either a single
letter or two letters separated by a dash, with the first letter
preceding the second in the alphabet. The range of letters specified
must not overlap any other ranges specified in this or other IMPLICIT
statements.
- Record name "#1" cannot be used in an EQUIVALENCE
statement.
- Repetition factor must be greater than zero.
Repetition factors for repeatable format items must be greater than
zero.
- Right parenthesis that matches this left parenthesis is
missing. The indicated left parenthesis has no corresponding
right parenthesis.
- Right parenthesis was expected here but not found.
A right parenthesis was expected in the indicated column, but another
symbol was found instead.
- Scalar expression expected. A scalar expression
was expected but not found, for example in the logical expression of an
if statement.
- Scalar integer expression must follow the label list in a
computed GOTO. The format of a computed GOTO requires that an
integer expression follow the list of statement labels. This expression
can be an integer constant, an integer variable, an integer array
element, or any form of scalar integer expression.
- Semicolon vector syntax not accepted by this
product. This product does not accept semicolon vector
notation. Use some other notation such as Fortran 8X triplets.
- Shape mismatch: Shape of left side is "#1" and
shape of right side is not. The shape of the left and right
sides of an assignment statement must be the same or conformable. The
shape of the left side (mentioned in the message) and the shape of the
right side do not agree.
- Size of hollerith constant exceeds remaining statement
length. A hollerith constant was specified with a length that
is longer than the number of characters that are left in the statement.
- Statement contains too many continuation lines.
KAP expects a maximum number of continuation lines per statement. This
maximum is product-dependent. When the maximum is exceeded, no further
tokenization takes place until a noncontinuation line is encountered.
- Statement is not any of the possible GOTO
statements. The syntax of this statement is so confused that
KAP could not decide what type of statement it is. It appears to be
some type of GOTO statement, but little else can be determined.
- Statement label "#1" was referenced, but never
defined in this program unit.
- Statement must occur earlier in the program unit.
The definition of the version of Fortran being accepted gives the
restrictions on statement ordering within a single compilation unit.
The statement being scanned violates this order requirement. See the
Compaq Fortran User Manual for Tru64 UNIX and Linux Alpha
Systems for details.
- Statement unrecognizable as any known statement
type. The given statement contains errors that make it
impossible to tell what type of statement it was intended to be. The
keyword at the beginning of the statement (if any) did not match any of
the known statement keywords. The statement also did not contain any
equals signs at parenthesis nest level 0, necessary for the statement
to be an assignment statement. This error may be caused by incorrect
parenthesis nesting, or by a misspelled keyword.
- String constant was not closed by end of
statement. A string constant was begun by an apostrophe or
double quote, but no trailing delimiter was encountered before the end
of statement was reached.
- Structure name of a record is the same as the defining
STRUCTURE. A structure name of a record cannot be used within
the defining declaration for that structure name.
- Structure references must be defined prior to use in a
RECORD statement.
- Structure-name has been used previously in a STRUCTURE
declaration.
- Structure-name is missing from the STRUCTURE
declaration. Structure names are required on the structure
declaration at the outermost level of nesting.
- Substring denoted by this expression is not within declared
length of string. The starting position of a substring
specification must be at least 1, and the ending position must be at
most the length of the string.
- Symbolic constant must be a simple scalar entity.
The name of a symbolic constant must not be dimensioned, or in any way
appear different than that of a scalar variable.
- Symbolic constant must not be defined more than once in a
program unit. The symbolic constant that is defined to the
left of the current column has been either in an earlier PARAMETER
statement in this program unit, or in an earlier portion of this
PARAMETER statement. Each symbolic constant in a program unit can be
defined only once.
- Text "#1" following a STOP or PAUSE is not an
integer or string constant. The format of the STOP statement
is STOP [n]. The format of the PAUSE statement is PAUSE [n]. In either
case, "n" must be either a string of not more than 5 digits
or a character constant.
- The %FILL pseudo-name cannot be dimensioned.
- The array "#1" has adjustable dimension and must
appear in dummy argument list. At least one dummy argument
list of the subprogram must contain the name of the adjustable array.
- The field name "#1" has an illegal adjustable
dimension. Adjustable or assumed sized arrays and passed
length CHARACTER declarations are not allowed in field declarations.
- The field-name has not been defined in the associated
structure.
- The preceding parallel and/or synchronization
region/section is not closed. The present Parallel directive
was scanned or the end of the program was reached where KAP was
expecting a closing Parallel directive for the preceding parallel
region/section block.
- This declaration type is not allowed in structure
declaration blocks. During the scanning process, a declaration
type has been detected within a STRUCTURE declaration block that is not
allowed.
- This directive is not adjacent to the loop it applies
to. KAP recognizes directives in a file only if they are
placed immediately before the loop that they are to affect.
- This Parallel directive should be inside a Parallel
PARALLEL REGION. Work-sharing or synchronization Parallel
constructs should be used inside a Parallel fork/join construct (that
is, a PARALLEL REGION).
- Too many arguments in FUNCTION/SUBROUTINE. Some
products put restrictions on the number of arguments allowed in
SUBROUTINE/ FUNCTION.
- Too many labels in computed GOTO. Some products
put restrictions on the number of labels allowed in a computed GOTO
statement.
- Too many parameters are specified to this intrinsic
function. Too many parameters appear in the invocation of the
indicated intrinsic function. Check the intrinsic function and code the
correct number of parameters.
- Transfer into IF or DO block from outside the IF or DO
block is prohibited. Transfer of control into an IF-block or
DO-block from outside the block is not allowed.
- Type conversion not supported for this product.
This message is issued if the type conversion did not exist to type
cast the statement function expression to the type of the statement
function.
- Unary operator has more than one operand. A unary
operator was found that has an operator on the left side.
- Unexpected character. In processing a statement, a
character was encountered that was not allowed at the place it was
found. Check the syntax of the statement where the error occurred.
- Unexpected symbol. The indicated symbol is not
legal at this point in the statement.
- UNION statement must be used inside a STRUCTURE declaration
block.
- UNION statement must not be preceded by a UNION
statement. The UNION statement was scanned during a parse
state where KAP was expecting a MAP declaration type for the present
structure declaration block.
- Unknown I/O control entry begins at the current
column. An I/O control entry that is not in the table of all
possible I/O control entries begins at the current column. This I/O
control entry is not the first or second entry in this control list,
because those two can be positional (unit and format).
- Unrecognized .xxx. operator. A token was
recognized as having the format of an extended operator/operand (period
identifier period), but the extended operator/operand was not in the
table of known extended operators/operands. See the Compaq Fortran
User Manual for Tru64 UNIX and Linux Alpha Systems for details.
- Unsubscripted arrays not permitted in expressions and
assignment statements. An array name without a subscript is
not allowed in expressions and assignment statements.
- Upper bound expression of the DO statement has an
error. The format of the DO statement is DO [,] i = e1, e2
[,e3]. The expressions e1, e2, and e3 are
each an INTEGER, REAL, or DOUBLE PRECISION expression. In this
statement, e2 has a syntax error.
- Variable "#1" has no dimension bounds
specified. Variables declared in a dimension statement must
have at least one dimension bound, enclosed in parentheses, specified.
- Variable "#1" must be explicitly typed.
IMPLICIT NONE and UNDEFINED ( for few dialects ) disables automatic
typing. All variables occurring within the scope of IMPLICIT NONE or
UNDEFINED must be explicitly typed.
- Variable already occurred in a DATA statement. The
variable is declared after it has already been used in a data statement.
- Variable list is missing from this list-directed I/O
statement. The comma after the format in a list-directed READ,
PRINT, or PUNCH statement was present, but the variable list following
the comma was missing.
- Variable must be an array. The simple variable in
question is used in a context requiring an array.
- Variable name "#1" is too long. The
given variable name is too long for the target language.
- Variable name is required at this point. Only a
variable can be used at this point.
- Variables from different COMMON blocks may not be
equivalenced. An EQUIVALENCE statement must not cause the
storage sequences of two different COMMON blocks in the same program
unit to be associated.
F.2.3 Extension (EX)
- COMMON block /"#1"/ contains both character and
non-character data. If a character variable or character array
is in a COMMON block, all of the entities in that COMMON block must be
of type character.
- Intrinsic function call could not be converted to the
target language. This intrinsic function call was to be
converted for output, but did not exist in the target language and had
no known equivalent (or generic) form. You must determine the correct
action to take.
F.2.4 Inlining/IPA (INL)
- Routine "#1" analyzed interprocedurally.
When optimizing the loop containing this call, IPA was performed on the
called routine.
- Routine "#1" was inlined/IPAed. The call
to this routine was replaced by the body of the routine to enhance
optimization. The source of the subroutine or function is available
either in the same file or in a specified library.
- Routine "#1" was not inlined/IPAed. Actual and
formal parameter counts differ. The number of formal
parameters in the definition of the program unit, in the same
compilation stream or in the library, differs from the number of actual
parameters at the call site.
- Routine "#1" was not inlined/IPAed. Space
limitations exceeded. The inlining of subroutine or function
calls at this statement was not attempted due to limitations placed on
the amount of data structure space used in inline expansion.
- Routine "#2" was not inlined/IPAed. COMMON block
"#1" item counts differ. The COMMON block mentioned
is defined in both the program unit being called and the calling
program unit. The number of separate entities in the two definitions do
not match.
- Routine "#2" was not inlined/IPAed. COMMON block
item "#1" has a shape mismatch. The COMMON block
mentioned is defined in both the program unit being called and the
calling program unit. The entity mentioned has a different shape
(scalar or array) than its corresponding entity in the called program
unit.
- Routine "#2" was not inlined/IPAed. COMMON block
item "#1" has a type mismatch. The COMMON block
mentioned is defined in both the program unit being called and the
calling program unit. The entity mentioned has a different type
(integer, logical, real, and so on) than its matching entity in the
called program unit.
- Routine "#2" was not inlined/IPAed. External name
"#1" has unresolvable conflict. In the called and
calling routines, the definitions of an externally visible entity
cannot be reconciled. This may be an error in the program itself.
- Routine "#2" was not inlined/IPAed. Non scalar
parameter "#1" is passed into scalar. The actual
parameter of a function/subroutine call differs in shape from the
corresponding formal parameter, that is scalar.
- Routine "#2" was not inlined/IPAed. Parameter
"#1" is a nonarray passed into array. The actual
parameter of a call statement differs in shape from the corresponding
formal parameter, which is an array.
- Routine "#2" was not inlined/IPAed. Parameter
"#1" cannot conform without linearizing. Before the
program unit is placed inline, the translation of formal parameters to
their actual equivalents must be made (a process called conformance).
First the scalars in the parameter list are matched, then the arrays
are examined to see what the proper translation is (the scalars are
done first because bounds of an array parameter are often passed as a
separate scalar). In this process, each dimension is compared, and a
translation is constructed that tries to keep each dimension of the
actual parameter separate. If this is not possible, the array
references (or a portion of them) must be linearized to do the
translation correctly. This is not desirable because the linearized
subscripts violate the bounds of the array reference, and the data
dependence tests used to optimize the program are compromised.
- Routine "#2" was not inlined/IPAed. Parameter
"#1" has a class mismatch. Inline expansion or IPA
was aborted due to class mismatch between formal and actual parameters.
- Routine "#2" was not inlined/IPAed. Parameter
"#1" has type mismatch. For inlining to work, the
types of the formal parameters and actual parameters must agree. Any
program unit called with parameters of the wrong type will get an
incorrect value unless assigned before any use in the call, and
assigned before the next use after the call.
- Routine "#2" was not inlined/IPAed. Parameter
"#1" whole array does not conform. Inline expansion
or IPA was aborted because whole arrays do not conform.
- Routine "#2" was not inlined/IPAed. The shape of
parameter "#1" is unknown. The shape of an actual
parameter to a call cannot be determined. It must be array, scalar, or
an intrinsic or external function call.
F.2.5 Informational (INF)
- Dynamic array is referenced in the statement.
There is a reference to a dynamic array that may prevent translation.
- Optimization from pass: "#1" is inhibited because
of data structure overflow. The given pass did not optimize
the entire program unit because the amount of storage required to do so
would exceed the capacity of internal data structures.
Note
It is possible for a given routine to be partially optimized by the
pass that issues this message.
|
- Possible use of variable "#1" before its
definition. Live variable analysis was performed and a
possible use of the specified variable was found before any definition.
The optimizer may be acting (necessarily) conservatively and the
variable may not actually be used before any definition.
F.2.6 Inserted (I)
- Two-version loop was created here. The loop cannot
be vectorized as-is because of possible data dependencies. An inserted
IF block eliminates this possibility, and the loop can be vectorized.
F.2.7 Loop Reordering (LR)
- Bounds of this DO loop were changed because of
interchanging triangular loops. The indicated loop was one of
two or more triangular loops that were interchanged. The bounds were
modified so that the same index variable values would be covered by the
loops.
- Condition from the IF statement at this line was assigned
to a temporary array. The condition from the IF statement that
was at the same line number as this statement was assigned to a
temporary array in order that the body of the IF could be split across
multiple loops.
- Loop was distributed. This loop was broken up into
two or more loops to optimize one or more of the resulting loops.
F.2.8 Warning (MIS)
- Too many messages were issued for this compilation
unit. Either there were too many syntax errors, or the program
unit is too large for the vectorization message tables.
F.2.9 Option Error (OW)
- Compiler directive does not have correct syntax.
This line has a compiler directive on it, but it contains a syntax
error.
F.2.10 Not Optimized (NO)
- Data dependence analysis aborted due to insufficient
storage for graph arcs. Data dependence analysis was aborted
because of insufficient storage allocated for dependence graph arcs.
- ELSE IF construct found. This loop was not
optimized because the target machine does not support optimization of
loops with ELSE IF constructs.
- Exits found. This loop was not optimized because
it contains exits. The target machine does not support optimization of
loops with exits.
- GOTO statement found. This loop was not optimized
because the target machine does not support optimization of loops with
GOTO statements.
- Inner loop structure is too complex. This loop was
not optimized because the inner loop structure was too complex. This
could be because of a complex data dependence graph or because of a
complex flow graph structure.
- Loop was asserted serial by directive. The present
loop was asserted serial by the use of a directive. Optimization was
not attempted for this loop.
- Nested IFs found. This loop was not optimized
because the target machine does not support optimization of loops with
nested IFs.
- No optimizable statements found. No optimizable
statements were found in this loop.
- No parallelism detected. The optimizer could not
detect any parallelism in this loop.
- Non-integer loop control variable found. This loop
was not optimized because of a non-integer loop control variable.
Changing the index variable appropriately may enable optimization of
the loop.
- Non-optimizable intrinsic found. This loop was not
optimized because it contains a call to a nonoptimizable intrinsic
function or subroutine.
- Non-optimizable operator found. This loop was not
optimized because it contains an operator that cannot be optimized.
- Non-optimizable statement found. This loop was not
optimized because it contains one or more statements that cannot be
optimized safely.
- Non-optimizable variable type found. This loop was
not optimized because of the presence of a nonoptimizable variable
type. The target machine does not support optimizations for variables
of this type.
- Non-stride-1 references found. This loop was not
optimized because the target machine does not support optimization of
non-stride-1 loops.
- Not an inner loop. This loop was not optimized
because the target machine does not support the optimization of
non-inner loops.
- Optimization was disabled. The present loop was
not optimized because optimization had been disabled.
- Prevented by reference(s) to variable
"#1". This loop was not optimized because of the
presence of the named variable. Restructuring of the code to simplify
references to this variable may enable further optimization.
- Scalar mode determined best. No better execution
mode than scalar was found for this loop. Of all valid loop orderings
considered, this ordering was determined to be the best.
- Statement with alternate returns found. This loop
was not optimized because of the presence of a statement with alternate
returns.
- Too many dependence arcs. There are too many
dependence arcs for this loop. Increasing the value of
-arclimit
may enable optimization of this loop.
- Too many loop orderings. There are too many loop
orderings generated for this loop nest. Increasing the value of
-limit
may enable optimization of this loop.
- Unoptimizable call to "#1" found. This
loop was not optimized because of the presence of a call to the given
function or subroutine. Inline expansion or IPA would be necessary for
optimization to be performed safely.
- Unoptimizable input or output statements found.
This loop was not optimized because it contains unoptimizable input or
output statements.
F.2.11 Output Translation (OT)
- The name "#1" has been used to remove a
KAP-inserted intrinsic conflict. This statement was recognized
as having at least one variable that is in conflict with intrinsic
names inserted by KAP. The translator renamed the conflicting variable
name or names to remove this naming problem.
- Statement was converted from array notation to serial
form. This statement was converted from array notation into
serial form and a DO loop is created around it.
F.2.12 Output Trans Fails (OTF)
- KAP intrinsic function could not be inserted because of a
name conflict. An attempt was made to change an intrinsic
function call in this statement to a KAP "intrinsic," but the
attempt failed because the name of the intrinsic had already been used
in a conflicting way. You can rename the variable that causes the
conflict, if possible.
- Optimization inhibited: the COMMON block name
"#1" cannot be renamed. Page 18-2 lines 45-54 of the
X3J3 ANSI Fortran 77 specification states that a COMMON block name may
not conflict with an intrinsic function name in the same program unit.
This program unit has a COMMON block with the same name as an intrinsic
function inserted by KAP. KAP attempts to correct a program unit by
renaming any local variables with the same name as inserted intrinsics.
This is not possible with a global name such as a COMMON block. The
resulting, transformed program may not compile or link correctly.
- Optimization inhibited: the external function name
"#1" cannot be renamed. This statement was
recognized as having an external function name in conflict with an
intrinsic name inserted by KAP. The translator is unable to rename the
external function.
- Optimization inhibited: the function entry name
"#1" cannot be renamed. This statement was
recognized as having a function entry name in conflict with an
intrinsic name inserted by KAP. The translator is unable to rename the
function entry.
- Optimization inhibited: the function name "#1"
cannot be renamed. This statement was recognized as having a
function name in conflict with an intrinsic name inserted by KAP. The
translator is unable to rename the function.
- Optimization inhibited: the main program name
"#1" cannot be renamed. This statement was
recognized as having a main program name in conflict with an intrinsic
name inserted by KAP. The translator is unable to rename the main
program.
- Optimization inhibited: the subroutine entry name
"#1" cannot be renamed. This statement was
recognized as having a subroutine entry name in conflict with an
intrinsic name inserted by KAP. The translator is unable to rename the
subroutine entry.
- Optimization inhibited: the subroutine name "#1"
cannot be renamed. This statement was recognized as having a
subroutine name in conflict with an intrinsic name inserted by KAP. The
translator is unable to rename the subroutine.
- Optimization inhibited: the variable "#1" cannot
be renamed. This statement was recognized as having at least
one variable in conflict with intrinsic names inserted by KAP. The
translator tried to rename the conflicting variable name, but the
attempt failed because KAP ran out of possible renaming alternatives.
- Optimization inhibited: the variable "#1" cannot
be renamed. This statement was recognized as having at least
one variable that is in conflict with the named COMMON block used by
KAP. The translator tried to rename the conflicting variable name, but
the attempt failed because KAP ran out of possible renaming
alternatives.
- This unit cannot be optimized due to an indeterminable flow
graph. KAP optimization was disabled for this program unit
because the flow graph is indeterminable at the end of the scanner.
F.2.13 Program Too Large (NO)
- Compilation unit is too large to optimize. The
compiler uses data structures to store a program internally while it is
being optimized. In the process of optimization, the compiler creates
new statements that also require storage, all in these same data
structures. At times in the process of optimization, the remaining
space in these data structures is checked. If there is insufficient
space to continue the process, the program is not optimized, and is
passed through unchanged. The general rule to follow in case this
message occurs is to make the program smaller and run the smaller
version through KAP. If further assistance is needed, contact the
software vendor. This message rarely appears.
F.2.14 Question (Q)
- Is "#1" a permutation vector? This array
is used to index another array. If the values of different elements of
the array do not overlap, KAP may be able to optimize this loop.
- Is "#1" in the loop beginning at this
statement? The data dependence program needs information about
the value of a variable or the relative value of two variables to
determine if there is a dependence within this loop. This information
may be provided with an assertion. In an actual instance of this
message, "#1" will be replaced by a relation, for instance,
"N .GT. 1."
F.2.15 Scalar Optimization (SO)
- Block loop for strip mining with block size
"#1". This loop is the block loop of a strip-mined
loop with the given block size.
- Cleanup loop for loop unrolling. Following loop
unrolling, the present loop is the cleanup loop, and was generated for
executing the remainder of the iterations not covered by the main loop
that has been unrolled.
- Cleanup loop for strip mining with block size
"#1". This loop is the cleanup loop of a strip-mined
loop with the given block size.
- Execution flow from this statement has been unconditionally
resolved. The execution path of this conditional statement has
already been determined.
- Loop is empty or is zero-trip. An empty or zero
trip DO loop has been identified.
- Loop unrolled "#1" times to improve scalar
performance. Following loop unrolling, the present loop is the
main loop where the primary number of iterations are executed.
- Statement deleted because of scalar optimization.
Data flow analysis has determined that the execution of this statement
is unnecessary. The statement may reference an unused definition in the
original program or forward-substitution may have made the definition
redundant.
- Strip loop for strip mining with block size
"#1". This loop is the strip loop of a strip-mined
loop with the given block size.
- Unreachable statement. Flow analysis has
determined that no execution path leads to this statement. Check the
logic of the program unit.
- Unused definition. Data flow analysis has
determined that the execution of this statement is unnecessary.
F.2.16 Standardized (STD)
- DO loop in the original program which had no executable
statements was deleted. The source program contained a DO loop
that contained no executable statements. The loop was deleted.
- DO loop was standardized by rerolling it. The DO
loop indicated was recognized as an unrolled loop. The loop has been
rerolled, that is, converted to an equivalent form in which the loop
increment is one.
- IF and assignment were converted to an assignment using MAX
or MIN. An IF with an associated assignment were converted
into an assignment using an intrinsic function (either a MAX or a MIN).
- IF loop beginning here was transformed into a DO
loop. An IF loop beginning at this statement was transformed
into a DO loop. The DO variable increment statement was removed. Any
references to the DO variable that followed the original increment have
been advanced by 1 iteration.
- IF loop ending here was transformed into a DO
loop. An IF loop ending at this statement was transformed into
a DO loop. The branch back to the top of the loop was turned into a
CONTINUE.
- IF statement that ensured the zero trip condition has been
deleted. The output language has DO loops that are zero trip
DO loops. The IF statement that appeared before this DO loop ensured
that this DO loop was a zero trip DO loop, even if the Compaq Fortran
variant had one trip DO loops. The IF statement has been deleted.
- Logical or arithmetic IF converted to block IF or single
statement IF. A logical or arithmetic IF was changed to the
corresponding block IF, and END IF and optional ELSE inserted, or to a
single statement IF if appropriate.
- Two logical IFs converted to a single IF-THEN-ELSE
block. Two logical or block IFs with complementary conditions,
for example, a.eq.0 and a.ne.0, were replaced by a single block IF with
ELSE clause.
F.2.17 Translator Error (TE)
- No message specified. This indicates a fatal error
in KAP. A traceback accompanies this message. Give a copy of the
traceback and the original code to the software vendor so an action can
be taken.
- Translator Error : "#1". KAP has issued
an internal compiler error. The message in quotes indicates which error
is being reported. Please make a copy of the traceback and the original
program available to the software vendor so action can be taken.
- Unknown statement type was passed to the I/O statement
parser. A statement that was thought to be an I/O statement
was not recognized. This is a compiler bug. Please give a copy of the
traceback and the source code to the software vendor so the problem can
be corrected.
F.2.18 Vector Enhanced (VE)
- IF statement was inserted when a wraparound variable was
removed. A loop was unrolled to remove a wraparound variable.
This IF statement was inserted so that the unrolled portion of the loop
would not be executed because the original loop had fewer iterations
than the number of unrolls.
- Loop has been fused with others to reduce
overhead. Compatible adjoining loops have been fused together
to reduce the total execution overhead.
- Loop replaced by call to optimized routine
"#1". This loop was replaced by a call to an
appropriate optimized routine.
- Loop unrolled to remove wraparound index variable.
The loop starting at the indicated statement was unrolled one or more
times to remove a wraparound index variable. For each iteration that
was unrolled, the loop body was copied once before the loop statement,
and an IF statement was inserted around the copied loop body and the
original loop to ensure that the body is executed the proper number of
times.
- Statement copied during loop unrolling to remove a
wraparound variable. The loop containing this statement was
unrolled one or more times to remove a wraparound scalar variable. This
statement was one of those within the loop that was copied when the
loop was unrolled.
- Statement inserted to save the initial value of an
induction variable. This statement was inserted to save the
initial value of an induction variable. The induction variable was
converted to a form that depends only on the loop index and
loop-invariant expressions. The variable assigned in this statement was
created to hold the value that the induction variable had upon entering
the loop nest.
F.2.19 Warning (W)
- All parameters to this intrinsic function must have same
type. All of the parameters to the indicated intrinsic
function must be of the same type.
- Array reference is not within declared array
bounds. This message is issued if an instance of an array
reference in an EQUIVALENCE statement has one or more constant indices
that are out of bounds of the array.
- END statement was missing on this compilation
unit. The last line of each compilation unit must be an END
statement. An END statement was added as the last statement of this
compilation unit.
- If keyword parameter "DIM" is used it must be the
second parameter. Keyword parameter "DIM" is legal
to this intrinsic function, but it must be the second parameter.
- Length of the constant is too long. Length of the
constant is longer than allowed. Refer to the Fortran manual for the
valid syntax.
- Parameter to statement function "#1" is of the
wrong type. An expression passed to a statement function must
match the corresponding dummy argument in type. One of the parameters
to the indicated call had the wrong type.
- Possible use of variable "#1" before its
definition. KAP performed live variable analysis and found a
possible use of the specified variable before any definition. It is
possible that KAP is being (necessarily) conservative and the variable
may not actually be used before any definition. There is a possibility
that the variable may be used before any definition.
- Range of first letters specified in this IMPLICIT statement
is invalid. An IMPLICIT statement must specify either a single
letter or two letters separated by a dash, with the first letter
preceding the second in the alphabet. The range of letters specified
must not overlap any other ranges specified in this or other IMPLICIT
statements.
- Routine "NAME" requires the parallel STACKSIZE
must be at least 221400 bytes. Increasing the number of
parallel threads may result in the need to increase the stack size of
your system.
- SAVE statement conflicts with earlier SAVE
statements. This save statement is not compatible with
previous save statements. All save statements must have parameters or
there must be only one save statement without any parameters.
- Symbol specified in SAVE statement more than once.
An identifier may not appear in more than one save statement.
- Transfer into IF or do block from outside the IF or do
block is prohibited. Transfer of control into an IF block or
DO block from outside the block is not allowed.
- Variable already occurred in a DATA statement.
DATA statements must follow specification statements.