# Compaq KAP Fortran/OpenMP
for Tru64 UNIX
User Guide

Previous | Contents | Index

# 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.

Index | Contents