LSCC Compiler Messages

This chapter describes diagnostic messages for the SAS/C mainframe Compiler and SAS/C Cross-Platform Compiler. Most of the Cross-Platform Compiler messages, which are generated on a workstation running under UNIX, are identical to those generated by the SAS/C Compiler on the mainframe.

Diagnostic messages include numbered and unnumbered messages that are produced during the three phases of the compiler. All lexical and syntax diagnostics are produced by phase 1 of the compiler, and code generation diagnostics are produced by phase 2. Messages containing the text CXERR are compiler internal errors and are not described in this chapter.

Compiler Message Processing

The SAS/C mainframe Compiler provides a return code indicating the overall success of the compilation. For the SAS/C mainframe Compiler, a return code of 0 indicates successful compilation, a return code of 4 indicates a warning level diagnostic, and a return code equal to or greater than 8 indicates one or more error conditions were detected. Global optimization warnings do not change the return code.

The Cross-Platform Compiler return codes, unlike those of the mainframe compiler, have been chosen to be compatible with traditional UNIX program development tools such as make. If the return code is a nonzero integer, an error occurred; if it is zero, no error occurred. Cross-platform warning messages do not affect the return code. If the -mrc option is specified, the return code is the same as would be found on the mainframe.

Message levels ERROR and WARNING can be controlled by compiler options. For example, the enforce (SAS/C mainframe Compiler) option or -w~n (SAS/C Cross-Platform Compiler) option can be used to turn any WARNING into an ERROR. Similarly, the suppress or -wn option can be used to make any phase 1 WARNING disappear. This chapter describes the default message level (that is, no options affect the message level).

Message Types

Compiler error messages can be either numbered or unnumbered. Numbered messages can be produced throughout compilation. Unnumbered messages generally refer to errors occurring during compiler option processing. Unnumbered messages appear at the end of this chapter.

When the compiler detects an error in an input file, it generates a diagnostic for numbered messages in the following form: 

   [message num]  Error in [file]  at line [line num]
                  before column [col num] : [text]
where
message num
is the message identifier number.
file
is the name of the current input file, which may be the name of a #include file.
line num
is the line number of the current line in the file.

col num
is the column where the error was detected. A vertical bar (|) can be placed in that column.
text
is a description of the condition responsible for producing the message.
Sometimes recovery from a single error may produce a succession of subsequent errors in a cascade effect. You should attempt to correct the obvious error or errors first and not be overly concerned about subsequent error messages for apparently valid source lines.

Message Numbering

Messages are numbered as follows:

Phase 1 Error and Warning Messages

Messages 001 through 199 and 400 through 499 describe syntax or specification errors or warnings in the source file. A number of messages may be issued as warnings under some conditions and as errors under other conditions. In such cases, the distinction between these conditions is documented. Warning messages generally indicate the use of non-portable or dubious C constructs, but do not prevent generation of object code. When warnings are generated, it is advisable to verify that the actual effect of the construct diagnosed is what was intended.

Phase 2 Error and Warning Messages

The second phase of the compiler generates diagnostics 200 through 299. These messages describe conditions encountered in the process of code generation. The suppress or -wn option cannot be used to ignore phase 2 error and warning messages.

Global Optimization Phase Error and Warning Messages

The global optimization phase generates diagnostics 300 through 399. For messages 301 and 305, examine the program source code to determine if the program is performing as intended. As with phase 2 errors, the suppress or -wn option cannot be used to ignore these error and warning messages.

Note: The LSCC prefix that appears when a diagnostic message is generated has been omitted in the following descriptions. Additionally, SAS/C Compiler and SAS/C Cross-Platform messages are not always identical, so the exceptions are noted in the explanatory text.

LSCC Messages

001

ERROR/WARNING: Invalid preprocessor command.

Explanation

This message was generated by a variety of errors in preprocessor commands, including specifying an unrecognized command, failing to include white space between command elements, or using an illegal preprocessor symbol. The warning is generated when the sizeof keyword or any cast expression in a #if command is used. Such uses are non-ISO/ANSI.

002

ERROR: Unexpected end of file.

Explanation

The end of an input file was encountered when the compiler expected more data. This error may occur in a #include file or the original source file. In many cases, correcting a previous error eliminates this error.

003

ERROR: File not found [filename].

Explanation

The filename specified in a #include command was not found.

004

ERROR: Invalid lexical token.

Explanation

An unrecognized element was encountered in the input file that cannot be classified as any of the valid lexical constructs (such as an identifier or one of the valid expression operators). This error may occur if control characters or other illegal characters are detected in the source file.

005

ERROR: Invalid macro usage: [macro]

Explanation

A preprocessor #define macro was used with the wrong number of arguments.

006

ERROR: Buffer overflow:expansion buffer.

Explanation

Expansion of a #define macro caused the compiler's expansion buffer to overflow. This error may occur if more than one lengthy macro appears on a single input line, or if a macro call is ill-formed by having too few right parentheses. In the following example, if MAC is a macro taking two arguments and a right parenthesis is omitted in its call, the preprocessor will continue past the semicolon, believing that it is still gathering arguments for the macro: 
   MAC(f(1),f(2);
Although there is no fixed buffer size, an expansion that requires more space than the longest logical line occurring thus far in the compilation may cause buffer overflow. This error rarely occurs.

007

ERROR: #include nesting level exceeded.

Explanation

The maximum extent of #include file nesting was exceeded; the compiler supports #include nesting to a maximum depth of 16.

008

ERROR: Invalid conversion.

Explanation

An invalid arithmetic or pointer conversion was specified. This error usually occurs when an attempt is made to convert something into an array, a structure, or a function.

009

ERROR: Undefined identifier [symbol].

Explanation

The named identifier had not been previously declared. This error is generated only once; subsequent encounters with the identifier assume that it is of type int (which may cause other errors).

010

ERROR: Invalid subscript expression.

Explanation

An error was detected in the expression following the left bracket character (presumably a subscript expression). This error may occur if the expression in brackets is null (not present).

011

ERROR: String too large or not terminated.

Explanation

If the closing double quote was omitted in specifying a string, the string is considered not to be terminated. There is no compiler-imposed limit on the size of a string. A string may be too large only if its size exceeds available memory.

012

ERROR: Invalid structure reference.

Explanation

The expression preceding the period (.) or ( {tf:spmath {ndx 80} }) structure reference operator was not recognized by the compiler as a structure or pointer to a structure.

013

ERROR: Member name missing.

Explanation

An identifier indicating the desired aggregate member was not found following the period (.) or ( {tf:spmath {ndx 80} }) operator.

014

ERROR: Undefined member [symbol].

Explanation

The indicated identifier was not a member of the structure or union to which the period (.) or ( {tf:spmath {ndx 80} }) referred.

015

ERROR: Invalid function call.

Explanation

The identifier preceding the ( function call operator was not implicitly or explicitly declared as a function.

016

ERROR: Invalid function argument.

Explanation

An invalid function argument expression followed the ( function call operator. This error may occur if an argument expression is omitted as in the following: 
   f(;
   f(.);
   f(,1);

017

ERROR: Too many operands.

Explanation

More than one operand was still awaiting evaluation when the compiler encountered the end of an expression. This error may occur if an expression contains an incorrectly specified operation.

018

ERROR: Unresolved operator.

Explanation

An operator was still awaiting evaluation when the compiler encountered the end of an expression. This message may occur if an operand is omitted for a binary operation.

019

ERROR: Unbalanced parentheses.

Explanation

The number of opening and closing parentheses in an expression was not equal. This error message may also occur if a macro is poorly specified or improperly used.

020

ERROR: Invalid constant expression.

Explanation

The compiler required a constant result but the expression did not evaluate to a constant. This error may occur if one of the operators present is not valid for constant expressions.

021

ERROR: Illegal use of aggregate.

Explanation

An identifier declared as a structure or union was used in a context requiring a non-aggregate.

022

WARNING: Floating point value assigned to shorter type.

Explanation

A floating-point value (float or double) was assigned to a shorter type, and precision could be compromised. The message is suppressed unless the enforce option (or cross-platform -w~n option) is specified.

023

ERROR: Invalid use of conditional operator.

Explanation

The conditional operator was used erroneously. This error may occur if the question mark (?) operator is present, but the colon (:) is not found where expected.

024

ERROR: Pointer operand required.

Explanation

The context of the expression required an operand be a pointer. This error may occur if the expression following does not evaluate to a pointer.

025

ERROR: Modifiable lvalue required.

Explanation

The context of the expression required that an operand be a modifiable lvalue. A modifiable lvalue is an expression that designates an object in memory that can be altered. For example, a simple variable (not declared const) is a modifiable lvalue. This error may occur if the expression following & is not a modifiable lvalue or if the left side of an assignment expression is not a modifiable lvalue. Note that a cast does not yield a modifiable lvalue.

026

ERROR: Arithmetic operand required.

Explanation

The context of the expression required that the operand be arithmetic (not a pointer, function, or aggregate).

027

ERROR: Arithmetic or pointer operand required.

Explanation

The context of the expression required that the operand be either arithmetic or a pointer. This error may occur for the logical OR and logical AND operators.

028

ERROR: Missing operand.

Explanation

An insufficient number of operands were available for evaluation by the time the end of an expression was encountered. This error may occur if a binary operation is improperly specified.

029

ERROR: Invalid pointer operation.

Explanation

An operation (other than addition or subtraction) was specified that was invalid for pointer operands. The compiler also detects attempts made to operate on a pointer to a structure, union, or enumeration whose tag has not been defined, as in the following code where the tag X was never defined: 
   struct X *p;
   .
   .
   .
   p++;

030

WARNING: Pointers do not point to same type of object.

Explanation

In an assignment statement defining a value for a pointer variable, the expression on the right side of the equal (=) operator did not evaluate to a pointer of the same type as the assigned or NULLpointer variable. The warning also occurs when a pointer of any type is assigned to an arithmetic object.

The same message is generated as an ERROR when an expression initializes a pointer to an int (or vice versa), or during a pointer comparison operation.

031

ERROR: Integral operand required.

Explanation

In the context of this expression, an operand must be an integer type. Valid integer types are char, int, short, long, unsigned char, unsigned int, unsigned short, or unsigned long.

032

ERROR: Invalid conversion specified.

Explanation

An expression was specified requesting a conversion from one data type to another data type for which there is no conversion rule.

033

ERROR: Illegal initializer expression.

Explanation

An attempt was made to initialize a variable that cannot be initialized. Also, a function cannot be initialized. An initialization cannot be part of the declaration of an extern variable that has been declared in function (or inner block) scope, as this example illustrates: 
   func()


   extern int count = 0;
   .
   .
   .

034

ERROR: Invalid initializer expression.

Explanation

An invalid expression attempted to initialize an object. This error may occur for a variety of reasons, including failure to separate elements in an initializer list with commas or to initialize an array to a single object. The following expressions are invalid: 
   char a [10] = 0;
   char b [3] = 1 2 3;

035

ERROR: Closing brace expected.

Explanation

The compiler expected but did not find a closing right brace while processing an initializer list, structure, or union member declaration list. This error may occur if too many elements are specified in an initializer expression list or if a structure member is improperly declared.

036

WARNING: Control cannot reach this statement.

Explanation

The compiler could not reach, and thus execute, the code in a statement. Examples of possible causes include: a preceding statement such as return, continue, or goto precipitating an unconditional transfer of control; code within a switch block that was not reachable via a case or default statement.

037

ERROR: Duplicate statement label [symbol].

Explanation

The specified statement label was encountered more than once while the current function was processing.

038

ERROR: Unbalanced braces.

Explanation

In a body of compound statements, the number of opening left braces ({) and closing right braces (}) was not equal. The compiler may have been out of phase because of a previous error.

039

ERROR: Invalid use of keyword [symbol].

Explanation

One of the C language reserved words appeared in an invalid context (for example, as a variable name).

040

ERROR: Break not inside loop or switch.

Explanation

A break statement was detected that was not within the scope of a while, do, for, or switch statement. This error may be caused by an error in a preceding statement.

041

ERROR: Case not inside switch.

Explanation

A case prefix was encountered outside the scope of a switch statement. This error may be caused by an error in a preceding statement.

042

ERROR: Invalid case expression.

Explanation

The expression defining a case value did not evaluate to an integral constant.

043

ERROR: Duplicate case value.

Explanation

A case prefix was encountered that defined a constant value already used in a previous case prefix within the same switch statement.

044

ERROR: Continue not inside loop.

Explanation

A continue statement was detected that was not within the scope of a while, do, or for loop. This message may be caused by an error in a preceding statement.

045

ERROR: Default not inside switch.

Explanation

A default prefix was encountered outside the scope of a switch statement. This message may be caused by an error in a preceding statement.

046

ERROR: More than one default.

Explanation

The compiler encountered a default prefix within the scope of a switch statement that already contained a default prefix.

047

ERROR: While missing from do statement.

Explanation

The while clause was expected but not found after the body of a do statement. This message may be caused by an error within the body of the do statement.

048

ERROR: Invalid while expression.

Explanation

The expression defining the looping condition in a while or do loop was NULL (not present). Indefinite loops must supply a constant, such as 1, if that is what is intended.

049

ERROR: Else not associated with if.

Explanation

An else keyword was detected that was not within the scope of a preceding if statement. This message may be caused by an error in a preceding statement.

050

ERROR: label missing from goto.

Explanation

A statement label following the goto keyword was expected but not found. This message may be caused by an error in a preceding statement.

052

ERROR: Invalid if expression.

Explanation

The expression following the if keyword was not present.

053

ERROR: Invalid return expression.

Explanation

The expression following the return keyword could not be converted to the type of the value returned by the function.

054

ERROR: Invalid switch expression.

Explanation

The expression defining the value for a switch statement could not be converted to an integral type.

055

WARNING: No case values for switch statement.

Explanation

The statement defining the body of a switch statement did not contain at least one case prefix.

056

ERROR: Colon expected.

Explanation

The compiler expected a colon (:), but did not find one. This error may be generated if a case expression is improperly specified or if the colon was omitted following a label or prefix to a statement.

057

ERROR: Semi-colon expected.

Explanation

The compiler expected but did not find a semicolon (;). Typically, the compiler completed the processing of a statement but did not find the statement terminator. This error may be caused by too many closing parentheses, too few closing braces, or a statement that is otherwise formed incorrectly.

058

ERROR: Missing parentheses.

Explanation

A parenthesis required by the syntax of the current statement was not present. For instance, no parenthesis was found after the while or for keyword. This error may also occur if a parenthesized expression is incorrectly specified, causing the compiler to end the expression early.

059

ERROR: Invalid storage class.

Explanation

A declaration at file scope specified an invalid storage class, such as auto or register. This message may be generated if previous errors have caused the compiler to misinterpret statements within a function as file-scope declarations.

060

ERROR: Incompatible aggregate types.

Explanation

Incompatible aggregate types were used in an expression, for example, attempting to assign a structure to a structure of a different type.

061

ERROR/WARNING: Undefined structure/union tag [symbol].

Explanation

This message accompanies use of an undefined structure or union tag, that is, a tag for which no members have yet been defined. This is an error if the context requires the size of the type, for instance, if an object of the type is declared or referenced. Otherwise, this is a warning. This warning is suppressed unless the strict option (or cross-platform -W1,-ll option) is used.

062

ERROR: Structure/union type mismatch.

Explanation

A name declared as a structure tag was used as a union tag or vice versa. Usage of the tag must be consistent within the scope of the tag.

063

ERROR/WARNING: Duplicate declaration of item [symbol].

Explanation

The indicated identifier has been defined more than once within the same scope. This error may be generated because of a preceding error, but it is generally the result of improper declarations. This message is issued as a warning if multiple __actual declarations of an __inline function are encountered.

064

ERROR: Structure contains no members.

Explanation

A declaration of the members of a structure or union did not contain at least one member name.

065

ERROR: Invalid function definition.

Explanation

An attempt was made to define a function body within another function or in some other inappropriate context. This message may be produced as the result of a previous error.

066

WARNING: Invalid array limit expression.

Explanation

The expression defining the size of a subscript in an array declaration did not evaluate to a nonnegative integer constant. This message also occurs if a 0 length is specified for an inner (that is, not the leftmost) subscript.

067

ERROR: Illegal object.

Explanation

A declaration specified an illegal object as defined by the ANSI/ISO Standard. Illegal objects include functions that return arrays, arrays of void, and arrays of functions.

068

ERROR: Illegal object for structure.

Explanation

A structure or union declaration included an object declared as a function. Although a structure or union may contain an element of function pointer type, functions are not permitted.

069

ERROR: Structure includes instance of self.

Explanation

The structure or union whose declaration was just processed contains an instance of itself, which is illegal. This error may be generated if the asterisk (*) is forgotten on a structure pointer declaration or if (due to some intertwining of structure definitions) the structure actually contains an instance of itself.

071

ERROR: Formal declaration error [symbol].

Explanation

A variable was declared before the opening brace of a function, but it did not appear in the list of formal names enclosed in parentheses following the function name.

072

ERROR/WARNING: Conflict with prior declaration of external: [symbol].

Explanation

An external item has been declared with attributes that conflict with a previous declaration. This error may occur when a function used earlier as an implicit int function returns some other kind of value. Functions that return a value other than int must be declared before they are used so that the compiler is aware of the type of the function value.

This message is issued as a warning if the type mismatch is harmless, for example, int/long, const/volatile, or char/unsigned char. The message is issued as an error if the mismatch is harmful.

073

ERROR: Declaration expected.

Explanation

In processing the declarations of objects, the compiler expected to find another declaration but did not. This error may be caused by a preceding error.

074

WARNING: Initializer data truncated.

Explanation

An array of char or wchar_t was initialized from a string literal, but the literal contained more characters (not including the ending null character) than the size of the array. The excess characters were discarded.

075

ERROR: Invalid sizeof expression.

Explanation

An invalid expression was the operand of sizeof. This message also may be generated if an attempt is made to take the size of a structure via a tag that has not been defined, or if an attempt is made to take the size of a function, bitfield, or incomplete type.

076

ERROR: Left brace expected.

Explanation

The compiler expected but did not find an opening left brace in the current context. This error may occur if the opening brace is omitted on a list of initializer expressions for an aggregate.

077

ERROR: Identifier expected.

Explanation

While processing a declaration, the compiler expected to find an identifier that was to be declared. This error may occur if the prefixes to an identifier in a declaration (parentheses and asterisks) are specified improperly, or if a sequence of declarations is listed incorrectly.

078

ERROR: Undefined statement label [symbol].

Explanation

A goto statement referred to a statement label but the compiler could not find the definition of the label.

079

WARNING: Duplicate enumeration value.

Explanation

More than one enumeration constant in an enumeration list was assigned the same numeric value.

080

ERROR: Invalid bitfield.

Explanation

This error is generated in the following circumstances:

081

ERROR: Preprocessor limit exceeded.

Explanation

This message is issued under one of two conditions: there are more than 65535 tokens on a source line, or a macro macro expansion generated more than 65535 tokens. To avoid this error, simplify the source line or, in the case of a macro expansion, simplify the macro.

082

ERROR: Maximum object/storage size exceeded.

Explanation

The size of an object exceeded the maximum legal size for objects in its storage class, or the last object declared caused the total size of declared objects for that storage class to exceed the maximum. See the SAS/C Compiler and Library User's Guide for the limits for any particular storage class.

083

WARNING: Reference beyond object size.

Explanation

An indirect pointer reference (usually a subscripted expression) used an address greater than the size of the object that was used as a base for the address calculation. This message generally occurs when the program refers to an element beyond the declared end of an array.

084

ERROR/WARNING: Redefinition of preprocessor symbol [symbol].

Explanation

A warning is issued if the compiler encountered a #define statement for an already-defined symbol. The symbol and the new statement specified a different replacement text (that is, it was a nonbenign redefinition).

A warning is issued unless the redef compiler option (or cross-platform -W1,-cr option) is specified. In that case, the previous declaration is stacked and reappears when a #undef statement for the symbol appears. The warning message is suppressed unless the enforce or strict option (or cross-platform -w~n or -W1,-ll option) is specified.

085

WARNING: Return value mismatch for function value [symbol].

Explanation

The expression specifying the return value of a function was not the same type as the function itself. If possible, the value specified is converted to the appropriate type. The warning serves as notification of the conversion. The warning can be avoided by using a cast operator to force the return value to the function type.

086

WARNING: Formal definitions conflict with type list.

Explanation

The compiler encountered a function definition, and a prototype was in scope for that function. One or more of the formal parameters in the definition conflict in type with the types specified in the prototype.

087

WARNING: Argument count incorrect.

Explanation

Although a prototype was in scope for this function, it specified a different number of arguments from the call. A function call may execute correctly with the wrong number of arguments in this implementation, but it is likely to cause portability problems.

088

WARNING: Argument type incorrect.

Explanation

Although a prototype is in scope for this function, the type of the argument does not match the type in the prototype. The argument is converted to the correct type. This message does not appear if only a simple widening conversion, such as char to int, is needed.

089

WARNING: Constant converted to required type.

Explanation

This message is the same as message 088 but is produced for an argument that is a constant; the conversion is done at compile time.

090

ERROR: Invalid argument type specifier.

Explanation

The type of an argument in a function prototype was unrecognized or invalid in this context (for example, void ).

091

ERROR: Illegal void operand.

Explanation

A void operand was found in a context where a value is required.

092

WARNING: Statement has no effect.

Explanation

A statement has no effect (including side effects), as this example illustrates: 
   x+2;
Although this statement is a valid C statement, it may not be what the programmer intended to write.

093

WARNING: No reference to identifier [symbol].

Explanation

The auto variable named in the message was declared but never used. Although this is valid C, it may not be what the programmer intended. Perhaps another variable was used where this one should have been used.

094

WARNING: Uninitialized auto variable [symbol].

Explanation

The named auto variable appeared to be used before it was assigned a value. This message may be generated for correct code, if at execution time non-sequential execution (possibly using goto or for statements) would cause the variable to be initialized before any use. Note that if the variable is inspected before it is initialized, its value is undefined.

Although uninitialized variables often, by chance, have the value 0, this is not (for auto variables) guaranteed by the ANSI/ISO Standard language definition. Changing the program or moving the program to another system can change the value and cause undefined program behavior.

095

WARNING: Symbol previously mapped.

Explanation

The symbol being mapped by a #pragma map statement has already been mapped by a previous #pragma map statement. The first #pragma map statement takes precedence.

096

WARNING: New pragma map symbol longer than 8 characters; truncated.

Explanation

The new symbol to which the old symbol is mapped cannot be longer than eight characters.

097

WARNING: Mapped name may conflict with other compiler-generated names.

Explanation

A new symbol violates the guidelines enumerated in Chapter 3, "Compiler Processing and Code Generation Conventions," of the SAS/C Compiler and Library User's Guide, and may conflict with symbols generated by the compiler.

099

ERROR: Attempt to change a const lvalue.

Explanation

Identifiers with the type qualifier const cannot be changed. Either the program uses the identifier incorrectly, or the const type qualifier should be removed from the declaration.

100

WARNING: No prototype declared for function [symbol].

Explanation

This message is issued only if the reqproto option (or cross-platform -W1,-cf option) is in effect. No prototype is in scope for the function at the time that a call is made to the function.

101

ERROR: Redundant keywords in declaration.

Explanation

A declaration contained one or more unnecessary keywords. For example, identifier xyz is declared as long long xyz.

102

ERROR: Conflicting keywords in declaration.

Explanation

A declaration contained keywords that specified conflicting type specifiers or storage-class specifiers. For example, the declaration short long xyz contains conflicting type specifiers. The declaration extern static xyz contains conflicting storage-class specifiers.

103

WARNING: Uninitialized constant [symbol].

Explanation

An auto or register const variable was not initialized. Constant values should be initialized at compile time since they cannot be changed at execution time, and their values will be unpredictable if they are not initialized.

104

WARNING: Conversion from pointer to const/volatile to pointer to non-const/volatile.

Explanation

An attempt was made to convert a pointer to a const object to a pointer to a non-const object, or from a pointer to a volatile object to a pointer to a non-volatile object. If a pointer to non-const is used to modify an object declared as const, a protection exception or other incorrect results may occur. If a pointer to non-volatile is used to access an object declared as volatile, the results are unpredictable.

105

WARNING: Function prototype not allowed for non-C function (except Assembler).

Explanation

A prototype cannot be used to declare a function that is declared with one of the interlanguage communication keywords such as __fortran, __cobol, etc.

107

ERROR: Too many initializers.

Explanation

More initializers were specified than the number of aggregate elements to be initialized.

109

ERROR: Invalid use of type name or keyword.

Explanation

The user attempted to use a typedef name or keyword where an identifier or lvalue was expected.

110

ERROR: Execution terminated.

Explanation

End of file (EOF) was found unexpectedly on the compiler input file, for example, in the middle of a function. This error may be caused by mismatched braces, an unclosed comment, or unclosed quotes in a char literal.

111

WARNING: External name longer than 8 characters [symbol].

Explanation

Due to restrictions imposed by the IBM linkage editor, externally visible names are truncated to eight characters in the object deck. If you prefer to use long external names, the first eight characters must be unique or multiple names will resolve to the same linkage-editor symbol. This problem will not occur if the extname option is specified.

112

WARNING: Extraneous information in include file name: [symbol].

Explanation

The name of a system header file (that is, one included in angle brackets) ended with a qualifier other than ".h" or ".H". The qualifier was ignored. 
    #include [filename] [name.ext].

113

WARNING: Unable to open specified file, will attempt to include [filename].

Explanation

Mainframe only: The compiler could not open an include file specified as #include "[name.h]". It attempts to recover by opening the file as if it had been specified by #include <name.h>.

114

ERROR: Floating point constant out of machine range.

Explanation

A floating-point constant was outside the range of numbers supported by IBM 370 architecture machines, which cannot handle a number whose absolute value is greater than approximately 7.23e75 or a nonzero number whose magnitude is less than approximately 5.4e-79.

115

ERROR: Invalid record size (>1024 bytes).

Explanation

Mainframe only: Source fed to the compiler had a line with length greater than 1024. Input to the compiler can be in either fixed or variable length records up to 1024 bytes in length. This message is also produced if an input record contains a null (0x00) character.

116

ERROR/WARNING: Undefined enum tag [symbol].

Explanation

The indicated enum tag was not previously defined. The message is issued as an error if an attempt is made to define an enumeration by means of the undefined tag. Declarations that are not definitions cause the message to be issued as a warning.

117

ERROR: Enum contains no members.

Explanation

A declaration of an enum type did not define at least one enumeration constant.

118

ERROR: Conflicting use of enum/struct/union tag [symbol].

Explanation

A name was declared as one sort of tag (struct, union or enum) within a scope, and then referenced as another sort. Usage of the tag must be consistent within its scope.

119

ERROR: Identifiers missing from definition of function [symbol].

Explanation

A function definition was given in prototype format, but one or more parameter names were omitted from the prototype. Make sure that a name is specified for each parameter.

121

WARNING: Hex/octal constant too large (high bits are lost).

Explanation

A hexadecimal or octal constant specified a value that is too large (greater than 255) to fit into a char object. The compiler ignores all but the last eight bits in the constant. For example, if the constant x1234 is specified, the warning is issued and the constant is treated as equivalent to x34. The prefix L may be employed to specify a wide character constant as in L'x12x34'.

122

WARNING: Missing ellipsis.

Explanation

The last parameter in a function prototype was followed by a comma. Either the comma is superfluous or an ellipsis (...), which indicates that unspecified parameters may follow the last declared parameter, is missing.

125

ERROR: Invalid number.

Explanation

A token appeared to be a number but contains nonnumeric characters. If the number is intended to be a hexadecimal constant, then one or more of the digits is not in the range 0-f. If it is intended to be a floating-point constant, it does not follow the allowed syntax.

This message can also be generated if a number beginning with a 0 contains an invalid octal digit, for example 08.

126

WARNING: #endif, #else, or #elif out of order.

Explanation

One of the preprocessor directives named was encountered unexpectedly. For instance, a #endif directive was read with no previous unmatched #if or #ifdef.

127

ERROR: Operand to # operator must be a macro argument.

Explanation

The operand of a # operator must be one of the arguments calling to the macro.

128

{mono ERROR: [ {ob text} ]}

Explanation

A #error directive was encountered by the preprocessor. The text of the message is specified by the #error directive.

129

ERROR: Ambiguous member [symbol].

Explanation

One of the members declared for an anonymous union has the same name as a member in the containing structure or the same name as a member of another anonymous union in the containing structure. Member names in anonymous unions are in the same name space as member names in the containing structure.

131

ERROR: Invalid or unsupported use of at-sign operator.

Explanation

The @ operator only can be used in the argument list of a function call.

132

WARNING: Extra tokens after valid preprocessor directive.

Explanation

One or more unexpected or incorrect tokens were found following a preprocessor directive. The tokens may need to be removed, or they may need to be specified correctly.

133

ERROR: Cannot redefine macro [symbol].

Explanation

The __LINE__, __FILE__, __STDC__, __DATE__, and __TIME__ macro names cannot be used in a #define or #undef preprocessor directive.

134

ERROR: Too many arguments

Explanation

The maximum number of macro arguments is 31.

136

ERROR: Invalid use of register keyword.

Explanation

The register storage class specifier can be used only in the declaration of a formal parameter or auto variable for integer, floating-point, and pointer types.

139

WARNING: Missing #endif.

Explanation

The preprocessor expected a #endif preprocessor directive to terminate a previous #if or #ifdef directive.

140

WARNING: Sizeof operator used on array that has been converted to pointer.

Explanation

Formal arrays are converted to pointers. When the sizeof operator is applied to a formal array, the return value is the size of the pointer, not the size of the array.

142

ERROR/WARNING: Array size never given for [symbol].

Explanation

This message occurs for an incomplete array definition. When the size of an array is not defined at the first opportunity, some compilers conforming to ANSI may not accept this even if the size is supplied later. For both externally visible and static arrays, the size must be supplied before the end of the compilation.

143

ERROR: Object has no address.

Explanation

register variables and bitfields cannot have their addresses taken.

144

ERROR: Combined storage for strings and constants exceeds maximum.

Explanation

The combined size of all the character string literals and const- qualified objects exceeds 2 gigabytes.

145

WARNING: #include file name or suffix truncated to 8 characters.

Explanation

Mainframe only: Either the member name or the DDname specified in a #include preprocessing directive exceeded eight characters in length. The name is truncated on the right.

147

WARNING: Conversion between function and data pointers.

Explanation

The ANSI/ISO Standard states that function pointers cannot be converted to data pointers and vice versa. Even though the conversion can be performed in this implementation, other compilers may not accept the conversion. The compiler flags the statement as a possible portability problem.

148

WARNING: Use of incomplete struct/union/enum tag [symbol].

Explanation

Compilers predating the ANSI/ISO standard may not support this use of an incomplete structure, union or enum type. The compiler flags this statement as a possible portability problem. This message is suppressed unless the strict option is used.

149

WARNING: Undefined struct/union/enum tag in prototype scope [symbol].

Explanation

The compiler has detected the use of a tag in a prototype that has not been defined previously. The ANSI/ISO Standard defines a separate scope for tags in a function prototype. Tags defined after the prototype are not in the scope of the prototype and are considered to be in a different scope. struct, union, and enum tags that are used in a function prototype should be defined before the prototype.

150

ERROR: Conversion to different struct | union | enum type.

Explanation

An attempt was made to assign the value of a structure, union, or enumeration to one of a different type.

152

ERROR: Cannot define function via typedef name.

Explanation

The ANSI/ISO Standard does not allow a function to be defined using a typedef name. Specifically, the following is not permitted: 
   typedef int FNC(void);

   FNC f {/* ... */}

154

WARNING: No prototype declared for function pointer.

Explanation

A function call via a function pointer was detected, but there is no prototype in scope for the function pointer. This message is suppressed unless the reqproto option (or cross-platform -W1,-cf option) is used.

155

WARNING: No statement after label.

Explanation

A statement label appeared followed immediately by a closing brace. This syntax is not permitted by the ANSI/ISO standard. You can correct this problem by adding a null statement (;) after the label. 
   switch(i) {
         .
         .
         .
         default: ;    }

156

WARNING: Operation/comparison of pointer to int and pointer to [type].

Explanation

In many implementations of C, values of type pointer to int may not be compared with or assigned to variables of type pointer to short or pointer to long. The compiler flags the statement as a possible portability problem. This message is suppressed unless the strict option (or cross-platform -W1,-ll option) is used.

158

ERROR: Invalid type name [symbol].

Explanation

This message is issued in two circumstances: first, when a cast contains a name that is not a type name; second, when the offsetof macro is used incorrectly. This macro requires a structure type name as its first argument.

159

WARNING: Use of unary minus on unsigned value [symbol].

Explanation

Using a unary minus operator on a variable of unsigned type frequently produces unexpected results because unsigned types cannot have a negative value. Examine the program to ensure that the operator will have its intended effect. This message is suppressed unless the strict option (or cross-platform -W1,-ll option) is used.

161

WARNING: No prototype declared at definition for function [symbol].

Explanation

A function has been defined for which no prototype is in scope. This message is suppressed unless the reqproto option (or cross-platform -W1,-cf option) is used.

162

WARNING: Non-ANSI use of ellipsis punctuator.

Explanation

The compiler detected an ellipsis (...) used in a way other than as defined by the ANSI/ISO Standard. The Standard allows an ellipsis only in a function declaration to indicate that the function accepts a variable argument list. It also requires that a prototype contain at least one parameter, and a function may take one or more arguments but not zero arguments.

This compiler supports the following non-standard construction, which indicates that func is a function returning an int that takes zero or more arguments: 

   int func(...)
However, in such cases, this warning is issued to point out the divergence from standard use.

165

WARNING: Use of narrow type in prototype.

Explanation

A narrow argument type such as char, short, or float was specified in a prototype. Such arguments will not be widened in a function call. Because the behavior will be different in a context where no prototype is in scope, this message indicates a potential problem if all uses of the function are not within scope of a prototype.

166

ERROR: Unrecoverable error or too many errors -- terminating the compilation.

Explanation

The compiler has detected an error that prevents further compilation, or too many errors have been detected to allow compilation to proceed. Correct the previous error or errors and recompile.

167

ERROR: This function type should not be defined in C: [type].

Explanation

The __asm function prefix may only appear in function declarations which are not definitions.

168

WARNING: Assignment of long to [symbol].

Explanation

This message (which is suppressed by default) is issued if a long is assigned to a short or int. It is intended to warn of possible truncation and portability problems.

169

WARNING: Incompatible operands of conditional operator.

Explanation

The types of the second and third operands of a conditional operator (?) do not agree. Use casts to ensure that the types match.

170

WARNING: Overflow during operation on constants.

Explanation

The compiler detected an overflow condition while evaluating a constant expression. The value of the expression is unpredictable. Correct the expression and recompile.

175

ERROR: Structure qualifiers do not match previous declarations of structure [symbol].

Explanation

__alignmem or __noalignmem keywords in the named structure declaration did not match a previous declaration of the same tag.

176

WARNING: Implicitly promoted formal conflicts with prototype.

Explanation

The prototype for a function specified an argument with a narrow type (char, short or float). The function definition was not in prototype format, which implies that all arguments should be widened. This discrepancy between the prototype and the function definition is not standard-conforming, and may lead to incorrect results with some C compilers. Either correct the prototype to specify the widened type, or use the prototype format in the function definition.

180

WARNING: No space between macro name and its replacement list.

Explanation

The preprocessor detected the end of a macro name but found no white space following the name. This message may occur when an illegal character, such as a dollar sign, is used in a macro name and the dollars option (or cross-platform -W1,-cd option) has not been specified. However, if the only error in the macro was the omission of white space following the macro name, the macro will work as intended.

181

WARNING: Function declared static but defined external [symbol].

Explanation

The declaration of the named function indicated the static storage class, but the function is defined without the static keyword.

182

WARNING: Static function declared but not defined [symbol].

Explanation

The named static function has a declaration but is not defined in the compilation.

183

WARNING: Inline function declared but not defined [symbol].

Explanation

The named in-line function has a declaration but is not defined in the compilation.

184

WARNING: Multiple characters in integral character constant.

Explanation

An integral character constant contains more than one single- or multibyte-character constant. This is permitted, but the effect is highly non-portable.

185

ERROR: Comma expected.

Explanation

In a function prototype or parameter definition, invalid text was encountered instead of a comma following an argument.

186

WARNING: Implicit conversion between pointer and scalar.

Explanation

This message is generated if a static or extern pointer variable is initialized using a scalar value. A cast should be used to perform the conversion to a pointer type explicitly.

187

WARNING: Negative value assigned to unsigned type.

Explanation

Since an unsigned variable cannot hold negative values, the assignment may not produce the expected results. The message can be eliminated by using a cast, which also clarifies the purpose of the assignment. This message is suppressed unless the strict option (or cross-platform -W1,-ll option) is used.

188

ERROR: Ambiguous use of ILC language keyword.

Explanation

In a complicated declaration, the compiler was unable to determine the function type qualified by a language keyword such as __fortran. The following code shows a pointer to a function returning a pointer to a function that returns a pointer to int: 
   __pli int * (* (* ab)( ) ) ( );
In this case, however, the compiler cannot tell whether the first function or the second is in PL/I. Specify language keywords directly before the * (for function pointers) or the name (for functions). For example: 
   int * (__pli * (* ad ) ( ) ) ( );
This code shows a pointer to a function returning a pointer to a PL/I function that returns a pointer to int.

192

ERROR: Malformed double-byte characters.

Explanation

The compiler used a locale that supports DBCS but the source file contained malformed DBCS characters. A source file containing two successive SO characters, for example, would cause this error.

193

WARNING: Mixed types in string concatenation - using original type.

Explanation

The compiler attempted to concatenate a character-string literal and a wide-string literal. All string literals in a concatenation must be of the same type. The compiler uses the type of the first string literal in the concatenation.

194

ERROR: DBCS used outside of comment, character constant or string.

Explanation

The compiler used a locale that supports DBCS, but DBCS characters were found outside of the allowed contexts. The ANSI/ISO Standard specifies that DBCS characters can appear only in comments, characters constants, string literals, and header filenames.

195

WARNING: Multiple characters in wide character constant.

Explanation

A wide-character constant contained more than one character. Only one wide character will fit into a wchar_t.

196

ERROR: AT option required when using @ operator.

Explanation

The compiler does not accept the @ operator unless the at option (or cross-platform -Kat option) is used. Recompile the program using the at option (or cross-platform -W1,-ca option).

198

WARNING: No external functions or data defined.

Explanation

This warning is produced at the end of a compilation if no externally visible data or functions are defined in the source module.

201

ERROR: Unable to open pass 2 print file. Using stderr.

Explanation

Mainframe only: The listing file for phase 2 could not be opened. Phase 2 messages are written to stderr instead. stderr also should be inspected for information on why the phase 2 listing file failed to open.

202

WARNING: Empty object module.

Explanation

The input source file contained no externally visible functions or data so an empty object module was generated. This may be due to conditional compilation or optimization eliminating static functions that could not be called from this or any other compilation.

204

WARNING: Item is wrong size for conversion to pointer.

Explanation

A char or short item was converted to a pointer. However, since all pointers on the IBM 370 are 4 bytes in length, it is unlikely that the input item will convert to a valid pointer. However, code to do the conversion is generated.

207

WARNING: Default section name [first function name] is too long. Section name truncated to 7 characters.

Explanation

The default section name (the name of the first function in the compilation) was longer than seven characters. The section name is used to create various external names by suffixing it with special characters that cannot be used in valid C names. A section name longer than seven characters is truncated to seven characters before suffixing. Truncation can lead to duplicate names (and an unexecutable program) if another compilation has used the same section name.

Since this message appears for the default section name only, you can avoid it by supplying the sname option (or cross-platform -Ksname option), which is limited to seven characters.

210

ERROR: Wrong number of parameters for built-in function. An actual function call has been generated.

Explanation

Built-in function arguments were incorrect in type or number for the generation of in-line code. Consequently, a true function call was generated instead, which executes more slowly than the in-line code. Furthermore, the arguments may also be incorrect for the true function, causing an error when the function call is executed.

This message is rare because the library prototypes for built-in functions ensure correct parameters in most cases. However, it can occur if a library prototype is removed from the header file.

211

ERROR: A constant has an invalid type or value, (unsigned) 1 was used instead.

Explanation

An incorrect type, such as double instead of int, was specified for a constant argument to a built-in function. The compiler substitutes an unsigned constant 1.

212

ERROR: Maximum number of extended external names exceeded.

Explanation

The source file declared more extended external names than the compiler could support. This rare occurrence should be reported to the SAS Software Representative for C Compiler Products at your site. Refer to the SAS/C Compiler and Library User's Guide for more information about the maximum number of extended external names.

213

ERROR: Maximum number of extended function names exceeded.

Explanation

The source file declared more extended function names than the compiler could support. This rare occurrence should be reported to the SAS Software Representative for C Compiler Products at your site. Refer to the SAS/C Compiler and Library User's Guide for more information about the maximum number of extended function names.

214

NOTE: No extended names found.

Explanation

This message appears if the extname option (or cross-platform -Kextname option) is specified and no extended names are found.

215

NOTE: No extended names defined.

Explanation

This message appears if the enxref option (or any of the cross-platform -Wl,-xxe, -Wl,-xxs, -Wl,-xxx, or -Wl,-xxy options) is specified and no functions or variables with extended names are defined.

216

ERROR: Unsupported use of __remote with pflocal or __asm function.

Explanation

An attempt was made to convert a __local or __asm function pointer to a __remote function pointer. This conversion cannot be performed, because the source function pointer contains no PRV information. Note that this message can be generated for an unqualified function pointer if the pflocal compiler option is used.

217

ERROR: Pointer to FILE required for this built-in function parameter.

Explanation

The first parameter of __builtin_getc or the second parameter or __builtin_putc must be a pointer to the FILE type.

220

ERROR: Register mask is not a compile-time constant.

Explanation

The register mask argument to the _ldregs, _stregs, _code , and branch functions must be a compile-time constant so the compiler can know what registers are needed.

221

ERROR: Undefined bits set in register mask.

Explanation

The register mask had an undefined bit set to 1. Bits 0 through 15 in the register mask represent general purpose registers; bits 16, 18, 20, and 22 represent floating-point registers. The remaining bits must be set to 0. Use combinations of the macro symbols defined in <regs.h> to create the register mask.

222

ERROR: Register mask does not match number of function parameters.

Explanation

The register mask specified a number of registers that do not match the number of parameters to the function. The register mask used in the _ldregs function must define a number of registers that matches the number of parameters (excluding the mask) in the function call.

The register mask used in the _stregs function must define a number of registers that either equals the number of other parameters in the function call or exceeds that number by one.

223

ERROR: Register mask specifies unsupported register(s).

Explanation

The register mask referred to a register that could not be used. The mask may contain a bit that does not correspond to a hardware register, or may specify a register reserved to the compiler. See the SAS/C Compiler and Library User's Guide for information on registers that can be used by machine code functions.

224

ERROR: Parameter must be address or pointer.

Explanation

The compiler expected a pointer argument in a call to the _stregs built-in function, but one was not supplied. All arguments to the _stregs function (except the register mask) must be pointers.

225

ERROR: SVC number must be a compile-time constant in the range 0-255.

Explanation

The operand of the IBM 370 SVC instruction must have a value between 0 and 255.

226

ERROR: DIAGNOSE number unsupported or not a compile-time constant.

Explanation

The number specified as the argument to the _diag function was not a compile-time constant. The number must be a constant, since it forms a part of the generated machine instruction.

227

ERROR: Parameter must be a constant in the range 0-0xFFFF.

Explanation

Arguments two through five to the _code function must be halfword constants.

228

ERROR: Structure or union parameter cannot be loaded into a register.

Explanation

A variable of structure or union type was passed to the _ldregs function. Inspect the function arguments to see if an & operator has been omitted.

229

ERROR: Inline machine code sequence does not begin with _ldregs.

Explanation

A call to builtin_code (or some other machine code function) was made without a previous call to __builtin_ldregs, which must immediately precede any sequence of calls to other inline machine code functions. This message can occur if some C code intervenes between a call to __builtin_ldregs and a call to another inline machine code function.

230

ERROR: Register mask does not specify a result register.

Explanation

A call was made to __builtin_stregs with a parameter, but the value of that parameter, the register mask, did not specify a result register.

231

ERROR: _stregs not preceded by _ldregs. (_stregs operand may be too complex.)

Explanation

Similar to message 229, a call to __builtin_stregs must be preceded by a call to __builtin_ldregs. No C code other than calls to inline machine code functions may appear between the call to __builtin_ldregs and the call to __builtin__stregs. The generation of code will be halted if the operands of the __builtin_stregs function are overly complex, since they may force interruption of the inline code sequence to compute the target addresses.

232

ERROR: Unsupported opcode, mask, or index register for branch.

Explanation

A call to the __builtin_branch function specified an invalid opcode, register mask, or index register.

236

ERROR: Error in debugging file: [description]

Explanation

This error will be generated when the compiler encounters problems in either reading or generating the debugging information. On MVS, this is frequently caused by a lack of available space in the PDS where the debugging file is to be stored. The <description> offers some explanation about the problem the compiler encountered.

238

ERROR: Problem processing __builtin function '[function name]', possibly incorrect type or number of arguments.

Explanation

Either the wrong number or wrong types of parameters was passed to a __builtin function, causing the function to be replaced with an actual function call. However, the calling function does not have a DSA, and thus cannot support the call.

301

WARNING: Indirect reference through NULL pointer.

Explanation

The program being optimized contained code to dereference a pointer with a NULL value. The results of such a dereference are undefined but may well include an addressing exception or 0C4 abend.

302

WARNING: Type punning involves representation change [symbol].

Explanation

An object defined with one type was used as a dissimilar type, for example, a long object was accessed as a pointer. This message can occur when an assignment is made to a member of a union, and then the value is accessed from a different member of the union. It can also occur when an address to data of one type is used to access data of a dissimilar type by means of a cast.

303

WARNING: Reference has overlapping definition [symbol].

Explanation

A storage reference was determined by the optimizer to overlap an object or an element of an object. The effect of such accesses is not defined by the ISO/ANSI C standard. The warning indicates that optimization of the code may change its effect from what was intended. If the code cannot be rewritten in a more portable fashion, it is recommended to disable optimization for this source file.

304

WARNING: Dead assignment eliminated [symbol].

Explanation

[symbol] was assigned a value on the indicated line, but the value was never used. The assignment was therefore eliminated.

305

WARNING: Uninitialized variable [symbol].

Explanation

The named identifier was not initialized before it was used. The value resulting is unpredictable.

306

NOTE: [reason] function inlined: [function name] from line [number].

Explanation

This message occurs as a consequence of multiple levels of inlining. The value [number] is the line number of the call. The named function was expanded inline on the line cited in the message. The line [number] is included only when the location at which the call was expanded differs from the location of the call.

The [reason] indicates whether the __inline keyword, complexity=[c] option, or local option caused the inlining to occur. The [c] represents the complexity of the function, not the value of the complexity=[c] option.

Although the cross-platform form of the complexity=[c] option is -Oic=[number], the value for [reason] will assume the "complexity" form even when the cross-platform compiler is used.

307

WARNING: Return value missing in inline function.

Explanation

The indicated line is a return from a function which has been inlined. A caller of the function uses the returned value, but the return statement does not specify one.

308

WARNING: Inline function does not use formal parameter [symbol].

Explanation

The indicated line is a call that has been inlined. [symbol] is the name of a formal parameter that is not used in the function.

309

WARNING: Integer operation overflows.

Explanation

This message is generated when the cross-platform compiler detects that an integer computation overflows.

315

WARNING: Static variable is unreachable

Explanation

Control flow cannot reach a use of this variable. The optimizer removes the variable because the variable is effectively unused, so no storage is allocated for it.

316

WARNING: Static function is unreachable

Explanation

This static function cannot be called because control flow cannot reach a call to this function. In some cases this message might be issued because the C++ translator creates static virtual functions which are never actually called, and so can be eliminated by the optimizer.

317

WARNING: Possibly uninitialized variable

Explanation

This message is issued because initialization of a variable took place inside conditionally executed code. The optimizer cannot determine whether it is possible for the variable to be referenced before it is initialized. The code may be correct even though the optimizer cannot guarantee this.

400

WARNING: Invalid comparison of pointer and scalar.

Explanation

The expression contains a relational or equality operator with a pointer and an arithmetic operand. Either both operands must have arithmetic type or both must be pointers.

401

ERROR: Illegal pointer subtraction for void pointers.

Explanation

void * pointers cannot be used in arithmetic expressions because they point to objects that have no size.

402

WARNING: Function declared/defined static was previously declared extern:[symbol].

Explanation

A declaration or a definition of a static function was found, but a previous declaration of the function omitted the static keyword. This message is suppressed unless the strict option (or cross-platform -W1,-ll option) is specified.

404

WARNING: Variable name conflicts with typedef name.

Explanation

An identifier was declared in an inner scope with the same typedef name that had been declared in an outer scope. The typedef was hidden in the inner scope declaration. This message is suppressed unless the strict option is specified.

405

WARNING: Extraneous braces in initializer expression.

Explanation

An initializer expression contains more braces than required. Check the syntax of the expression to make sure that it is correct. This message is suppressed unless the strict option (or cross-platform -W1,-ll option) is specified.

406

WARNING: 'If' condition always [true | false].

Explanation

The compiler determined that the condition in the if statement was a constant expression. If the condition is true, the compiler only generates code for the then branch. If the condition is false, the compiler only generates code for the else branch.

407

WARNING: Assignment statement as 'if' condition.

Explanation

An assignment operator (=) was used when an equality operator (==) may have been intended.

409

WARNING: Function declared static within a block.

Explanation

The compiler ignores the static keyword if it is used in a function declaration in an inner block. Static functions cannot be declared in inner blocks.

412

ERROR: Size of object is unknown.

Explanation

The type of one of the operands in an aggregate (structure or union) assignment is incomplete, and its size cannot be determined. This situation can occur when a structure or union tag declares a variable, but the tag itself has not been defined.

413

WARNING: Comparison of unsigned value and constant is always [true | false].

Explanation

Comparison of an unsigned value and a signed constant yielded either a true or false value.

For example, this comparison will always be false because ui can never be a negative value: 

   unsigned int ui;
   if (ui < 0 ) ...
The compiler does not generate code to perform the test, nor does it generate any code for the true branch of the if statement.

414

WARNING: Conversion of negative constant to unsigned type.

Explanation

A negative constant value was assigned to an unsigned variable. The assignment may occur in a function call or an initialization. For example, the following statement sets all bits to 1 in an unsigned long: 
   static unsigned long u1 = -1;
The compiler issues a warning message in this case. A more correct method of setting all bits to 1 is as follows: 
   static unsigned long u1 = 0xffffffff;

416

WARNING: Trailing comma in enum declaration.

Explanation

An enumerator may be missing in the enumerator list of an enum declaration.

418

WARNING: Empty argument to a preprocessor macro.

Explanation

A null macro argument was specified using two consecutive commas or a comma followed by an open parenthesis. The preprocessor replaced the argument with a string of zero length. For example, in the following macro definition cat(X,,Z) produces XZ: 
   #define cat(a,b,c) a##b##c
This message is suppressed unless the strict option (or cross-platform -W1,-ll option) is specified.

419

ERROR: Unexpected I/O error.

Explanation

An I/O error occurred while reading an input source file. Refer to the library messages in stderr for more information.

420

WARNING: Argument type is unsupported for __ref functions.

Explanation

An argument to a __ref function is of a type that cannot have the @ operator applied to it. For instance, an attempt was made to pass a bitfield to a __ref function.

421

WARNING: Symbol exceeds maximum length: [symbol].

Explanation

The named [symbol] is longer than the maximum allowable number of characters for symbols of this type. By default, the compiler allows 31 characters for symbols with internal linkage. If the extname option is specified, an identifier can be up to 64K characters long. This message is suppressed unless the mention option is specified.

422

WARNING: Unknown option [name].

Explanation

The named option has been specified in a #pragma options statement but is not a recognized compiler option. The option may be misspelled, or it may be a command-line-only option.

423

WARNING: Option does not accept argument [name].

Explanation

The named option, specified in a #pragma options statement, does not accept an argument in parentheses.

424

WARNING: Invalid argument to option [name].

Explanation

The argument specified for an option in a #pragma options statement is invalid or out of range.

426

WARNING: Invalid option in pragma: [name].

Explanation

During processing of a #pragma options statement, the compiler found the specified symbol instead of an option name.

427

WARNING: Option not allowed in options pragma: [name].

Explanation

The named option can only be used on the command line.

428

WARNING:Option can not be negated: [name].

Explanation

Mainframe only: The named option cannot be prefixed with no. For example, nopagesize is not a valid option.

429

WARNING: Static prototype in included file.

Explanation

A static function has been declared in a header file instead of a primary source file. This warning is suppressed unless the mention option (or cross-platform +n option) is specified.

430

WARNING: Non-static prototype in main source file.

Explanation

An external function was declared in the primary source file instead of a header file. This warning is suppressed unless the mention option (or cross-platform -W1,+n option) is specified.

433

WARNING: Only first dimension may be undefined.

Explanation

Only the first or outer most dimension of a declaration of an array may be left undefined.

435

WARNING: Assignment to non-const __norent variable will prevent reentrancy.

Explanation

A variable has been declared as __norent in a compilation using the rent or rentext option, but the const qualifier was not specified. This implies that the variable may be assigned elsewhere in the program. If, in fact, the variable is assigned elsewhere, the program will be non-reentrant.

436

WARNING: Initialization prevents reentrancy.

Explanation

The initialization of the variable will prevent the program from being reentrant. This message is generated because one or more elements of the item being initialized have a type which cannot be initialized before execution time. See the discussion of the __norent keyword in the SAS/C Compiler and Library User's Guide for more information

437

WARNING: Operation/comparison of pointer to char and pointer to [type].

Explanation

In some implementations of C, values of type pointer to char may not be compare or assigned to pointers of other types. The compiler flags the statement as a possible portability problem.

This message is suppressed unless the strict option (or cross-platform -W1,-ll option) is used.

438

WARNING: Application of this linkage request is invalid.

Explanation

#pragma linkage was specified for an identifier declared with a conflicting keyword, such as __ref. Either remove the conflicting keyword or the #pragma linkage directive.

441

WARNING: Assignment of int to short.

Explanation

A signed or unsigned int was assigned to a short or unsigned short. Data truncation may occur. This message is suppressed unless the strict option (or cross-platform -W1,-ll option) is used.

442

WARNING: Function declared with two different types: [function name]

Explanation

The function specified in the message was declared as having two conflicting types.

443

WARNING: Assignment of short to char.

Explanation

A signed or unsigned short was assigned to a char (possibly signed or unsigned). Data truncation may occur. This message is suppressed unless the strict option (or cross-platform -W1,-ll option) is used.

444

WARNING: Assignment of int to char.

Explanation

A signed or unsigned int was assigned to a char. Data truncation may occur (possibly signed or unsigned). This message is suppressed unless the strict option (or cross-platform -W1,-ll option) is used.

445

WARNING: Assignment of long to char.

Explanation

A signed or unsigned long was assigned to a char. Data truncation may occur (possibly signed or unsigned). This message is suppressed unless the strict option (or cross-platform -W1,-ll option) is used.

446

WARNING: Assignment of long to short.

Explanation

A signed or unsigned long was assigned to a signed or unsigned short. Data truncation may occur. This message is suppressed unless the strict option (or cross-platform -W1,-ll option) is used.

447

WARNING: Constant assignment too large for char.

Explanation

A constant with a value greater than the maximum value for type char was assigned to a variable of type char. This message is suppressed unless the strict option (or cross-platform -W1,-ll option) is used.

448

WARNING: Constant assignment too small for char.

Explanation

A constant with a value smaller than the minimum value for type char was assigned to a variable of type char. This message is suppressed unless the strict option (or cross-platform -W1,-ll option) is used.

449

WARNING: Constant assignment too large for unsigned char.

Explanation

A constant with a value greater than 255 was assigned to a variable of type unsigned char. Data truncation will occur.

450

WARNING: Constant assignment too small for unsigned char.

Explanation

A constant with a value less than 0 was assigned to a variable of type unsigned char. Data truncation will occur.

451

WARNING: Constant assignment too large for signed char.

Explanation

A constant with a value greater than 127 was assigned to variable of type signed char. Data truncation will occur.

452

WARNING: Constant assignment too small for signed char.

Explanation

A constant with a value less than -128 was assigned to a variable of type signed char. Data truncation will occur.

453

WARNING: Assignment of long constant to char.

Explanation

A constant of type long was assigned to a variable of type char. This may indicate a portability problem, as data truncation could occur on a different platform. This message is suppressed unless the strict option (or cross-platform -W1,-ll option) is used.

454

WARNING: Constant assignment too large for short.

Explanation

A constant whose value is greater than the maximum value for the type short was assigned to a variable of type short. Data truncation will occur.

455

WARNING: Constant assignment too small for short.

Explanation

A constant with a value smaller than the minimum value for type short was assigned to a variable of type short. Data truncation will occur.

456

WARNING: Constant assignment too large for unsigned short.

Explanation

A constant whose value is greater than the maximum value for the type unsigned short was assigned to a variable of type unsigned short. Data truncation will occur.

457

WARNING: Constant assignment too small for unsigned short.

Explanation

A constant with a value smaller than the minimum value for type unsigned short was assigned to a variable of type unsigned short. Data truncation may occur.

459

WARNING: Assignment of long constant to short.

Explanation

A constant of type long was assigned to a variable of type short. This may indicate a portability problem, as data truncation could occur on a different platform. This message is suppressed unless the strict option (or cross-platform -W1,-ll option) is used.

460

WARNING: Constant assignment too large for int.

Explanation

An unsigned constant whose value is greater than the maximum unsigned value for the type int was assigned to a variable of type int. Data truncation will occur. This message is suppressed unless the strict option (or cross-platform -W1,-ll option) is used.

461

WARNING: Constant assignment too small for int.

Explanation

A constant whose value is less than the minimum value for the type int was assigned to a variable of type int. Data truncation will occur. This message is suppressed unless the strict option (or cross-platform -W1,-ll option) is used.

462

WARNING: Constant assignment too large for unsigned int.

Explanation

A constant whose value is greater than the maximum value for the type unsigned int was assigned to a variable of type unsigned int. Data truncation will occur. This message is suppressed unless the strict option (or cross-platform -W1,-ll option) is used.

463

WARNING: Constant assignment too small for unsigned int.

Explanation

A constant with a value less than 0 was assigned to a variable of type unsigned int. The constant will be converted to a large unsigned value, which may not be the intended effect.

465

WARNING: Assignment of long constant to int.

Explanation

A constant of type long was assigned to a variable of type int. The assignment will behave properly on the 370, but may not if ported to another machine architecture. This message is suppressed unless the strict option (or cross-platform -W1,-ll option) is used.

469

WARNING: Constant assignment too small for unsigned long.

Explanation

A constant with a value less than 0 was assigned to a variable of type unsigned long. The constant will be converted to a large unsigned long value, which may not be the intended effect.

470

WARNING: Assignment of unsigned constant to long.

Explanation

A constant of type unsigned long whose value is greater than the maximum value of the type long was assigned to a variable of type long. Data truncation will occur. This message is suppressed unless the strict option (or cross-platform -W1,-ll option) is used.

473

WARNING: Operation/comparison of unsigned *char and signed *char.

Explanation

An assignment was made between signed and unsigned char pointers. This message is suppressed unless the strict option (or cross-platform -W1,-ll option) is used.

476

WARNING: Invalid control expression in for statement.

Explanation

The control (second) expression of a for statement had void type. The control expression must either have an arithmetic or pointer type, or be omitted.

477

WARNING: Unmatched quote in #pragma title preprocessor command.

Explanation

An unmatched quote was found in processing a #pragma title compiler directive.

Unnumbered Error and Warning Messages

These messages are compiler diagnostic notes concerning the following:

Option Processing Messages

These messages generally describe conditions that arise during compiler option processing. The messages are generally for diagnostic purposes only; the compiler ignores the unrecognized string and continues processing. Check the Options in Effect part of the compiler listing to determine the options actually used by the compiler.
Invalid DDname prefix specified
Mainframe only: The argument to the files compiler option contains characters that cannot be used in a DDname, or the argument is longer than three characters (MVS, TSO only).
Invalid default bitfield type.
The allocation unit specified with the bitfield option must be either 1, 2, or 4. The bitfield option (or cross-platform -Kbitfield option) is ignored.
Invalid GO complexity() option: 0-20 allowed - overridden.
The complexity option (or cross-platform -Oic=[number] option) requires an integer value between 0 and 20, inclusive. The compiler will use a default value of 0.
Invalid GO depth() option: 0 -6 allowed - overridden.
The depth option (or cross-platform -Oid=[number] option) requires an integer value between 0 and 6, inclusive. The compiler will use a default value of 3.
{mono Invalid GO inline option [ {ob text} ].}
The specified option is an unknown optimization phase option. It is ignored.
Invalid GO rdepth() option: 0-6 allowed - overridden.
The rdepth option (or cross-platform -Oir=[number] option) requires an integer value between 0 and 6, inclusive. The compiler will use a default value of 1.
Invalid LISTING disposition specified
Mainframe only: An attempt was made to route the compiler listing to a destination other than a minidisk, SFS directory, virtual printer, or the terminal (CMS only).
Invalid multiple specified for zapspace size.
The zapspace option (or cross-platform -Kzapspace option) requires an integer value between 0 and 22, inclusive. A value was found that did not fit these criteria, so the compiler used the default value of 1.
Invalid number of lines per page specified for listing
The number specified by the pagesize option was not greater than 10 and less than 255. The compiler sets the page size to 55.
{mono Unknown option [ {ob xxx} ] [ {ob yyy} ].}
The compiler did not recognize [xxx] as an option and assumed that [yyy] was intended. The message identifies the bad option and the assumed option.
{mono Invalid [ {ob option-type} ] option: [ {ob text} ]}
An invalid option was specified. The message may classify the option by [option-type]. The [text] may identify the string that was unrecognizable or may indicate what action the compiler took (or both).
Invalid section name specified.
The sname option (or cross-platform -ksname option) specified a string that either contained invalid characters or was longer than seven characters.

Invalid symbol definition.
An attempt was made to define an invalid preprocessor symbol with the define option (or cross-platform -Dsym=[value] option).
Invalid value specified for minimum zapspace size.
The zapmin option (or cross-platform -Kzapmin option) requires an integer value between 24 and 512, inclusive. The compiler will use a default value of 1.

Environmental Conditions

The messages in this section describe error conditions in the environment, rather than errors in the source file caused by improper language specifications. In most cases, errors written by the run-time library to the standard error file, stderr, provide additional information.
Can't close file for debugger symbol information.
The second phase of the compiler encountered an error while closing the debugger symbol file.
Can't create file for debugger symbol information.
The second phase of the compiler was unable to create the debugger symbol file.
Can't create object file.
The second phase of the compiler was unable to create the object file.
Can't create quad file.
The first phase of the compiler was unable to create the quad file.
Can't open quad file.
The second phase of the compiler was unable to open the quad file.
Can't open source file.
The first phase of the compiler was unable to open the source file.
End-of-file on object file.
The second phase of the compiler encountered a premature end-of-file on the object file.
Error closing object file.
The second phase of the compiler encountered an error while closing the object file.
Intermediate file error.
The first phase of the compiler encountered an error when writing to the quad file.
Invalid quad file.
The quad file was created incorrectly by the first phase of the compiler or has been corrupted between compiler phases.
No functions or data defined.
A source file that did not define any functions or data elements was processed by the compiler. This error always terminates execution of the compiler. It can be generated by forgetting to terminate a comment, which then causes the compiler to treat the entire file as a comment.
Not enough memory.
This message is generated when either phase of the compiler uses up all the available working memory. The only remedy for this error is either to increase the available memory or (if the maximum is already available) to reduce the size and complexity of the source file.
Object file error.
The second phase of the compiler encountered an error when writing to the object file.

Global Optimization Phase Messages

These messages can be issued by the global optimization phase:
Can't reopen output quad file.
The optimizer could not open the quad file. Check for a library diagnostic message containing more information about why the file could not be opened.
Error while replacing quad file.
The optimizer could not close the quad file. Check for a library diagnostic message containing more information about why the file could not be closed.
Quad file not replaced.
The optimizer could not delete the existing copy of the quad file. This usually is caused by write-protecting the quad file.

Copyright (c) 1998 SAS Institute Inc. Cary, NC, USA. All rights reserved.