Error Messages

Error message severities:

I - informative. W - warning. S - severe error. F - fatal error. V - variable.

V000 Internal compiler error. $ $

This message indicates an error in the compiler, rather than a user error - although it may be possible for a user error to cause an internal error. The severity may vary; if it is informative or warning, correct object code was probably generated - but it is not real safe to rely on this. Regardless of the severity or cause, internal errors should be reported to the compiler maintenance group.

F001 Source input file name not specified

On the command line, source file name should be specified either before all the switches, or after them.

F002 Unable to open source input file: $

Source file name misspelled, file not in current working directory, or file is read protected.

F003 Unable to open listing file

Probably, user does not have write permission for the current working directory.

F004 Unable to open object file

Probably, user does not have write permission for the current working directory.

F005 Unable to open temporary file

Compiler uses directory “/usr/tmp” or “/tmp” in which to create temporary files. If neither of these directories is available on the node on which the compiler is being used, this error will occur.

S006 Input file empty

Source input file does not contain any Fortran statements other than comments or compiler directives.

F007 Subprogram too large to compile at this optimization level $

Internal compiler data structure overflow, working storage exhausted, or some other non-recoverable problem related to the size of the subprogram. If this error occurs at opt 2, reducing the opt level to 1 may work around the problem. Moving the subprogram being compiled to its own source file may eliminate the problem. If this error occurs while compiling a subprogram of fewer than 2000 statements it should be reported to the compiler maintenance group as a possible compiler problem.

F008 Error limit exceeded

The compiler gives up after 50 severe errors.

F009 Unable to open assembly file

Probably, user does not have write permission for the current working directory.

F010 File write error occurred $

Probably, file system is full.

S011 Unrecognized command line switch: $

Refer to PDS reference document for list of allowed compiler switches.

S012 Value required for command line switch: $

Certain switches require an immediately following value, such as “-opt 2”.

S013 Unrecognized value specified for command line switch: $

S014 Ambiguous command line switch: $

Too short an abbreviation was used for one of the switches.

W015 Hexadecimal or octal constant truncated to fit data type

I016 Identifier, $, truncated to 63 chars

An identifier may be at most 63 characters in length; characters after the 63rd are ignored.

S017 Unable to open include file: $

File is missing, read protected, or maximum include depth (10) exceeded. Remember that the file name should be enclosed in quotes.

S018 Illegal label field

The label field (first five characters) of the indicated line contains a non-numeric character.

S019 Illegally placed continuation line

A continuation line does not follow an initial line, or more than 99 continuation lines were specified.

S020 Unrecognized compiler directive

Refer to PDS reference manual for list of allowed compiler directives.

S021 Label field of continuation line is not blank

The first five characters of a continuation line must be blank.

S022 Unexpected end of file - missing END statement

S023 Syntax error - unbalanced parentheses

W024 CHARACTER or Hollerith constant truncated to fit data type

A character or hollerith constant was converted to a data type that was not large enough to contain all of the characters in the constant. This type conversion occurs when the constant is used in an arithmetic expression or is assigned to a non-character variable. The character or hollerith constant is truncated on the right, that is, if 4 characters are needed then the first 4 are used and the remaining characters are discarded.

W025 Illegal character ($) - ignored

The current line contains a character, possibly non-printing, which is not a legal Fortran character (characters inside of character or Hollerith constants cannot cause this error). As a general rule, all non-printing characters are treated as white space characters (blanks and tabs); no error message is generated when this occurs. If for some reason, a non-printing character is not treated as a white space character, its hex representation is printed in the form dd where each d is a hex digit.

S026 Unmatched quote

S027 Illegal integer constant: $

Integer constant is too large for 32 bit word.

S028 Illegal real or double precision constant: $

S029 Illegal hexadecimal constant: $

A hexadecimal constant consists of digits 0..9 and letters A..F or a..f. Any other character in a hexadecimal constant is illegal.

S030 Illegal octal constant: $

An octal constant consists of digits 0..7. Any other digit or character in an octal constant is illegal.

S031 Illegal data type length specifier for $

The data type length specifier (e.g. 4 in INTEGER*4) is not a constant expression that is a member of the set of allowed values for this particular data type.

W032 Data type length specifier not allowed for $

The data type length specifier (e.g. 4 in INTEGER*4) is not allowed in the given syntax (e.g. DIMENSION A(10)*4).

S033 Illegal use of constant $

A constant was used in an illegal context, such as on the left side of an assignment statement or as the target of a data initialization statement.

S034 Syntax error at or near $

I035 Predefined intrinsic $ loses intrinsic property

An intrinsic name was used in a manner inconsistent with the language definition for that intrinsic. The compiler, based on the context, will treat the name as a variable or an external function.

S036 Illegal implicit character range

First character must alphabetically precede second.

S037 Contradictory data type specified for $

The indicated identifier appears in more than one type specification statement and different data types are specified for it.

S038 Symbol, $, has not been explicitly declared

The indicated identifier must be declared in a type statement; this is required when the IMPLICIT NONE statement occurs in the subprogram.

W039 Symbol, $, appears illegally in a SAVE statement

An identifier appearing in a SAVE statement must be a local variable or array.

S040 Illegal common variable $

Indicated identifier is a dummy variable, is already in a common block, or has previously been defined to be something other than a variable or array.

W041 Illegal use of dummy argument $

This error can occur in several situations. It can occur if dummy arguments were specified on a PROGRAM statement. It can also occur if a dummy argument name occurs in a DATA, COMMON, SAVE, or EQUIVALENCE statement. A program statement must have an empty argument list.

S042 $ is a duplicate dummy argument

S043 Illegal attempt to redefine $ $

An attempt was made to define a symbol in a manner inconsistent with an earlier definition of the same symbol. This can happen for a number of reasons. The message attempts to indicate the situation that occurred. * *(tfintrinsic*(rf - An attempt was made to redefine an intrinsic function. A symbol that represents an intrinsic function may be redefined if that symbol has not been previously verified to be an intrinsic function. For example, the intrinsic *(tfsin*(rf can be defined to be an integer array. If a symbol is verified to be an intrinsic function via the *(cfINTRINSIC*(rf statement or via an intrinsic function reference then it must be referred to as an intrinsic function for the remainder of the program unit. * *(tfsymbol*(rf - An attempt was made to redefine a symbol that was previously defined. An example of this is to declare a symbol to be a *(rfPARAMETER*(rf which was previously declared to be a subprogram argument.

S044 Multiple declaration for symbol $

A redundant declaration of a symbol has occurred. For example, an attempt was made to declare a symbol as an *(cfENTRY*(rf when that symbol was previously declared as an *(cfENTRY*(rf.

S045 Data type of entry point $ disagrees with function $

The current function has entry points with data types inconsistent with the data type of the current function. For example, the function returns type character and an entry point returns type complex.

S046 Data type length specifier in wrong position

The CHARACTER data type specifier has a different position for the length specifier from the other data types. Suppose, we want to declare arrays ARRAYA and ARRAYB to have 8 elements each having an element length of 4 bytes. The difference is that ARRAYA is character and ARRAYB is integer. The declarations would be CHARACTER ARRAYA(8)*4 and INTEGER ARRAYB*4(8).

S047 More than seven dimensions specified for array

S048 Illegal use of ‘’ in declaration of array $*

An asterisk may be used only as the upper bound of the last dimension.

S049 Illegal use of ‘’ in non-subroutine subprogram*

The alternate return specifier ‘*’ is legal only in the subroutine statement. Programs, functions, and block data are not allowed to have alternate return specifiers.

S050 Adjustable or assumed size array, $, is not a dummy argument

S051 Unrecognized built-in % function

The allowable built-in functions are %VAL, %REF, %LOC, and %FILL. One was encountered that did not match one of these allowed forms.

S052 Illegal argument to %VAL or %LOC

S053 %REF or %VAL not legal in this context

The built-in functions %REF and %VAL can only be used as actual parameters in procedure calls.

W054 Implicit character $ used in a previous implicit statement

An implicit character has been given an implied data type more than once. The implied data type for the implicit character is changed anyway.

W055 Multiple implicit none statements

The IMPLICIT NONE statement can occur only once in a subprogram.

W056 Implicit type declaration

The -dclchk switch and an implicit declaration following an IMPLICIT NONE statement will produce a warning message for IMPLICIT statements.

S057 Illegal equivalence of dummy variable, $

Dummy arguments may not appear in EQUIVALENCE statements.

S058 Equivalenced variables $ and $ not in same common block

A common block variable must not be equivalenced with a variable in another common block.

S059 Conflicting equivalence between $ and $

The indicated equivalence implies a storage layout inconsistent with other equivalences.

S060 Illegal equivalence of structure variable, $

STRUCTURE and UNION variables may not appear in EQUIVALENCE statements.

S061 Equivalence of $ and $ extends common block backwards

W062 Equivalence forces $ to be unaligned

EQUIVALENCE statements have defined an address for the variable which has an alignment not optimal for variables of its data type. This can occur when INTEGER and CHARACTER data are equivalenced, for instance.

I063 Gap in common block $ before $

S064 Illegal use of $ in DATA statement implied DO loop

The indicated variable is referenced where it is not an active implied DO index variable.

S065 Repeat factor less than or equal to zero

S066 Too few data constants in initialization statement

S067 Too many data constants in initialization statement

S068 Numeric initializer for CHARACTER $ out of range 0 through 255

A CHARACTER*1 variable or character array element can be initialized to an integer, octal, or hexadecimal constant if that constant is in the range 0 through 255.

S069 Illegal implied DO expression

The only operations allowed within an implied DO expression are integer +, -, *, and /.

S070 Incorrect sequence of statements $

The statement order is incorrect. For instance, an IMPLICIT NONE statement must precede a specification statement which in turn must precede an executable statement.

S071 Executable statements not allowed in block data

S072 Assignment operation illegal to $ $

The destination of an assignment operation must be a variable, array reference, or vector reference. The assignment operation may be by way of an assignment statement, a data statement, or the index variable of an implied DO-loop. The compiler has determined that the identifier used as the destination, is not a storage location. The error message attempts to indicate the type of entity used. * *(tfentry point*(rf - An assignment to an entry point that was not a function procedure was attempted. * *(tfexternal procedure*(rf - An assignment to an external procedure or a Fortran intrinsic name was attempted. if the identifier is the name of an entry point that is not a function, an external procedure…

S073 Intrinsic or predeclared, $, cannot be passed as an argument

S074 Illegal number or type of arguments to $

The indicated symbol is an intrinsic or generic function, or a predeclared subroutine or function, requiring a certain number of arguments of a fixed data type.

S075 Subscript, substring, or argument illegal in this context for $

This can happen if you try to doubly index an array such as ra(2)(3). This also applies to substring and function references.

S076 Subscripts specified for non-array variable $

S077 Subscripts omitted from array $

S078 Wrong number of subscripts specified for $

S079 Keyword form of intrinsic argument illegal in this context for $

S080 Subscript for array $ is out of bounds

S081 Matrix/vector $ illegal as subprogram argument

A matrix/vector reference cannot be used as a subprogram argument.

S082 Illegal substring expression for variable $

Substring expressions must be of type integer and if constant must be greater than zero.

S083 Vector expression used where scalar expression required

A vector expression was used in an illegal context. For example, iscalar = iarray, where a scalar is assigned the value of an array. Also, character and record references are not vectorizable.

S084 Illegal use of symbol $ $

This message is used for many different errors.

S085 Incorrect number of arguments to statement function $

S086 Dummy argument to statement function must be a variable

S087 Non-constant expression where constant expression required

S088 Recursive subroutine or function call of $

A function may not call itself.

S089 Illegal use of symbol, $, with character length = *

Symbols of type CHARACTER*(*) must be dummy variables and must not be used as statement function dummy parameters and statement function names. Also, a dummy variable of type CHARACTER*(*) cannot be used as a function.

S090 Hollerith constant more than 4 characters

In certain contexts, Hollerith constants may not be more than 4 characters long.

S091 Constant expression of wrong data type

S092 Illegal use of variable length character expression

A character expression used as an actual argument, or in certain contexts within I/O statements, must not consist of a concatenation involving a passed length character variable.

W093 Type conversion of expression performed

An expression of some data type appears in a context which requires an expression of some other data type. The compiler generates code to convert the expression into the required type.

S094 Variable $ is of wrong data type $

The indicated variable is used in a context which requires a variable of some other data type.

S095 Expression has wrong data type

An expression of some data type appears in a context which requires an expression of some other data type.

S096 Illegal complex comparison

The relations .LT., .GT., .GE., and .LE. are not allowed for complex values.

S097 Statement label $ has been defined more than once

More than one statement with the indicated statement number occurs in the subprogram.

S098 Divide by zero

S099 Illegal use of an aggregate RECORD

Aggregate record references may only appear in aggregate assignment statements, unformatted I/O statements, and as parameters to subprograms. They may not appear, for example, in expressions. Also, records with differing structure types may not be assigned to one another.

S100 Expression cannot be promoted to a vector

An expression was used that required a scalar quantity to be promoted to a vector illegally. For example, the assignment of a character constant string to a character array. Records, too, cannot be promoted to vectors.

S101 Vector operation not allowed on $

Record and character typed entities may only be referenced as scalar quantities.

S102 Arithmetic IF expression has wrong data type

The parenthetical expression of an arithmetic if statement must be an integer, real, or doubleprecision scalar expression.

S103 Type conversion of subscript expression for $

The data type of a subscript expression must be integer. If it is not, it is converted.

S104 Illegal control structure $

This message is issued for a number of errors involving IF-THEN statements and DO loops. If the line number specified is the last line (END statement) of the subprogram, the error is probably an unterminated DO loop or IF-THEN statement.

S105 Unmatched ELSEIF, ELSE or ENDIF statement

An ELSEIF, ELSE, or ENDIF statement cannot be matched with a preceding IF-THEN statement.

S106 DO index variable must be a scalar variable

The DO index variable cannot be an array name, a subscripted variable, a PARAMETER name, a function name, a structure name, etc.

S107 Illegal assigned goto variable $

S108 Illegal variable, $, in NAMELIST group $

A NAMELIST group can only consist of arrays and scalars which are not dummy arguments and pointer-based variables.

I109 Overflow in hexadecimal constant $, constant truncated at left

A hexadecimal constant requiring more than 64-bits produces an overflow. The hexadecimal constant is truncated at left (e.g. ‘1234567890abcdef1’x will be ‘234567890abcdef1’x).

I110 Overflow in octal constant $, constant truncated at left

An octal constant requiring more than 64-bits produces an overflow. The octal constant is truncated at left (e.g. ‘2777777777777777777777’o will be ‘777777777777777777777’o).

I111 Underflow of real or double precision constant

I112 Overflow of real or double precision constant

S113 Label $ is referenced but never defined

S114 **

W115 Assignment to DO variable $ in loop

S116 Illegal use of pointer-based variable $ $

S117 Statement not allowed within STRUCTURE definition

S118 Statement not allowed in DO, IF, or WHERE block

I119 Redundant specification for $

Data type of indicated symbol specified more than once.

I120 Label $ is defined but never referenced

I121 Operation requires logical or integer data types

An operation in an expression was attempted on data having a data type incompatible with the operation. For example, a logical expression can consist of only logical elements of type integer or logical. Real data would be invalid.

I122 Character string truncated

Character string or Hollerith constant appearing in a DATA statement or PARAMETER statement has been truncated to fit the declared size of the corresponding identifier.

W123 Hollerith length specification too big, reduced

The length specifier field of a hollerith constant specified more characters than were present in the character field of the hollerith constant. The length specifier was reduced to agree with the number of characters present.

S124 Relational expression mixes character with numeric data

A relational expression is used to compare two arithmetic expressions or two character expressions. A character expression cannot be compared to an arithmetic expression.

I125 Dummy procedure $ not declared EXTERNAL

A dummy argument which is not declared in an EXTERNAL statement is used as the subprogram name in a CALL statement, or is called as a function, and is therefore assumed to be a dummy procedure. This message can result from a failure to declare a dummy array.

I126 Name $ is not an intrinsic function

I127 Optimization level for $ changed to opt 1 $

W128 Integer constant truncated to fit data type: $

An integer constant will be truncated when assigned to data types smaller than 32-bits, such as a BYTE.

I129 Floating point overflow. Check constants and constant expressions

I130 Floating point underflow. Check constants and constant expressions

I131 Integer overflow. Check floating point expressions cast to integer

I132 Floating pt. invalid oprnd. Check constants and constant expressions

I133 Divide by 0.0. Check constants and constant expressions

W134 **

W135 Missing STRUCTURE name field

A STRUCTURE name field is required on the outermost structure.

W136 Field-namelist not allowed

The field-namelist field of the STRUCTURE statement is disallowed on the outermost structure.

W137 Field-namelist is required in nested structures

W138 Multiply defined STRUCTURE member name $

A member name was used more than once within a structure.

W139 Structure $ in RECORD statement not defined

A RECORD statement contains a reference to a STRUCTURE that has not yet been defined.

S140 Variable $ is not a RECORD

S141 RECORD required on left of .

S142 $ is not a member of this RECORD

W143 **

W144 NEED ERROR MESSAGE $ $

This is used as a temporary message for compiler development.

W145 %FILL only valid within STRUCTURE block

The %FILL special name was used outside of a STRUCTURE multiline statement. It is only valid when used within a STRUCTURE multiline statement even though it is ignored.

S146 Expression must be character type

S147 Character expression not allowed in this context

S148 Non-record where aggregate record reference required

An aggregate reference to a record was expected during statement compilation but another data type was found instead.

S149 Record where arithmetic value required

An aggregate record reference was encountered when an arithmetic expression was expected.

S150 Structure, Record, or member $ not allowed in this context

A structure, record, or member reference was found in a context which is not supported. For example, the use of structures, records, or members within a data statement is disallowed.

S151 Empty STRUCTURE, UNION, or MAP

STRUCTURE - ENDSTRUCTURE, UNION - ENDUNION MAP - ENDMAP declaration contains no members.

S152 All dimension specifiers must be ‘:’

S153 **

S154 **

S155 $ $

Generic error message which should be self-explanatory.

S156 **

S157 **

S158 Alternate return not specified in SUBROUTINE or ENTRY

An alternate return can only be used if alternate return specifiers appeared in the SUBROUTINE or ENTRY statements.

S159 Alternate return illegal in FUNCTION subprogram

An alternate return cannot be used in a FUNCTION.

S160 ENDSTRUCTURE, ENDUNION, or ENDMAP does not match top

S161 **

W162 Not equal test of loop control variable $ replaced with < or > test.

S163 Cannot data initialize member $ of ALLOCATABLE COMMON $

S164 Overlapping data initializations of $

An attempt was made to data initialize a variable or array element already initialized.

S165 $ appeared more than once as a subprogram

A subprogram name appeared more than once in the source file. The message is applicable only when an assembly file is the output of the compiler.

S166 $ cannot be a common block and a subprogram

A name appeared as a common block name and a subprogram name. The message is applicable only when an assembly file is the output of the compiler.

I167 Inconsistent size of common block $

A common block occurs in more than one subprogram of a source file and its size is not identical. The maximum size is chosen. The message is applicable only when an assembly file is the output of the compiler.

S168 Incompatible size of common block $

A common block occurs in more than one subprogram of a source file and is initialized in one subprogram. Its initialized size was found to be less than its size in the other subprogram(s). The message is applicable only when an assembly file is the output of the compiler.

W169 Multiple data initializations of common block $

A common block is initialized in more than one subprogram of a source file. Only the first set of initializations apply. The message is applicable only when an assembly file is the output of the compiler.

W170 F77 extension: $

Use of a nonstandard feature. A description of the feature is provided.

W171 F77 extension: nonstandard statement type $

W172 F77 extension: numeric initialization of CHARACTER $

A CHARACTER*1 variable or array element was initialized with a numeric value.

W173 F77 extension: nonstandard use of data type length specifier

W174 F77 extension: type declaration contains data initialization

W175 F77 extension: IMPLICIT range contains nonalpha characters

W176 F77 extension: nonstandard operator $

W177 F77 extension: nonstandard use of keyword argument $

W178 F77 extension: matrix/vector reference $

W179 F77 extension: use of structure field reference $

W180 F77 extension: nonstandard form of constant

W181 F77 extension: & alternate return

W182 F77 extension: mixed non-character and character elements in COMMON $

W183 F77 extension: mixed non-character and character EQUIVALENCE ($,$)

W184 Mixed type elements (numeric and/or character types) in COMMON $

W185 Mixed numeric and/or character type EQUIVALENCE ($,$)

W190 Possible use of $ before definition in $

The optimizer has detected the possibility that a variable is used before it has been assigned a value. The names of the variable and the function in which the use occurred are listed. The line number, if specified, is the line number of the basic block containing the use of the variable.

W191 Unable to open VPU intrinsic lib: $

Unable to open intrinsic definition file using pathname passed to compiler via -idf switch. Sparc/VPU compilers only.

W192 VPU intrinsic lib - bad format (line $) file not read

IDF file illegal, out of date format. Line # of IDF file given. Sparc/VPU compilers only.

S197 Invalid qualifier or qualifier value (/$) in OPTIONS statement

An illegal qualifier was found or a value was specified for a qualifier which does not expect a value. In either case, the qualifier for which the error occurred is indicated in the error message.

S198 $ $ in ALLOCATE/DEALLOCATE

W199 Unaligned memory reference $ $

A memory reference occurred whose address does not meet its data alignment requirement.

S200 Missing UNIT/FILE specifier

S201 Illegal I/O specifier - $

S202 Repeated I/O specifier - $

S203 FORMAT statement has no label

S204 Syntax error - unbalanced angle brackets

S205 Illegal specification of scale factor

The integer following + or - has been omitted, or P does not follow the integer value.

S206 Repeat count is zero

S207 Integer constant expected in edit descriptor

S208 Period expected in edit descriptor

S209 Illegal edit descriptor

S210 Exponent width not used in the Ew.dEe or Gw.dEe edit descriptors

S211 Internal I/O $

S212 Illegal NAMELIST I/O

Namelist I/O cannot be performed with internal, unformatted, formatted, and list-directed I/O. Also, I/O lists must not be present.

S213 $ is not a NAMELIST group name

S214 Input item is not a variable reference

S215 Assumed sized array name cannot be used as an I/O item or specifier

An assumed sized array was used as an item to be read or written or as an I/O specifier (i.e., FMT = array-name). In these contexts the size of the array must be known.

S216 STRUCTURE/UNION cannot be used as an I/O item

S217 ENCODE/DECODE buffer must be a variable, array, or array element

S218 Statement labeled $ is not a FORMAT

S221 #elif after #else

A preprocessor #elif directive was found after a #else directive; only #endif is allowed in this context.

S222 #else after #else

A preprocessor #else directive was found after a #else directive; only #endif is allowed in this context.

S223 #if-directives too deeply nested

Preprocessor #if directive nesting exceeded the maximum allowed (currently 10).

S224 Actual parameters too long for $

The total length of the parameters in a macro call to the indicated macro exceeded the maximum allowed (currently 2048).

W225 Argument mismatch for $

The number of arguments supplied in the call to the indicated macro did not agree with the number of parameters in the macro’s definition.

F226 Can’t find include file $

The indicated include file could not be opened.

S227 Definition too long for $

The length of the macro definition of the indicated macro exceeded the maximum allowed (currently 2048).

S228 EOF in comment

The end of a file was encountered while processing a comment.

S229 EOF in macro call to $

The end of a file was encountered while processing a call to the indicated macro.

S230 EOF in string

The end of a file was encountered while processing a quoted string.

S231 Formal parameters too long for $

The total length of the parameters in the definition of the indicated macro exceeded the maximum allowed (currently 2048).

S232 Identifier too long

The length of an identifier exceeded the maximum allowed (currently 2048).

S233 **

W234 Illegal directive name

The sequence of characters following a # sign was not an identifier.

W235 Illegal macro name

A macro name was not an identifier.

S236 Illegal number $

The indicated number contained a syntax error.

F237 Line too long

The input source line length exceeded the maximum allowed (currently 2048).

W238 Missing #endif

End of file was encountered before a required #endif directive was found.

W239 Missing argument list for $

A call of the indicated macro had no argument list.

S240 Number too long

The length of a number exceeded the maximum allowed (currently 2048).

W241 Redefinition of symbol $

The indicated macro name was redefined.

I242 Redundant definition for symbol $

A definition for the indicated macro name was found that was the same as a previous definition.

F243 String too long

The length of a quoted string exceeded the maximum allowed (currently 2048).

S244 Syntax error in #define, formal $ not identifier

A formal parameter that was not an identifier was used in a macro definition.

W245 Syntax error in #define, missing blank after name or arglist

There was no space or tab between a macro name or argument list and the macro’s definition.

S246 Syntax error in #if

A syntax error was found while parsing the expression following a #if or #elif directive.

S247 Syntax error in #include

The #include directive was not correctly formed.

W248 Syntax error in #line

A #line directive was not correctly formed.

W249 Syntax error in #module

A #module directive was not correctly formed.

W250 Syntax error in #undef

A #undef directive was not correctly formed.

W251 Token after #ifdef must be identifier

The #ifdef directive was not followed by an identifier.

W252 Token after #ifndef must be identifier

The #ifndef directive was not followed by an identifier.

S253 Too many actual parameters to $

The number of actual arguments to the indicated macro exceeded the maximum allowed (currently 31).

S254 Too many formal parameters to $

The number of formal arguments to the indicated macro exceeded the maximum allowed (currently 31).

F255 Too much pushback

The preprocessor ran out of space while processing a macro expansion. The macro may be recursive.

W256 Undefined directive $

The identifier following a # was not a directive name.

S257 EOF in #include directive

End of file was encountered while processing a #include directive.

S258 Unmatched #elif

A #elif directive was encountered with no preceding #if or #elif directive.

S259 Unmatched #else

A #else directive was encountered with no preceding #if or #elif directive.

S260 Unmatched #endif

A #endif directive was encountered with no preceding #if, #ifdef, or #ifndef directive.

S261 Include files nested too deeply

The nesting depth of #include directives exceeded the maximum (currently 20).

S262 Unterminated macro definition for $

A newline was encountered in the formal parameter list for the indicated macro.

S263 Unterminated string or character constant

A newline with no preceding backslash was found in a quoted string.

I264 Possible nested comment

The characters /* were found within a comment.

W268 Cannot inline subprogram; common block mismatch

W269 Cannot inline subprogram; argument type mismatch

This message may be Severe if have gone too far to undo inlining process.

F270 Missing -exlib option

W271 Can’t inline $ - wrong number of arguments

I272 Argument of inlined function not used

S273 Inline library not specified on command line (-inlib switch)

F274 Unable to access file $/TOC

S275 Unable to open file $ while extracting or inlining

F276 Assignment to constant actual parameter in inlined subprogram

I277 Inlining of function $ may result in recursion

W278 Can’t inline $ - too large

W279 Cannot inline function $ - data type mismatch

W280 Syntax error in directive $

messages 280-300 rsvd for directive handling

W281 Directive ignored - $ $

S282 ISHFT: shift is greater than the bit size of the value argument

In integer shift, ISHFT(I, SHIFT), absolute value of SHIFT cannot be bigger than bit size of I.

S350 Invalid constraint $ in extended ASM operand $

W351 Unsupported clobber register ‘$’ ignored in extended ASM

W352 Constraint/expression type mismatch in extended ASM operand $

S353 Unsupported constraint ‘$’ in extended ASM operand $

S354 Can’t find a register in class ‘$’ for extended ASM operand $

W355 Operand constraints for extended ASM differ in number of alternatives

S356 Unsupported modifier $ in extended ASM string

S357 Invalid asm: Operand number missing after $

W358 Output constraint $ for operand $ is not at the beginning

S359 Missing or incorrectly positioned $ in constraint for operand $

S360 Duplicate asm operand name ‘$’

W361 Use of a matching constraint with read/write (‘+’) operand $ is ambiguous

W362 Ignoring matching constraint for non-register operand $

S363 Invalid register name `$’

W364 Call-clobbered register `$’ used for global register variable

S365 Address of register variable `$’ requested in operand $

W366 Profiling inhibited for templated functions

F367 Extended precision long doubles are not supported as extended ASM operands

W370 License for accelerator feature was not found; accelerator code generation is disabled

The accelerator feature in the PGI compilers is separately licensed; that license was not found. Please update your licenses to use this feature. Starting from 1100, Reserved for OpenMP GPU

F701 Error reading temp file - $

This may occur if the file system failed, or the file system or directory containing the temporary file filled up. The compiler typically uses the “/tmp” directory to create temporary files. You may specify a directory to use for temporary files with the TMPDIR environment variable.

F702 Error writing temp file - $

This may occur if the file system containing the temporary file is full. The compiler typically uses the “/tmp” directory to create temporary files. You may specify a directory to use for temporary files with the TMPDIR environment variable.

F703 only the last -preinclude switch is processed

We have one spot for the preinclude file in the gbl. structure. This is not a user visible switch.

F704 Compilation aborted due to previous errors.

Compilation will abort immediately in case of Severe or Fatal error.

F705 Half precision implementation missing support - $

W972 The directive #pragma acc mirror is deprecated; use #pragma acc declare create instead

W973 The directive #pragma acc reflected is deprecated; use #pragma acc declare present

W974 The directive #pragma acc region is deprecated; use #pragma acc kernels instead

W975 The directive #pragma acc data region is deprecated; use #pragma acc data instead

W976 The directive #pragma acc for is deprecated; use #pragma acc loop instead

W977 The directive #pragma acc for kernel is deprecated; use #pragma acc loop instead

W978 The clause parallel is deprecated; use clause gang instead

W979 The directive #pragma acc region for is deprecated; use #pragma acc kernels loop instead

W980 The directive #pragma acc region loop is deprecated; use #pragma acc kernels loop instead

W981 The directive #pragma acc kernels for is deprecated; use #pragma acc kernels loop instead

W982 The directive #pragma acc deviceptr is deprecated; use #pragma acc declare deviceptr instead

W983 The directive #pragma acc parallel for is deprecated; use #pragma acc parallel loop instead

W984 The directive #pragma acc scalar region is deprecated; use #pragma acc serial instead

W985 The clause local is deprecated; use clause create instead

W986 The clause cache is deprecated; use directive #pragma acc cache instead

W987 The clause update host is deprecated; use separate update host directive after the region instead

W988 The clause update device is deprecated; use separate update device directive before the region instead

W989 The clause update in is deprecated; use separate update device directeve before the region instead

W990 The clause update out is deprecated; use update self instead

W991 The clause pnot is deprecated; use no_create instead

W992 The clause updatein is deprecated; use update device instead

W993 The clause updateout is deprecated; use update self instead

W994 The directive #pragma acc copy is deprecated; use #pragma acc declare copy instead

W995 The directive #pragma acc copyin is deprecated; use #pragma acc declare copyin instead

W996 The directive #pragma acc copyout is deprecated; use #pragma acc declare copyout instead

W997 The directive #pragma acc device_resident is deprecated; use #pragma acc declare device_resident instead

W998 The directive #pragma acc for host is deprecated; no OpenACC equivalent

W999 The directive #pragma acc loop kernel is deprecated; no OpenACC equivalent

S1000 Call in OpenACC region to procedure ‘$’ which has no acc routine information

S1001 All selected compute capabilities were disabled (see -Minfo)

S1002 Reduction type not supported for this variable datatype - $

W1003 Lambda capture by reference not supported in Accellerated region

W1004 Lambda capture ‘this’ by reference not supported in Accellerated region

W1005 The clause unroll is deprecated; no OpenACC equivalent

W1006 The clause mirror is deprecated; no OpenACC equivalent

W1007 The clause host is deprecated; no OpenACC equivalent

S1011 Device variable cannot be THREADPRIVATE - $

S1012 Threadprivate variables are not supported in acc routine - $

S1013 Static Threadprivate variables are not supported - $

S1014 Global Threadprivate variables are not supported - $

F1015 No shape directive is defined in structure $

F1016 No shape name $ is defined in structure $

F1017 arrays/pointers appearing in the OpenACC shape and policy directives must be a member of current aggregate type

F1018 Only one unnamed Shape directive is allowed in one aggregate type (struct/union)

F1019 Type clause must be used to specified structure type when Shape/Policy is defined outside (struct/union/class) definition

F1020 Data-Type appearing in type clause cannot be found

F1021 Data-Type appearing in type clause must be struct/union type

F1022 Duplicated shape names $ are defined for structure/union/class $

F1023 Duplicated policy names $ are defined for structure/union/class $

F1024 Type clause is not allowed within structure/union/class definition

F1025 The number of dimension section descriptions doesn’t match member $ which requires $ dimensions

F1026 Pointers appearing within relative clause must be their sibling members

F1027 As motion clauses, only create, copyin, copyout, copy, update, and deviceptr are allowed in policy directive

F1028 The variable $ doesn’t have predefined policy $ available

F1029 The variable $ using policy $ is not a structure-based type

F1030 Policy motion $ is not allowed in $ directive

W1031 The directive #pragma acc create is deprecated; use #pragma acc declare create instead

W1032 The directive #pragma acc present is deprecated; use #pragma acc declare present instead

W1033 The directive #pragma acc link is deprecated; use #pragma acc declare link instead

F1034 Only signed/unsigned 32 bits and 64 bits integer variables are allowed in bound expression. $ is is not such variable

F1035 Only integer sibling members and global variables are allowed in bound expression. $ is is neither of them.

F1036 No global variable named $ has been defined

F1037 Default clause can only contain include and exclude keyword.

W1038 COPY clause on a dummy variable with INTENT(IN) attribute demoted to COPYIN - $

S1039 OpenACC data clause expected after $

S1040 OpenACC $ data clause may not follow a device_type clause.

S1041 OpenACC $ clause may not follow a device_type clause.

W1042 acc loop vector clause ignored because of inner vector loop.

Nested acc loop vector directives will not be honored if the loops cannot be effectively collapsed or tiled.

W1043 acc loop worker clause ignored because of inner worker loop.

Nested acc loop worker directives will not be honored if the loops cannot be effectively collapsed or tiled.

S1044 acc loop gang not allowed in an acc routine($) procedure.

S1045 call to acc routine(gang$) procedure not allowed in acc loop $.

S1046 OpenACC compute region ignored: no parallel kernels found.

S1047 Inner collapsed loop bounds are not invariant in outer loop.

S1100 Cannot collapse non-tightly-nested loops

S1198 OpenMP GPU - The feature is not implemented yet for the target device

W1199 OpenMP GPU - "$" is ignored for the target device

S1200 OpenMP GPU - "$" is used, it is not implemented yet

S1201 OpenMP GPU - [$] is used with [$], this usage is not implemented yet.

S1202 OpenMP GPU - [$] is used independently than [$], this usage is not implemented yet.

S1204 OpenMP GPU - Internal compiler error. Reason: [$] at [$]