//-style comments accepted as an extensionA standard conforming C compiler must emit a diagnostic about "syntax errors" like two adjacent division operators. This warning is produced only at the first use of a // comment in a compile.
int a; // declare a"file", line 1: warning: //-style comments accepted as an extension
'$' in an identifier accepted as an extensionThis one-time warning is issued on the first occurrence of a $ in an identifier when the -Kdollar and -Xc options are used together.
n
extra byte(s) in string literal initializer ignoredA string literal that initializes a character array contains n more characters than the array can hold.
char ca[3] = "abcd";"file," line 1: warning: 1 extra byte(s) in string literal initializer ignored
0 is invalid in # <number> directiveThe line number in a line number information directive (which the compiler uses for internal communication) must be a positive, non-zero value.
# 0 "foo.c""file," line 1: 0 is invalid in # <number> directive
0 is invalid in #line directiveThis diagnostic is similar to the preceding one, except the invalid line number appeared in a #line directive.
#line 0"file," line 1: 0 is invalid in #line directive
ANSI C behavior differs; not modifying typedef with modifierA typedefed type may not be modified with the short, long, signed, or unsigned type modifiers, although earlier releases permitted it. modifier is ignored. A related message is
modifying typedef with modifier; only qualifiers allowed.
typedef int INT; unsigned INT ui;"file," line 2: warning: ANSI C behavior differs; not modifying typedef with "unsigned"
ANSI C predefined macro cannot be redefinedThe source code attempted to define or redefine a macro that is predefined by ANSI C. The predefined macro is unchanged.
#define __FILE__ "xyz.c""file," line 1: warning: ANSI C predefined macro cannot be redefined
ANSI C predefined macro cannot be undefinedThe source code contains an attempt to undefine a macro that is predefined by ANSI C.
#undef __FILE__"file," line 1: warning: ANSI C predefined macro cannot be undefined
ANSI C requires formal parameter before "..."The compiler implementation allows you to define a function with a variable number of arguments and no fixed arguments. ANSI C requires at least one fixed argument.
f(...){}
"file," line 1: warning: ANSI C requires formal parameter
before "..."
ANSI C treats constant as unsigned: op "operator"The type promotion rules for ANSI C are slightly different from those of previous releases. In the current release the default behavior is to use the ANSI C rules.
Obtain the older behavior by using the -Xt option for the cc command.
Previous type promotion rules were ``unsigned-preserving.'' If one of the operands of an expression was of unsigned type, the operands were promoted to a common unsigned type before the operation was performed.
ANSI C uses ``value-preserving'' type promotion rules. An unsigned type is promoted to a signed type if all its values may be represented in the signed type.
ANSI C also has a different rule from previous releases for the type of an integral constant that implicitly sets the sign bit.
The different type promotion rules may lead to different program behavior for the operators that are affected by the unsigned-ness of their operands:
-
The division operators:
/,
/=,
%,
%=.
-
The right shift operators:
>>,
>>=.
- The relational operators: <, <=, >, >=.
f(void){
int i;
/
constant was integer, unsigned in ANSI C /
i /= 0xf0000000;
}
"file," line 4: warning: ANSI C treats constant as unsigned:
op "/="
To get the same behavior as in previous releases add an explicit cast:
f(void){
int i;
/ constant was integer, unsigned in ANSI C /
i /= (int) 0xf0000000;
}
-D option argument not an identifierAn identifier must follow the -D cc command line option.
cc -D3b2 -c x.c command line: -D option argument not an identifier
-D option argument not followed by "="If any tokens follow an identifier in a -D command line option to the cc command, the first such token must be =.
cc -DTWO+2 -c x.c command line: warning: -D option argument not followed by "="
EOF in argument list of macro: nameThe compiler reached end-of-file while reading the arguments for an invocation of function-like macro name.
#define mac(a) mac( arg1"file," line 5: EOF in argument list of macro: mac
EOF in asm function definitionThe compiler reached end-of-file while reading an enhanced asm function definition.
EOF in character constantThe compiler encountered end-of-file inside a character constant.
EOF in commentThe compiler encountered end-of-file while reading a comment.
EOF in string literalThe compiler encountered end-of-file inside a string literal.
NUL in asm function definitionThe compiler encountered a NUL (zero) character while reading an enhanced asm function definition. The NUL is ignored.
-U option argument not an identifierAn identifier must follow the -U cc command line option.
cc -U3b2 -c x.c command line: -U option argument not an identifier
a cast does not yield an lvalueA cast may not be applied to the operand that constitutes the object to be changed in an assignment operation. The diagnostic is a warning if the size of the operand type and the size of the type being cast to are the same; otherwise it is an error.
f(void){
int i;
(long) i = 5;
(short) i = 4;
}
"file," line 3: warning: a cast does not yield an lvalue
"file," line 4: a cast does not yield an lvalue
\a is ANSI C "alert" characterIn earlier releases, '\a' was equivalent to 'a'. However, ANSI C defines '\a' to be an alert character. In the implementation, the corresponding character code is 07, the BEL character.
int c = '\a';"file," line 1: warning: \a is ANSI C "alert" character
access through "void" pointer ignoredf(){
volatile void vp1, vp2;
(vp1 = vp2); / assignment does get done /
}
"file," line 3: warning: access through "void" pointer ignored
argument cannot have unknown size: arg #nAn argument in a function call must have a completed type. A struct, union, or enum object was passed whose type is incomplete.
f(){
struct s st;
g(st);
}
"file," line 3: argument cannot have unknown size: arg #1
argument does not match remembered type: arg #nAt a function call, the compiler determined that the type of the n-th argument passed to a function disagrees with other information it has about the function. That other information comes from two sources:
-
An old-style (non-prototype) function definition, or
- A function prototype declaration that has gone out of scope, but whose type information is still remembered.
The argument in question is promoted according to the default argument promotion rules.
This diagnostic may be incorrect if the old-style function definition case applies and the function takes a variable number of arguments.
void f(i)
int i;
{ }
void g()
{
f("erroneous");
}
"file," line 7: warning: argument does not match remembered
type: arg #1
argument is incompatible with prototype: arg #nA function was called with an argument whose type cannot be converted to the type in the function prototype declaration for the function.
struct s {int x;} q;
f(void){
int g(int,int);
g(3,q);
}
"file," line 4: argument is incompatible with prototype:
arg #2
argument mismatchThe number of arguments passed to a macro was different from the number in the macro definition.
#define twoarg(a,b) a+b int i = twoarg(4);"file," line 2: warning: argument mismatch
argument mismatch: n1 arg[s] passed, n2 expectedAt a function call, the compiler determined that the number of arguments passed to a function disagrees with other information it has about the function. That other information comes from two sources:
-
An old-style (non-prototype) function definition, or
- A function prototype declaration that has gone out of scope, but whose type information is still remembered.
This diagnostic may be incorrect if the old-style function definition case applies and the function takes a variable number of arguments.
extern int out_of_scope();
int f()
{ / function takes no args /
extern int out_of_scope(int);
}
int g()
{
f(1); / f takes no args /
out_of_scope(); / out_of_scope expects one arg /
}
"file," line 9: warning: argument mismatch: 1 arg passed,
0 expected
"file," line 10: warning: argument mismatch: 0 args passed,
1 expected
array too bigAn array declaration has a combination of dimensions such that the declared object is too big for the target machine.
int bigarray[1000][1000][1000];"file," line 1: array too big
asm() argument must be normal string literalThe argument to an old-style asm() must be a normal string literal, not a wide one.
asm(L"wide string literal not allowed");"file," line 1: asm() argument must be normal string literal
asm definition cannot have old-style parametersThe definition of an enhanced asm function may use the ANSI C function prototype notation to declare types for parameters. It may not declare parameters by using the old-style C function definition notation of an identifier list, followed by a declaration list that declares parameter types.
__asm is an extension of ANSI CCode declaring an enhanced asm function was compiled with -Xc. This warning tells that the enhanced __asm is a violation of ANSI C syntax, which the compiler is obliged to diagnose, and is not a compatible extension.
"asm" valid only for function definitionThe asm storage class may only be used for function definitions. It is ignored here.
asm int f(void);"file," line 1: warning: "asm" valid only for function definition
"#assert identifier (..." expectedIn a #assert directive, the token following the predicate was not the ( that was expected.
#assert system unix"file," line 1: "#assert identifier (..." expected
"#assert identifier" expectedIn a #assert directive, the token following the directive was not the name of the predicate.
#assert 5"file," line 1: "#assert identifier" expected
"#assert" missing ")"In a #assert directive, the parenthesized form of the assertion lacked a closing ).
#assert system(unix"file," line 1: "#assert" missing ")"
assignment type mismatchThe operand types for an assignment operation are incompatible. The message is a warning when the types are pointer types that do not match. Otherwise the message is an error.
struct s { int x; } st;
f(void){
int i;
char cp;
const char ccp;
i = st;
cp = ccp;
}
"file," line 6: assignment type mismatch
"file," line 7: warning: assignment type mismatch
auto/register/asm inappropriate hereA declaration outside any function has storage class auto or register or a declaration within a function has storage class asm.
auto int i;
f(void){
asm int j;
}
"file," line 1: auto/register/asm inappropriate here
"file," line 3: auto/register/asm inappropriate here
automatic redeclares external: nameAn automatic variable was declared name in the same block and with the same name as another symbol that is extern. ANSI C prohibits such declarations, but previous compilation systems of allowed them. For compatibility with previous releases, references to name in this block will be to the automatic.
f(void){
extern int i;
int i;
}
"file," line 3: warning: automatic redeclares external: i
bad file specificationThe file specifier in a #include directive was neither a string literal nor a well-formed header name.
#include stdio.h"file," line 1: bad file specification
bad octal digit: 'digit'An integer constant that began with
0
included the non-octal digit
digit.
An
8
is taken to have value 8, and a
9
is taken to have value 9, even though they are invalid.
In ANSI C (with the -Xa or -Xc options), the compiler will
reject such a constant with the diagnostic invalid token.
int i = 08;"file," line 1: warning: bad octal digit: '8'
bad #pragma pack value: nThe value n that was specified in a #pragma pack directive was not one of the acceptable values: 1, 2, or 4. The erroneous value is ignored and the directive has no effect.
bad token in #error directive: tokenThe tokens in a #error directive must be valid C tokens. The source program contained the invalid token token.
#error "this is an invalid token"file," line 1: bad token in #error directive: " "file," line 1: #error: "this is an invalid token
bad use of "#" or "##" in macro #defineIn a macro definition, a # or ## operator was followed by a # or ## operator.
#define bug(s) # # s #define bug2(s) # ## s"file," line 1: warning: bad use of "#" or "##" in macro #define "file," line 2: warning: bad use of "#" or "##" in macro #define
base type is really "type tag": nameA type was declared with a struct, union, or enum type specifier and with tag tag, and then used with a different type specifier to declare name. type is the type specifier used for the original declaration.
With the -Xt option, the compiler treats the two types as the same for compatibility with previous releases. In ANSI C (with the -Xa or -Xc options), the types are different.
struct s { int x,y,z; };
f(void){
union s foo;
}
"file," line 3: warning: base type is really "struct s": foo
"file," line 3: warning: declaration introduces new type in
ANSI C: union s
bit-field size <= 0: nameThe declaration for bit-field name specifies a zero or negative number of bits.
struct s { int x:-3; };
"file," line 1: bit-field size <= 0: x
bit-field too big: nameThe declaration for bit-field name specifies more bits than will fit in an object of the declared type.
struct s { char c:20; };
"file," line 1: bit-field too big: c
"break" outside loop or switchA function contains a break statement in an inappropriate place, namely outside any loop or switch statement.
f(void){
break;
}
"file," line 2: "break" outside loop or switch
call to function lacking prototype: nameThe program calls function _name_, which has been declared, but without any parameter information.
extern void g();
void f(void) {
g();
}
"file", line 3: warning: call to function lacking prototype: g
cannot access member of non-struct/union objectThe structure or union member must be completely contained within the left operand of the . operator.
f(void){
struct s { int x; };
char c;
c.x = 1;
}
"file," line 4: warning: left operand of "." must be struct/
union object
"file," line 4: cannot access member of non-struct/union object
cannot begin macro replacement with "##"The ## operator is a binary infix operator and may not be the first token in the macro replacement list of a macro definition.
#define mac(s) ## s"file," line 1: warning: cannot begin macro replacement with "##"
cannot concatenate wide and regular string literalsRegular string literals and string literals for wide characters may be concatenated only if they are both regular or both wide. The compiler issues a warning if a wide string literal is followed by a regular one (and both are treated as wide); it issues an error if a regular string literal is followed by a wide one.
#include <stddef.h> wchar_t wa[] = L"abc" "def"; char a[] = "abc" L"def";"file," line 2: warning: cannot concatenate wide and regular string literals "file," line 3: cannot concatenate wide and regular string literals
cannot declare array of functions or voidAn array of functions was or an array of void. was declared.
int f[5]();"file," line 1: cannot declare array of functions or void
cannot define "defined"The predefined preprocessing operator defined may not be defined as a macro name.
#define defined xyz"file," line 1: warning: cannot define "defined"
cannot dereference non-pointer typeThe operand of the
(pointer dereference) operator must have pointer type.
This diagnostic is also issued for an array reference
to a non-array.
f(){
int i;
i = 4;
i[4] = 5;
}
"file," line 3: cannot dereference non-pointer type
"file," line 4: cannot dereference non-pointer type
cannot do pointer arithmetic on operand of unknown sizeAn expression involves pointer arithmetic for pointers to objects whose size is unknown.
f(void){
struct s ps;
g(ps+1);
}
"file," line 3: cannot do pointer arithmetic on operand
of unknown size
cannot end macro replacement with "#" or "##"A # or ## operator may not be the last token in the macro replacement list of a macro definition.
#define mac1(s) abc ## s ## #define mac2(s) s #"file," line 1: warning: cannot end macro replacement with "#" or "##" "file," line 2: warning: cannot end macro replacement with "#" or "##"
cannot find include file: filenameThe file filename specified in a #include directive could not be located in any of the directories along the search path.
#include "where_is_it.h""file," line 1: cannot find include file: "where_is_it.h"
cannot have "..." in asm functionAn enhanced asm definition may not be a function prototype definition with ellipsis notation.
cannot have void object: nameAn object may not be declared as having type void.
void v;"file," line 1: cannot have void object: v
cannot initialize "extern" declaration: nameWithin a function, the declaration of an object with extern storage class may not have an initializer.
f(void){
extern int i = 1;
}
"file," line 2: cannot initialize "extern" declaration: i
cannot initialize function: nameA name declared as a function may not have an initializer.
int f(void) = 3;"file," line 1: cannot initialize function: f
cannot initialize parameter: nameOld-style function parameter name may not have an initializer.
int f(i)
int i = 4;
{
}
"file," line 2: cannot initialize parameter: i
cannot initialize typedef: nameA typedef may not have an initializer.
typedef int INT = 1;"file," line 1: cannot initialize typedef: INT
cannot open file: explanationThe compiler was unable to open an input or output file. Usually this means the file name argument passed to the cc command was incorrect. explanation describes why file could not be opened.
cc glorch.c -c x.ccommand line: fatal: cannot open glorch.c: No such file or directory
cannot open include file (too many open files): filenameThe compiler could not open a new include file, filename, because too many other include files are already open. This scenario could arise if you have file1 that includes file2 that includes file3, and so on. The compiler supports at least eight levels of nesting, up to a maximum defined by the operating system. The most likely reason for the diagnostic is that at some point an include file includes a file that had already been included. For example, this could happen if file1 includes file2, which includes file1 again.
In this example, imagine that the file i1.h contains #include "i1.h".
#include "i1.h""./i1.h", line 1: cannot open include file (too many open files): "i1.h"
cannot recover from previous errorsEarlier errors in the compilation have confused the compiler, and it cannot continue to process the program. Please correct those errors and try again.
cannot return incomplete typeWhen a function is called that returns a structure or union, the complete declaration for the structure or union must have been seen already. Otherwise this message results.
f(){
struct s g();
g();
}
"file," line 3: cannot return incomplete type
cannot take address of bit-field: nameIt is not permitted to take the address of a bit-field member of a structure or union.
f(void){
struct s { int x:3, y:4; } st;
int ip = &st.y ;
}
"file," line 3: cannot take address of bit-field: y
cannot take address of register: nameWhen name is declared with register storage class, it is not permissible to take the address of name, even if the compiler actually allocates the object to a register. The attempt to take an object's address may have been implicit, such as when an array is dereferenced. The diagnostic is an error if a register was allocated for the object and a warning otherwise.
f(void){
register int i;
register int ia[5];
int ip = &i ;
ia[2] = 1;
}
"file," line 4: cannot take address of register: i
"file," line 5: warning: cannot take address of register: ia
cannot take sizeof bit-field: nameThe sizeof operator may not be applied to bit-fields.
struct s { int x:3; } st;
int i = sizeof(st.x);
"file," line 2: warning: cannot take sizeof bit-field: x
cannot take sizeof function: nameThe sizeof operator may not be applied to functions.
int f(void); int i = sizeof(f);"file," line 2: cannot take sizeof function: f
cannot take sizeof voidThe sizeof operator may not be applied to type void.
void v(void); int i = sizeof(v());"file," line 2: cannot take sizeof void
cannot undefine "defined"The predefined preprocessing operator defined may not be undefined.
#undef defined"file," line 1: warning: cannot undefine "defined"
can't take address of object of type voidStrict ANSI conformance requires a diagnostic when taking the address of an object of type void.
extern void_end;foo () { foo (&_end) ; }
"file," line 4: warning: can't take address of object of type void
case label affected by conversion: valueThe value for the case label cannot be represented by the type of the controlling expression of a switch statement. If the type of the case expression and the type of the controlling expression have the same size, the actual bit representation of the case expression is unchanged, but its interpretation is different. For example, the controlling expression may have type int and the case expression may have type unsigned int. In the diagnostic, value is represented as a hexadecimal value if the case expression is unsigned, decimal if it is signed.
f(){
int i;
switch( i ){
case 0xffffffffu:
;
}
}
"file," line 5: warning: case label affected by conversion:
0xffffffff
In this example
0xffffffffu
is not representable as an
int.
When the case expression is converted to the type of the controlling expression
(int),
its effective value is
-1,
which means that the case will be reached if
i
has the value
-1,
rather than
0xffffffff.
"case" outside switchA case statement occurred outside the scope of any switch statement.
f(void){
case 4: ;
}
"file," line 2: "case" outside switch
character constant too longThe character constant contains too many characters to fit in an integer. Only the first four characters of a regular character constant, and only the first character of a wide character constant, are used. (Character constants that are longer than one character are non-portable.)
int i = 'abcde';"file," line 1: warning: character constant too long
character escape does not fit in characterA hexadecimal or octal escape sequence in a character constant or string literal produces a value that is too big to fit in an unsigned char. The value is truncated to fit.
char
"file," line 1: warning: \x is ANSI C hex escape "file," line 1: warning: character escape does not fit in character "file," line 1: warning: character escape does not fit in character
character escape does not fit in wide characterThis message diagnoses a condition similar to the previous one, except the character constant or string literal is prefixed by L to designate a wide character constant or string literal.
The character escape is too large to fit in an object of type wchar_t and is truncated to fit.
comment does not concatenate tokensIn previous releases, it was possible to ``paste'' two tokens together by juxtaposing them in a macro with a comment between them. This behavior was never defined or guaranteed. ANSI C provides a well-defined operator, ##, that serves the same purpose and should be used. This diagnostic warns that the old behavior is not being provided.
#define PASTE(a,b) a/"file," line 1: warning: comment does not concatenate tokens "file," line 2: syntax error, probably missing ",", ";" or "=" "file," line 2: syntax error before or at: suffix "file," line 2: warning: declaration missing specifiers: assuming "int"
comment is replaced by "##"This message is closely related to
comment does not concatenate tokens.
The diagnostic tells that the compiler is treating
an apparent concatenation as if it were the
##
operator.
The source code should be updated to use the new operator.
#define PASTE(a,b) a/"file," line 1: warning: comment is replaced by "##"
const object should have initializer: nameA const object cannot be modified. If an initial value is not supplied, the object will have a value of zero, or for automatics its value will be indeterminate.
const int i;"file," line 1: warning: const object should have initializer: i
constant value too big: constantAn operand in a #if or #elif directive has a value greater than ULLONG_MAX (one less than 2^64 or 18446744073709551616).
#if 18446744073709551617 > 0 int a; #endif"file", line 1: warning: constant value too big: 18446744073709551617
"continue" outside loopThe program contains a continue statement outside the scope of any loop.
f(void){
continue;
}
"file," line 2: "continue" outside loop
controlling expressions must have scalar typeThe expression for an if, for, while, or do-while must be an integral, floating-point, or pointer type.
f(void){
struct s {int x;} st;
while (st) {}
}
"file," line 3: controlling expressions must have scalar type
conversion of double to float is out of rangeA double expression has too large a value to fit in a float. The diagnostic is a warning if the expression is in executable code and an error otherwise.
float f = 1e30"file," line 1: conversion of double to float is out of range
conversion of double to integral is out of rangeA double constant has too large a value to fit in an integral type. The diagnostic is a warning if the expression is in executable code and an error otherwise.
int i = 1e100;"file," line 1: conversion of double to integral is out of range
conversion of floating-point constant to type out of rangeA floating-point constant has too large a value to fit in type type (float, double, long double).
float f = 1e300f;"file," line 1: conversion of floating-point constant to float out of range
decimal constant promoted to long long: nBy including long long and unsigned long long types, decimal constants in the range [LONG_MAX+1,ULONG_MAX] will now have type long long instead of unsigned long. Integer constants with other bases and decimal constants with a u or U suffix are not affected.
extern void g();
void f(void) {
g(2147483648); /* 2^31 */
}
"file", line 2: warning: decimal constant promoted to long long:
2147483648
declaration hides parameter: nameAn identifier name was declared with the same name as one of the parameters of the function. References to name in this block will be to the new declaration.
int f(int i,int INT){
int i;
typedef int INT;
}
"file," line 2: warning: declaration hides parameter: i
"file," line 3: warning: declaration hides parameter: INT
declaration introduces new type in ANSI C: type tagstruct, union, or enum tag has been redeclared in an inner scope. In previous releases, this tag was taken to refer to the previous declaration of tag. In ANSI C, the declaration introduces a new type. When the -Xt option is selected, the earlier behavior is reproduced.
struct s1 { int x; };
f(void){
struct s1;
struct s2 { struct s1 ps1; }; / s1 refers to line 1 /
struct s1 { struct s2 ps2; };
}
"file," line 3: warning: declaration introduces new type in
ANSI C: struct s1
declaration missing specifiers; add "int"Objects and functions that are declared at file scope must have a storage class or type specifier. If both are omitted the following warning is displayed:
i; f(void);"file," line 1: warning: declaration missing specifiers; assuming "int" "file," line 2: warning: declaration missing specifiers; assuming "int"
"default" outside switchA default label appears outside the scope of a switch statement.
f(void){
default: ;
}
"file," line 2: "default" outside switch
#define requires macro nameA #define directive must be followed by the name of the macro to be defined.
#define +3"file," line 1: #define requires macro name
digit sequence expected after "#line"The compiler expected to find the digit sequence that comprises a line number after #line, but the token it found there is either an inappropriate token or a digit sequence whose value is zero.
#line 09a"file," line 1: digit sequence expected after "#line"
directive is an upward-compatible ANSI C extensionThis diagnostic is issued when the C compiler sees a directive that it supports, but that is not part of the ANSI C standard, and -Xc has been selected.
#assert system( unix )"file," line 1: warning: directive is an upward-compatible ANSI C extension
directive not honored in macro argument listA directive has appeared between the ( )'s that delimit the arguments of a function-like macro invocation. The following directives are disallowed in such a context: #ident, #include, #line, #undef. The diagnostic is a warning if it appears within a false group of an if-group, and an error otherwise.
#define flm(a) a+4 int i = flm( #ifdef flm /"file," line 4: directive not honored in macro argument list "file," line 7: warning: directive not honored in macro argument list
division by 0An expression contains a division by zero that was detected at compile-time. If the division is part of a #if or #elif directive, the result is taken to be zero.
The diagnostic is a warning if the division is in executable code, an error otherwise.
f(void) {
int i = 1/0;
}
"file," line 2: warning: division by 0
dubious type declaration; use tag only: tagA new struct, union, or enum type with tag tag was declared within a function prototype declaration or the parameter declaration list of an old-style function definition, and the declaration includes a declarator list for type. Calls to the function would always produce a type mismatch, because the tag declaration goes out of scope at the end of the function prototype declaration or definition, according to ANSI C's scope rules. It is not possible to declare an object of that type outside the function.
This can be fixed by declaring the struct, union, or enum ahead of the function prototype or function definition and then referring to it just by its tag.
int f(struct s {int x;} st)
{}
"file," line 1: warning: dubious struct declaration; use tag
only: s
Rewrite this as
struct s {int x;};
int f(struct s st)
{}
dubious escape: \cOnly certain characters may follow \ in string literals and character constants; c was not one of them. The \ is ignored.
int i = '\q';"file," line 1: warning: dubious escape: \q
dubious escape: \<hex value>This message diagnoses the same condition as the preceding one, but the character that follows \ in the program is a non-printing character. The hex value between the brackets in the diagnostic is the character's code, printed as a hexadecimal number.
dubious reference to type typedef: typedefThis message is similar to
dubious tag in function prototype:
type
tag.
A function prototype declaration refers to a
type
struct, union, or enum
typedef with name
typedef.
Because the
struct, union, or enum
has been declared within a function,
it could not be in scope when the function
whose prototype is being declared was defined.
The prototype declaration and function definition thus could
never match.
f(){
struct s { int x; };
typedef struct s ST;
extern int g(ST, struct s);
}
"file," line 4: warning: dubious reference to struct typedef:
ST
"file," line 4: warning: dubious tag in function prototype:
struct s
dubious static function at block levelA function was declared with storage class static at block scope. The ANSI C standard says that the behavior is undefined if a function is declared at block scope with an explicit storage class other than extern. Although functions may be declared this way, other implementations may not recognize them, or may attach a different meaning to such a declaration.
void
f(void){
static void g(void);
}
"file," line 3: warning: dubious static function at block
level
dubious tag declaration: type tagA new struct, union, or enum type with tag tag was declared within a function prototype declaration or the parameter declaration list of an old-style function definition. Calls to the function would always produce a type mismatch, because the tag declaration goes out of scope at the end of the function declaration or definition, according to ANSI C's scope rules. It is not possible to declare an object of that type outside the function.
int f(struct s"file," line 1: warning: dubious tag declaration: struct s
dubious tag in function prototype: type tagThis message is similar to the previous one. A function prototype declaration refers to a struct, union, or enum type with tag tag. The tag has been declared within a function. Therefore it could not be in scope when the function whose prototype is being declared was defined. The prototype declaration and function definition thus could never match.
f(){
struct s {int x;};
int g(struct s );
}
"file," line 3: warning: dubious tag in function prototype:
struct s
duplicate case in switch: valueThere are two case statements in the current switch statement that have the same constant value value.
f(void){
int i = 5;
switch(i) {
case 4:
case 4:
break;
}
}
"file," line 5: duplicate case in switch: 4
duplicate case value value; first on line lineReplaces "duplicate case in switch: value". The existing test case now produces
line 5: duplicate case value 4; first on line 4
duplicate "default" in switchThere are two default labels in the current switch statement.
f(void){
int i = 5;
switch(i) {
default:
default:
break;
}
}
"file," line 5: duplicate "default" in switch
duplicate formal parameter: nameIn a function-like macro definition, name was used more than once as a formal parameter.
#define add3(a,a,c) a + b + c"file," line 1: warning: duplicate formal parameter: a
duplicate member name: memberA struct or union declaration uses the name member for more than one member.
union u {
int i;
float i;
};
"file," line 3: duplicate member name: i
duplicate name in % line specification: nameFormal parameter name was mentioned more than once in the
%
line of an enhanced
asm
function.
#elif follows #elseA preprocessing if-section must be in the order #if, optional #elif's, followed by optional #else and #endif. The code contains a #elif after the #else directive.
#if defined(ONE)
int i = 1;
#elif defined(TWO)
int i = 2;
#else
int i = 3;
#elif defined(FOUR)
int i = 4;
#endif
"file," line 7: warning: #elif follows #else
#elif has no preceding #ifAn #elif directive must be part of a preprocessing if-section, which begins with a #if directive. The code in question lacked the #if.
#elif defined(TWO)
int i = 2;
#endif
"file," line 1: #elif has no preceding #if
"file," line 3: #if-less #endif
#elif must be followed by a constant expressionThere was no expression following the #elif directive.
#if defined(ONE)
int i = 1;
#elif
int i = 4;
#endif
"file," line 3: warning: #elif must be followed by a constant
expression
#else has no preceding #ifAn #else directive was encountered that was not part of a preprocessing if-section.
#else
int i =7;
#endif
"file," line 1: #else has no preceding #if
"file," line 3: #if-less #endif
embedded NUL not permitted in asm()The string literal that appears in an old-style asm() contains an embedded
NUL
character (character code 0).
asm("this is an old-style asm with embedded NUL: \0");
"file," line 1: embedded NUL not permitted in asm()
empty #assert directiveA #assert directive contained no predicate name to assert.
#assert"file," line 1: empty #assert directive
empty character constantThe program has a character constant without any characters in it.
int i = '';"file," line 1: empty character constant
empty constant expression after macro expansionA #if or #elif directive contained an expression that, after macro expansion, consisted of no tokens.
#define EMPTY
#if EMPTY
char mesg = "EMPTY is non-empty";
#endif
"file," line 2: empty constant expression after macro
expansion
empty #define directive lineA #define directive lacked both the name of the macro to define and any other tokens.
#define"file," line 1: empty #define directive line
empty file nameThe file name in a #include directive is null.
#include <>"file," line 1: empty file name
empty header nameThis diagnostic is similar to the preceding one, but the null file name arises after macro substitution.
#define NULLNAME <> #include NULLNAME"file," line 2: empty header name
empty predicate argumentThe compiler expects to find tokens between the ( )'s that delimit a predicate's assertions in a #unassert directive. None were present.
#unassert machine()"file," line 1: empty predicate argument
empty translation unitThe source file has no tokens in it after preprocessing is complete. The ANSI C standard requires the compiler to diagnose a file that has no tokens in it.
#ifdef COMPILE
int token;
#endif
"file," line 5: warning: empty translation unit
empty #unassert directiveA #unassert contained no predicate name to discard.
#unassert"file," line 1: empty #unassert directive
empty #undef directive, identifier expectedA #undef directive lacked the name of a macro to ``undefine.''
#undef"file," line 1: empty #undef directive, identifier expected
{}-enclosed initializer requiredWhen initializing an aggregate, except in the case of initializing a character array with a string literal or an automatic structure with an expression, the initializes must be enclosed in
{ }'s.
int ia[5] = 1;
f(void){
struct s { int x,y; } st = 1;
}
"file," line 1: warning: {}-enclosed initializer required
"file," line 3: warning: {}-enclosed initializer required
"file," line 3: struct/union-valued initializer required
end-of-loop code not reachedA loop was written in such a way that the code at the end of the loop that the compiler generates to branch back to the beginning of the loop is not reachable and will never be executed.
f(void){
int i = 1;
while (i) {
return 4;
}
}
"file," line 5: warning: end-of-loop code not reached
enum constants have different types: op "operator"A relational operator operator was used to compare enumeration constants from two different enumeration types. This may indicate a programming error. Note also that the sense of the comparison is known at compile time, because the constants' values are known.
enum e1 { ec11, ec12 } ev1;
enum e2 { ec21, ec22 } ev2;
void v(void){
if (ec11 > ec22)
;
}
"file," line 4: warning: enum constants have different types:
op ">"
enum type mismatch: arg #nThe program is passing an enumeration constant or object to a function for which a prototype declaration is in scope. The passed argument is of a different enumerated type from the one in the function prototype, which may indicate a programming error.
enum e1 { ec11 } ev1;
enum e2 { ec21 } ev2;
void ef(enum e1);
void v(void){
ef(ec21);
}
"file," line 6: warning: enum type mismatch: arg #1
enum type mismatch: op "operator"This message is like the previous one. One of the operands of operator is an enumeration object or constant, and the other is an enumeration object or constant from a different enumerated type.
enum e1 { ec11, ec12 } ev1;
enum e2 { ec21, ec22 } ev2;
void v(void){
if (ev1 > ec22)
;
}
"file," line 4: warning: enum type mismatch: op ">"
enumeration constant hides parameter: nameA declaration of an enumerated type within a function includes an enumeration constant with the same name as parameter name. The enumeration constant hides the parameter.
int
f(int i){
enum e { l, k, j, i };
}
"file," line 3: warning: enumeration constant hides parameter:
i
enumerator used in its own initializer: nameWhen setting the value of enumerator name name was used in the expression. ANSI C's scope rules take name in the expression to be whatever symbol was in scope at the time.
int i;
f(void){
enum e { i = i+1, j, k }; / uses global i in i+1 /
}
"file," line 3: warning: enumerator used in its own
initializer: i
"file," line 3: integral constant expression expected
enumerator value overflows INT_MAX (2147483647)The value for an enumeration constant overflowed the maximum integer value.
enum e { e1=2147483647, e2 }; / overflow for e2 /
"file," line 1: warning: enumerator value overflows INT_MAX
(2147483647)
#error: tokensA #error directive was encountered in the source file. The other tokens in the directive are printed as part of the message.
#define ONE 2 #if ONE != 1 #error ONE != 1 #endif"file," line 3: #error: ONE != 1
%error encountered in asm functionA %error specification line was encountered while an enhanced asm was being expanded.
error in asm; expect ";" or "\n", saw 'c'In a % line of an enhanced asm function, the compiler expected to read a semi-colon or new-line and found character c instead.
error writing output fileAn output error occurred while the compiler attempted to write its output file or a temporary file. The most likely problem is that a file system is out of space.
")" expectedIn an #unassert directive, the assertion of a predicate to be dropped must be enclosed in ( ).
#unassert system(unix"file," line 1: ")" expected
"(" expected after "# identifier"When the # operator is used in a #if or #elif directive to select a predicate instead of a like-named macro, the predicate must be followed by a parenthesized list of tokens.
#assert system(unix)
#define system "unix"
#if #system
char systype = system;
#endif
"file," line 3: "(" expected after "# identifier"
"(" expected after first identifierIn an #unassert directive, the assertion of a predicate to be dropped must be enclosed in ( ).
#unassert system unix"file," line 1: "(" expected after first identifier
extern and prior uses redeclared as static: namename was declared at file scope as an extern, then later the same object or function was declared as static. ANSI C rules require that the first declaration of an object or function give its actual storage class. The compilation system accepts the declaration and treats the object or function as if the first declaration had been static.
extern int i; static int i;"file," line 2: warning: extern and prior uses redeclared as static: i
first operand must have scalar type: op "?:"The conditional expression in a
? :
expression must have scalar (integral, floating-point, or pointer) type.
struct s { int x; } st;
f(void){
int i = st ? 3 : 4;
}
"file," line 3: first operand must have scalar type: op "?:"
floating-point constant calculation out of range: op "operator"The compiler detected an overflow at compile time when it attempted the operator operation between two floating-point operands. The diagnostic is a warning if the expression is in executable code and an error otherwise.
double d1 = 1e300"file," line 1: floating-point constant calculation out of range: op "
floating-point constant folding causes exceptionThis message is like the previous one, except that the operation caused a floating-point exception that causes the compiler to exit.
formal parameter lacks name: param #nIn a function prototype definition, a name was not provided for the n-th parameter.
int f(int){
}
"file," line 1: formal parameter lacks name: param #1
function cannot return function or arrayA function was declared whose return type would be a function or array, rather than a pointer to one of those.
int f(void)[]; /"file," line 1: function cannot return function or array
function designator is not of function typeAn expression was used in a function call as if it were the name of a function or a pointer to a function when it was not.
f(void){
char p;
p();
}
"file," line 3: function designator is not of function type
function expects to return value: nameThe current function was declared with a non-void type, but contained a return statement with no return value expression.
f(void){
return;
}
"file," line 2: warning: function expects to return value: f
Function illegally defined in hosted mode: function_nameThe function function_name, having the same name as an ANSI function, was defined with external linkage.
int abs();
main()
{
int i = abs(7);
}
abs(i)
{
printf("fooled ya\n");
}
"file", line 7: warning: Function illegally defined in hosted mode: abs
function prototype parameters must have typesA function prototype declaration cannot contain an identifier list; it must declare types. The identifier list is ignored.
int f(i);"file," line 1: warning: function prototype parameters must have types
identifier expected after "#"The compiler expected to find an identifier, a predicate name, after a # in a conditional compilation directive, and none was there.
#if #system(unix) || #
char os = "sys";
#endif
"file," line 1: identifier expected after "#"
identifier expected after #undefA #undef must be followed by the name of the macro to be undefined. The token following the directive was not an identifier.
#undef 4"file," line 1: identifier expected after #undef
identifier or "-" expected after -AThe cc command line argument -A must be followed by the name of a predicate to assert, or by a -, to eliminate all predefined macros and predicates. The token following -A was neither of these.
cc -A3b2 -c x.c command line: identifier or "-" expected after -A
identifier or digit sequence expected after "#"An invalid token or non-decimal number follows the # that introduces a preprocessor directive line.
# 0x12"file," line 1: identifier or digit sequence expected after "#"
identifier redeclared: nameThe identifier name was declared in a way that is inconsistent with a previous appearance of name, or name was declared twice in the same scope.
Previous releases were forgiving of inconsistent redeclarations if the types were ``nearly'' the same. ANSI C considers the types to be different. The -Xt option will allow you to retain the previous behavior, although the compiler will issue a warning. When the types are manifestly different, the diagnostic is always an error. The -Xa and -Xc options always produce an error when the types are different.
int x; long x; int y; double y;"file," line 2: warning: identifier redeclared: x "file," line 4: identifier redeclared: y
Declarations of functions with and without argument information can often lead to confusing diagnostics. The following example illustrates.
int f(char); int f();"file," line 2: warning: identifier redeclared: f
According to ANSI C's type compatibility rules, a function declaration that lacks type information (i.e., one that is not a function prototype declaration) is compatible with a function prototype only when each parameter type is unchanged by the default argument promotion rules. In the example, char would be affected by the promotion rules (it would be promoted to int). Therefore the two declarations have incompatible types.
identifier redeclared; ANSI C requires "static": namename was declared twice at file scope. The first one used storage class static, but the second one specified no storage class. ANSI C's rules for storage classes require that all redeclarations of name after the first must specify static.
static int i; int i;"file," line 2: warning: identifier redeclared; ANSI C requires "static": i
identifier redefined: namename was defined more than once. An object with an initializer was declared more than once, or a function was defined more than once.
int i = 1; int i = 1;"file," line 2: identifier redefined: i
#if must be followed by a constant expressionNo expression appeared after a #if directive.
#if
int i = 4;
#endif
"file," line 1: warning: #if must be followed by a constant
expression
#if on line n has no #endifThe compiler reached end of file without finding the #endif that would end the preprocessing if-section that began with the if directive that was on line n. The if directive is one of #if, #ifdef, or #ifndef.
#ifdef NOENDIF
int i = 1;
"file," line 5: #ifdef on line 1 has no matching #endif
"file," line 5: warning: empty translation unit
#if-less #endifAn #endif directive was encountered that was not part of a preprocessing if-section.
int i = 1; #endif"file," line 2: #if-less #endif
#ifdef must be followed by an identifierA #ifdef preprocessing directive must be followed by the name of the macro to check for being defined. The source code omitted the identifier. The #ifdef is treated as if it were false.
#ifdef
int i = 1;
#endif
"file," line 1: warning: #ifdef must be followed by an
identifier
#ifndef must be followed by an identifierThe #ifndef directive must be followed by the identifier that is to be tested for having been defined.
#ifndef
int i = 5;
#endif
"file," line 1: warning: #ifndef must be followed by an
identifier
ignoring malformed #pragma int_to_unsigned symbolThe compiler encountered a #pragma int_to_unsigned directive that did not have the form shown. The erroneous directive is ignored.
#pragma int_to_unsigned strlen();"file," line 1: warning: ignoring malformed #pragma int_to_unsigned symbol
ignoring malformed #pragma pack(n)The compiler encountered a #pragma pack directive that did not have the form shown. The erroneous directive is ignored.
ignoring malformed #pragma weak symbol [=value]The compiler encountered a #pragma weak directive that did not have the form shown. The erroneous directive is ignored.
#pragma weak write,_write"file," line 1: warning: ignoring malformed #pragma weak symbol [=value]
implicitly declaring function to return int: name()The program calls function name, which has not been previously declared. The compiler warns that it is assuming that function name returns int.
void v(void){
g();
}
"file," line 2: warning: implicitly declaring function to
return int: g()
improper cast of void expressionA void expression cannot be cast to something other than void.
f(void){
void v(void);
int i = (int) v();
}
"file," line 3: improper cast of void expression
improper member use: nameThe program contains an expression with a -> or . operator, and name is not a member of the structure or union that the left side of the operator refers to, but it is a member of some other structure or union.
This diagnostic is an error if the member is not ``unique.'' A unique member is part of one or more structures or unions but has the same type and offset in all of them.
struct s1 { int x,y; };
struct s2 { int q,r; };
f(void){
struct s1 ps1;
ps1->r = 3;
}
"file," line 5: warning: improper member use: r
improper pointer subtractionThe operands of a subtraction are both pointers, but they point at different types. Only pointers of the same type that point to the same array may be subtracted.
The diagnostic is a warning if the pointers point to objects of the same size, and an error otherwise.
f(void){
int ip;
char cp;
int i = ip - cp;
}
"file," line 4: improper pointer subtraction
improper pointer/integer combination: arg #nAt a function call for which there is a function prototype declaration in scope, the code is passing an integer where a pointer is expected, or vice versa.
int f(char"file," line 3: warning: improper pointer/integer combination: arg #1
improper pointer/integer combination: op operatorOne of the operands of operator is a pointer and the other is an integer, but this combination is invalid.
f(void){
int i = "abc";
int j = i ? 4 : "def";
}
"file," line 2: warning: improper pointer/integer combination:
op "="
"file," line 3: warning: improper pointer/integer combination:
op ":"
"file," line 3: warning: improper pointer/integer combination:
op "="
inappropriate qualifiers with "void"When void stands by itself, it may not be qualified with const or volatile.
int f(const void);"file," line 1: warning: inappropriate qualifiers with "void"
#include <... missing '>'In a #include directive for which the header name began with <, the closing > character was omitted.
#include <stdio.h"file," line 1: warning: #include <... missing '>'
#include directive missing file nameA #include directive did not specify a file to include.
#include"file," line 1: #include directive missing file name
#include of /usr/include/... may be non-portableThe source file included a file with the explicit prefix /usr/include. Such an inclusion is implementation-dependent and non-portable. On some systems the list of default places to look for a header might not include the /usr/include directory. In such a case the wrong file might be included.
#include </usr/include/stdio.h>"file," line 1: warning: #include of /usr/include/... may be non-portable
incomplete #define macro parameter listIn the definition of a function-like parameter, the compiler did not find a ) character on the same (logical) line as the #define directive.
#define mac(a"file," line 1: incomplete #define macro parameter list
incomplete struct/union/enum tag: nameAn object name, with struct, union, or enum type and tag tag, was declared but the type is incomplete.
struct s st;"file," line 1: incomplete struct/union/enum s: st
inconsistent redeclaration of extern: nameA function or object was redeclared name with storage class extern for which there was a previous declaration that has since gone out of scope. The second declaration has a type that conflicts with the first.
f(void){
int p = (int ) malloc(5sizeof(int));
}
g(void){
void malloc();
}
"file," line 5: warning: inconsistent redeclaration of extern:
malloc
inconsistent redeclaration of static: nameAn object or function that was originally declared with storage class static was redeclared. The second declaration has a type that conflicts with the first.
The two most frequent conditions under which this diagnostic may be issued are:
-
A function was originally declared at other than file scope and with
storage class
static.
The subsequent declaration of the function has a type that conflicts
with the first.
- A function or object was originally declared at file scope and with storage class static. A subsequent declaration of the same object or function at other than file scope used storage class extern (or possibly no storage class, if a function), and there was an intervening, unrelated, declaration of the same name.
f(void){
static int myfunc(void);
}
g(void){
static char myfunc(void);
}
"file," line 5: warning: inconsistent redeclaration of static:
myfunc
static int x;
f(void){
int x; / unrelated /
{
extern float x; / related to first declaration /
}
}
"file," line 5: warning: inconsistent redeclaration of static:
x
inconsistent storage class for function: nameANSI C requires that the first declaration of a function or object at file scope establish its storage class. Function name was redeclared in an inconsistent way according to these rules.
g(void){
int f(void);
static int f(void);
}
"file," line 3: warning: inconsistent storage class for
function: f
initialization type mismatchThe type of an initializer value is incompatible with the type of the object being initialized. This specific message usually applies to pointers.
int a; unsigned int"file," line 2: warning: initialization type mismatch
initializer does not fit: valueThe value value does not fit in the space provided for it. If it were fetched from that space, it would not reproduce the same value as was put in. In the message, value is represented as a hexadecimal value if the initializer is unsigned, decimal if it is signed.
struct s {signed int m1:3; unsigned int m2:3;} st = {4, 5};
unsigned char uc = 300u;
"file," line 1: warning: initializer does not fit: 4
"file," line 2: warning: initializer does not fit: 0x12c
integer overflow detected: op "operator"The compiler attempted to compute the result of an operator expression at compile-time, and determined that the result would overflow. The low-order 32 bits of the result are retained, and the compiler issues this diagnostic.
int i = 1000000"file," line 1: warning: integer overflow detected: op "
integral constant expression expectedThe compiler expected (required) an integral constant or an expression that can be evaluated at compile time to yield an integral value. The expression written contained either a non-integral value, a reference to an object, or an operator that cannot be evaluated at compile time.
int ia[5.0];"file," line 1: integral constant expression expected
integral constant too largeAn integral constant is too large to fit in an unsigned long.
int i = 1234567890123;"file," line 1: warning: integral constant too large
internal compiler error: messageThis message does not diagnose a user programming error (usually), but rather a problem with the compiler itself. One of the compiler's internal consistency checks has failed.
interpreted as a #line directiveA source line was encountered that had a number where the directive name usually goes. Such a line is reserved for the compiler's internal use, but it must be diagnosed in the -Xc (strictly conforming) mode.
# 9"file," line 1: warning: interpreted as a #line directive "file," line 1: warning: directive is an upward-compatible ANSI C extension
invalid cast expressionA cast cannot be applied to the expression because the types are unsuitable for casting. Both the type of the expression being cast and the type of the cast must be scalar types. A pointer may only be cast to or from an integral type.
f(void){
struct s {int x;} st;
int i = (int) st;
}
"file," line 3: invalid cast expression
invalid class in asm % line: classThe storage class class that the compiler encountered in an enhanced asm % line is not one of the acceptable classes.
invalid compiler control line in ".i" fileA .i file, the result of a cc -P command, is assumed to be a reserved communication channel between the preprocessing phase and the compilation phase of the compiler. The .i file lets you examine that intermediate form to detect errors that may otherwise be hard to detect. However, the compiler expects to find only a few directives that are used for internal communication. The source file that was compiled (a .i file) contained a preprocessing directive other than one of the special directives.
invalid directiveThe identifier that follows a # in a preprocessing directive line was one that the compiler did not recognize.
# unknown"file," line 1: invalid directive
invalid initializerThe program contains an initializer for an extern or static that attempts to store a pointer in a smaller than pointer-sized object. Such initializations are not supported.
int j; char c = (char) &j ;"file," line 2: invalid initializer
invalid multibyte characterA multibyte character in a string literal or character constant could not be converted to a single wide character in the host environment.
invalid source character: 'c'The compiler encountered a character (c) in the source program that is not a valid ANSI C token.
int i = 1$;"file," line 1: invalid source character: '$'
invalid source character: <hex value>This message diagnoses the same condition as the previous one, but the invalid character is not printable. The hex value between the brackets in the diagnostic is the hexadecimal value of the character code.
invalid switch expression typeThe controlling expression of a switch statement could not be converted to int. This message always follows
switch expression must have integral type.
f(){
struct s {int x;} sx;
switch(sx){
case 4: ;
}
}
"file," line 3: switch expression must have integral type
"file," line 3: invalid switch expression type
invalid token: non-tokenThe compiler encountered a sequence of characters that does not comprise a valid token. An invalid token may result from the preprocessing ## operator. The offending non-token is shown in the diagnostic. If the non-token is longer than 20 characters, the first 20 are printed, followed by ``...''. The offending invalid token is ignored.
#define PASTE(l,r) l ## r double d1 = 1e; double d2 = PASTE(1,e); int i = 1veryverylongnontoken;"file," line 2: invalid token: 1e "file," line 2: syntax error before or at: ; "file," line 2: warning: syntax error: empty declaration "file," line 3: invalid token: 1e "file," line 3: syntax error before or at: ; "file," line 3: warning: syntax error: empty declaration "file," line 4: invalid token: 1veryverylongnontoke... "file," line 4: syntax error before or at: ; "file," line 4: warning: syntax error: empty declaration
invalid token in #define macro parameters: tokenThe compiler encountered an inappropriate token while processing the argument list of a function-like macro definition. token is the erroneous token.
#define mac(a,4) a b c"file," line 1: invalid token in #define macro parameters: 4
invalid token in directiveThe compiler found an invalid token at the end of what would otherwise be a correctly formed directive.
#line 7 "file.c"file," line 1: warning: string literal expected after #line <number> "file," line 1: invalid token in directive: " "file," line 1: warning: tokens ignored at end of directive line
invalid type combinationAn inappropriate combination of type specifiers was used in a declaration.
short float f;"file," line 1: invalid type combination
invalid type for bit-field: nameThe type chosen for bit-field name is not permitted for bit-fields. Bit-fields may only be declared with integral types.
struct s { float f:3; };
"file," line 1: invalid type for bit-field: f
invalid use of "defined" operatorA defined operator in a #if or #elif directive must be followed by an identifier or ( )'s that enclose an identifier. The source code did not use it that way.
#if defined
int i = 1;
#endif
"file," line 1: invalid use of "defined" operator
invalid white space character in directiveThe only white space characters that are permitted in preprocessing directives are space and horizontal tab. The source code included some other white space character, such as form feed or vertical tab. The compiler treats this character like a space.
label redefined: nameThe same label name has appeared more than once in the current function. (A label's scope is an entire function.)
f(void){
int i;
i = 1;
if (i) {
L:
while (i)
g();
goto L;
}
L: ;
}
"file," line 10: label redefined: L
left operand must be modifiable lvalue: op "operator"The operand on the left side of operator must be a modifiable lvalue, but it wasn't.
f(void){
int i = 1;
+i -= 1;
}
"file," line 3: left operand must be modifiable lvalue:
op "-="
left operand of "->" must be pointer to struct/unionThe operand on the left side of a -> operator must be a pointer to a structure or union, but it wasn't. The diagnostic is a warning if the operand is a pointer, an error otherwise.
struct s { int x; };
f(void){
long lp;
lp->x = 1;
}
"file," line 4: warning: left operand of "->" must be pointer
to struct/union
left operand of "." must be lvalue in this contextThe operand on the left side of a . operator is an expression that does not yield an lvalue. Usually this results from trying to change the return value of a function that returns a structure.
struct s { int ia[10]; };
struct s sf(void);
f(void){
sf().ia[0] = 3;
}
"file," line 4: warning: left operand of "." must be lvalue in
this context
left operand of "." must be struct/union objectThe . operator is only supposed to be applied to structure or union objects. The diagnostic is an error if the operand to the left of . is an array, pointer, function call, enumeration constant or variable, or a register value that got allocated to a register; it is a warning otherwise.
f(void){
struct s { short s; };
int i;
i.s = 4;
}
"file," line 4: warning: left operand of "." must be struct/
union object
()-less function definitionThe declarator portion of a function definition must include parentheses. A function cannot be defined by writing a typedef name for a function type, followed by an identifier and the braces ({ }) that define a function.
typedef int F();
F f{ }
"file," line 2: ()-less function definition
long long and unsigned long long are extensions to ANSI CA standard conforming C compiler must emit a diagnostic about "bad" use of type specifiers. This warning is produced only at the first use of long long in a compile.
long long a;"file", line 1: warning: long long and unsigned long long are extensions to ANSI C
loop not entered at topThe controlling expression at the beginning of a for or while loop cannot be reached by sequential flow of control from the statement before it.
f(void){
int i;
goto lab;
for (i = 1; i > 0; --i) {
lab:;
i=5;
}
}
"file," line 4: warning: loop not entered at top
macro nesting too deepThe source code defines a macro that causes the compiler to run out of memory during preprocessing.
macro recursionThe source code calls a macro that calls itself, either directly or indirectly. ANSI C's semantics prevent further attempts to rescan the macro. Older C compilers would try to rescan the macro.
Because the rescanning rules are different for ANSI C and its predecessor, the compiler provides the old behavior in -Xt mode, which includes producing this diagnostic when macro recursion is detected.
#define a(x) b(x) #define b(x) a(x) a(3)"file," line 3: warning: macro recursion
macro redefined: nameThe source code redefined a macro. Previous releases allowed such redefinitions silently if both definitions were identical except for the order and spelling of formal parameters. ANSI C requires that, when a macro is redefined correctly, the definitions must be identical including the order and spelling of formal parameters. This diagnostic is produced under all options if the new macro definition disagrees with the old one. For strict conformance, it is also produced under the -Xc option when the macro definitions disagree only in the spelling of the formal parameters.
#define TIMES(a,b) a"file," line 2: warning: macro redefined: TIMES
macro replacement within a character constantPrevious releases allowed the value of a formal parameter to be substituted in a character constant that is part of a macro definition. ANSI C does not permit such a use. The compiler provides the old behavior in -Xt mode with the warning.
#define CTRL(x) ('x'&037) / form control character /
int ctrl_c = CTRL(c);
"file," line 1: warning: macro replacement within a character
constant
The proper way to express this construct in ANSI C is the following:
#define CTRL(x) (x&037) /int ctrl_c = CTRL('c');
macro replacement within a string literalThis message diagnoses a similar condition to the preceding one, except the substitution is being made into a string literal.
#define HELLO(name) "hello, name"char
"file," line 1: warning: macro replacement within a string literal
ANSI C provides a way to accomplish the same thing. The # ``string-ize'' operator turns the tokens of a macro argument into a string literal, and adjacent string literals are concatenated. The correct form is:
#define HELLO(name) "hello, " #namechar
member cannot be function: nameA function may not be a member of a structure or union, although a pointer to a function may. Member name was declared as a function.
struct s { int f(void); };
"file," line 1: member cannot be function: f
mismatched "?" and ":"An expression in a #if or #elif directive contained a malformed ? : expression.
#if defined(foo) ? 5
int i;
#endif
"file," line 1: mismatched "?" and ":"
mismatched parenthesesParentheses were mismatched in a preprocessing conditional compilation directive.
#if ((1)
int i = 1;
#endif
"file," line 1: mismatched parentheses
missing ")"In a test of a predicate that follows a # operator in a #if or #elif directive, the ) that follows the assertion was missing.
#if # system(unix
char system = "unix";
#endif
"file," line 1: missing ")"
missing formal name in % lineIn an enhanced asm function, a % line specified a storage class, but not the formal parameter than has that storage class.
missing operandThe constant expression of a preprocessing conditional compilation directive is malformed. An expected operand for some operator was missing.
#define EMPTY
#if EMPTY / 4
int i = 1;
#endif
"file," line 2: missing operand
missing operatorThe constant expression of a preprocessing conditional compilation directive is malformed. An operator was expected but was not encountered.
#if 1 4
int i = 1;
#endif
"file," line 1: missing operator
missing tokens between parenthesesIn a #assert directive, there are no assertions within the parentheses of the predicate.
#assert system()"file," line 1: missing tokens between parentheses
modifying typedef with "modifier"; only qualifiers allowedANSI C prohibits applying a type modifier to a typedef name. ANSI C only permits modifying a typedef with a type qualifier (const, volatile). However, for compatibility, in -Xt mode the compiler accepts the declaration and treats it as did previous releases. In -Xa or -Xc mode, this declaration is rejected.
typedef int INT; unsigned INT i;"file," line 2: warning: modifying typedef with "unsigned"; only qualifiers allowed
modulus by zeroThe second operand of a % operator is zero. If the modulus operation is part of a #if or #elif directive, the result is taken to be zero.
The diagnostic is a warning if the modulus is in executable code, an error otherwise.
#if 42 % 0
int i = 1;
#endif
"file," line 1: warning: modulus by zero
more than one character honored in character constant: constantA character constant has an integral value that derives from the character codes of the characters. If a character constant comprises more than one character, the encoding of the additional characters depends on the implementation. This warning alerts you that the encoding that the preprocessing phase uses for the character constant constant is different in this release of the C compiler from the one in previous releases, which only honored the first character.
(The encoding for character constants you use in executable code is unchanged.)
#if 'ab' != ('b' 256 + 'a')
#error unknown encoding
#endif
"file," line 1: warning: more than one character honored in
character constant: 'ab'
"#" must be followed by formal identifier in #defineThe ``string-ize'' operator # must be followed by the name of a formal parameter in a function-like macro.
#define mac(a) # + a"file," line 1: "#" must be followed by formal identifier in #define
must have type "function-returning-unsigned": nameThe name that is a part of a #pragma int_to_unsigned directive must be an identifier whose type is function-returning-unsigned.
extern int f(int); #pragma int_to_unsigned f"file," line 2: warning: must have type "function-returning-unsigned": f
name in asm % line is not a formal: nameThe identifier name that followed a storage class specifier in the % line of an enhanced asm function was not one of the formal parameters of the function.
nested asm calls not now supportedThe compiler does not now support calls to enhanced asm functions as part of the argument expression for another enhanced asm function.
newline in character constantA character constant was written that had no closing ' on the same line as the beginning '.
int i = 'a ;"file," line 1: newline in character constant
newline in string literalA string literal was written that had no closing " on the same line as the beginning ". The diagnostic is a warning if the string literal is part of a preprocessing directive (and the compiler provides the missing ") and an error otherwise.
char"file," line 1: newline in string literal
newline not last character in fileEvery non-empty source file and header must consist of complete lines. This diagnostic warns that the last line of a file did not end with a newline.
no %-specification line found in asm: nameThe program includes the definition of an enhanced asm function name with parameters but that does not contain at least one match specification line (a line that begins with a ``%'' character). Such asm definitions will have no effect.
asm int identity(int arg) {
movl arg, %eax
}
"file", line 3: no %-specification line found in asm: identity
no actual for asm formal: nameAn enhanced asm function was called with fewer arguments than there were parameters in the definition. Thus there was no actual argument for parameter name.
no closing ">" in "#include <..."A #include directive that used the < > form of header omitted the closing >.
#include <stdio.h"file," line 1: warning: #include <... missing '>'
no file name after expansionThe form of #include directive was used that permits macro expansion of its argument, but the resulting expansion left no tokens to be taken as a file name.
#define EMPTY #include EMPTY"file," line 2: no file name after expansion
no hex digits follow \xThe \x escape in character constants and string literals introduces a hexadecimal character escape. The \x must be followed by at least one hexadecimal digit.
char"file," line 1: warning: no hex digits follow \x
no macro replacement within a character constantThis message is the inverse of
macro replacement within a character constant.
It informs you that the macro replacement that was done for
-Xt
mode is not being done in
-Xa
or
-Xt
mode.
no macro replacement within a string literalThis message is the inverse of
macro replacement within a string literal.
It informs you that the macro replacement that was done for
-Xt
mode is not being done in
-Xa
or
-Xc
mode.
no tokens after expansionAfter macro expansion was applied to the expression in a #line directive, there were no tokens left to be interpreted as a line number.
#define EMPTY #line EMPTY"file," line 2: no tokens after expansion
no tokens follow "#pragma"The compiler encountered a #pragma directive that contained no other tokens.
#pragma"file," line 1: warning: no tokens follow "#pragma"
no tokens following "#assert name ("A use of the #assert directive is malformed. The assertions and the ) that should follow are missing.
#assert system("file," line 1: no tokens following "#assert name ("
no tokens in #line directiveThe rest of a #line directive was empty; the line number and optional file name were missing.
#line"file," line 1: no tokens in #line directive
no type specifiers present: assuming "int"Declarations without any type specifiers is primarily supported for compatibility and is expected to be an anachronism in the next C standard.
static x=2;
f(){return 7;}
"file", line 1: no type specifiers present: assuming "int"
"file", line 2: no type specifiers present: assuming "int"
non-constant initializer: op "operator"The initializer for an extern, static, or array object must be a compile-time constant. The initializers for an automatic structure or union object, if enclosed in { }, must also be compile-time constants. operator is the operator whose operands could not be combined at compile time.
int j; int k = j+1;"file," line 2: non-constant initializer: op "+"
non-formal identifier follows "#" in #defineThe identifier that follows a # operator in a macro definition must be a formal parameter of a function-like macro.
#define mac(a) "abc" # b"file," line 1: non-formal identifier follows "#" in #define
non-integral case expressionThe operand of a case statement must be an integral constant.
f(void){
int i = 1;
switch (i) {
case 5.0: ;
}
}
"file," line 4: non-integral case expression
non-unique member requires struct/union: nameThe operand on the left side of a . operator was not a structure, union, or a pointer to one, and member name was not unique among all structure and union members that you have declared. Use . only with structures or unions. The member should belong to the structure or union corresponding to the left operand.
struct s1 { int x,y; };
struct s2 { int y,z; };
f(void){
long lp;
lp.y = 1;
}
"file," line 5: non-unique member requires struct/union object:
y
"file," line 5: left operand of "." must be struct/union object
non-unique member requires struct/union pointer: nameThis message diagnoses the same condition as the preceding one, but for the -> operator.
null character in inputThe compiler encountered a null character (a character with a character code of zero).
null dimension: nameA dimension of an array is null in a context where that is prohibited. The diagnostic is a warning if the offending dimension is outermost and an error otherwise.
int ia[4][];
struct s { int x, y[]; };
int i = sizeof(int []);
"file," line 1: null dimension: ia
"file," line 2: warning: null dimension: y
"file," line 3: warning: null dimension: sizeof()
number expectedThe compiler did not find a number where it expected to find one in a #if or #elif directive.
#if 1 +
int i = 1;
#endif
"file," line 1: number expected
old-style declaration hides prototype declaration: nameThe function name was declared in an inner scope. The outer declaration was a function prototype declaration, but the inner one lacks parameter information. By ANSI C's scoping rules, the parameter information is hidden and the automatic conversions of types that the prototype would have provided are suppressed.
extern double sin(double);
f(void){
extern double sin();
double d;
d = sin(1); / Note: no conversion to double! /
}
"file," line 3: warning: old-style declaration hides prototype
declaration: sin
"file," line 5: warning: argument does not match remembered
type: arg #1
only one storage class allowedMore than one storage class was specified in a declaration.
f(void){
register auto i;
}
"file," line 2: only one storage class allowed
only qualifiers allowed after Only the const or volatile type qualifiers may be specified after a
in a declaration.
int"file," line 2: only qualifiers allowed after
only "register" valid as formal parameter storage classA storage class specifier may be specified in a function prototype declaration, but only register is permitted.
int f(
register int x,
auto int y
);
"file," line 3: only "register" valid as formal parameter
storage class
operand cannot have void type: op "operator"One of the operands of operator has void type.
f(void){
void v(void);
int i = v();
}
"file," line 3: operand cannot have void type: op "="
"file," line 3: assignment type mismatch
operand must be modifiable lvalue: op "operator"The operand of operator must be a modifiable lvalue, but it wasn't.
f(void){
int i = --3;
}
"file," line 2: operand must be modifiable lvalue: op "--"
operand treated as unsigned: constantAn operand used in a #if or #elif directive has a value greater than LONG_MAX (2147483647) but has no unsigned modifier suffix (u or U). Previous releases treated such constants as signed quantities which, because of their values, actually became negative. ANSI C treats such constants as unsigned long integers, which may affect their behavior in expressions. This diagnostic is a transition aid that informs you that the value is being treated differently from before.
#if 2147483648 > 0
char mesg = "ANSI C-style";
#endif
"file," line 1: warning: operand treated as unsigned:
2147483648
operands have incompatible pointer types: op "operator"operator was applied to pointers to different types.
f(void){
char cp;
int ip;
if (ip < cp)
;
}
"file," line 4: warning: operands have incompatible pointer
types: op "<"
operands have incompatible types: op "operator"The types of the operands for operand are unsuitable for that type of operator.
f(void){
char cp;
int ip;
void vp = ip + cp;
}
"file," line 4: operands have incompatible types: op "+"
operands must have category type: op "operator"The operands for operator do not fall into the appropriate category for that operator. category may be arithmetic, integral, or scalar.
f(void){
int ia[5];
int ip = ia/4;
}
"file," line 3: operands must have arithmetic type: op "/"
out of scope extern and prior uses redeclared as static: namename was declared as extern in a block that has gone out of scope. Then name was declared again, this time as static. The compiler treats the object or function as if it were static, and all references, including ones earlier in the source file, apply to the static version.
f(void){
extern int i;
}
static int i;
"file," line 4: warning: out of scope extern and prior uses
redeclared as static: i
overflow in hex escapeIn a hexadecimal escape (\x) in a character constant or string literal, the accumulated value for the escape grew too large. Only the low-order 32 bits of value are retained.
int i = '\xabcdefedc';"file," line 1: warning: \x is ANSI C hex escape "file," line 1: warning: overflow in hex escape "file," line 1: warning: character escape does not fit in character
parameter mismatch: ndecl declared, ndef definedA function prototype declaration and an old-style definition of the function disagree in the number of parameters. The declaration had ndecl parameters, while the definition had ndef.
int f(int);
int f(i,j)
int i,j;
{}
"file," line 4: warning: parameter mismatch: 1 declared,
2 defined
parameter not in identifier list: nameVariable name appears in an old-style function definition's parameter declarations, but it does not appear in the parameter identifier list.
f(a,b)
int i;
{}
"file," line 2: parameter not in identifier list: i
parameter redeclared: namename was used more than once as the name for a parameter in a function definition.
int f(int i, int i) { }
int g(i,j)
int i;
int i;
{ }
"file," line 1: parameter redeclared: i
"file," line 4: parameter redeclared: i
preprocessing a .i fileThe source file is a .i file, a file that has already been preprocessed, and the -E cc option was selected. The compiler will simply copy the input file to the standard output without further processing.
prototype mismatch: n1 arg[s] passed, n2 expectedA function for which there is a function prototype declaration in scope, and the number of arguments in the call, n2, did not match the number of parameters in the declaration, n1.
int f(int);
g(void){
f(1,2);
}
"file," line 3: prototype mismatch: 2 args passed, 1 expected
return value type mismatchA value from a function cannot be returned that cannot be converted to the return-type of the function.
f(void){
struct s { int x; } st;
return( st );
}
"file," line 3: return value type mismatch
semantics of "operator" change in ANSI C; use explicit castThe type promotion rules for ANSI C are slightly different from those of previous releases. In the current release the default behavior is to use the ANSI C rules. To obtain the old behavior, use the -Xt option for the cc command.
Previous type promotion rules were ``unsigned-preserving.'' If one of the operands of an expression was of unsigned type, the operands were promoted to a common unsigned type before the operation was performed.
ANSI C uses ``value-preserving'' type promotion rules. An unsigned type is promoted to a signed type if all its values may be represented in the signed type.
The different type promotion rules may lead to different program behavior for the operators that are affected by the unsigned-ness of their operands:
-
The division operators:
/,
/=,
%,
%=.
-
The right shift operators:
>>,
>>=.
- The relational operators: <, <=, >, >=.
The warning message tells that the program contains an expression in which the behavior of operator changes in the -Xa or -Xc mode. To guarantee the desired behavior, insert an explicit cast in the expression.
f(void){
unsigned char uc;
int i;
/ was unsigned divide, signed in ANSI C /
i /= uc;
}
"file," line 5: warning: semantics of "/=" change in ANSI C;
use explicit cast
To get the same behavior as in previous releases add an explicit cast:
f(void){
unsigned char uc;
int i;
/ was unsigned divide, signed in ANSI C /
i /= (unsigned int) uc;
}
shift count negative or too big: op nThe compiler determined that the shift count (the right operand) for shift operator op is either negative or bigger than the size of the operand being shifted.
f(){
short s;
s <<= 25;
}
"file," line 3: warning: shift count negative or too big:
<<= 25
statement not reachedThis statement in the program cannot be reached because of goto, break, continue, or return statements preceding it.
f(void){
int i;
return i;
i = 4;
}
"file," line 4: warning: statement not reached
static function called but not defined: name()The program calls function name, which has been declared static, but no definition of name appears in the translation unit. (The line number that is displayed in the message is one more than the number of lines in the file, because this condition can be diagnosed only after the entire translation unit has been seen.)
static int statfunc(int);
void
f(){
int i = statfunc(4);
}
"file," line 7: warning: static function called but not
defined: statfunc()
static redeclares external: namename was reused as the name of a static object or function after having used it in the same block as the name of an extern object or function. The version of name that remains visible is the static version.
f(void){
extern int i;
static int i;
}
"file," line 3: warning: static redeclares external: i
storage class after type is obsolescentAccording to the ANSI C standard, writing declarations in which the storage class specifier is not first is ``obsolescent.''
int static i;"file," line 1: warning: storage class after type is obsolescent
storage class for function must be static or externAn inappropriate storage class specifier for a function declaration or definition was used. Only extern and static may be used, or the storage class may be omitted. The specifier is ignored.
f(void){
auto g(void);
}
"file," line 2: warning: storage class for function must be
static or extern
string literal expected after # <number>The # line information directive takes an optional second token, a file name. If present, it must be in the form of a string literal.
# 1 x.c"file," line 1: warning: string literal expected after # <number> "file," line 1: warning: tokens ignored at end of directive line
string literal expected after #fileThe #file directive (which is reserved for the compilation system) is used for internal communication between preprocessing and compilation phases. A string literal operand is expected as the operand.
string literal expected after #identA #ident directive must be followed by a normal (not wide character) string literal.
#ident no-string"file," line 1: string literal expected after #ident
string literal expected after #line <number>This diagnostic is similar to
string literal expected after # <number>,
except that it applies to the standard
#line
directive.
string literal must be sole array initializerIt is not permissible to initialize a character array with both a string literal and other values in the same initialization.
char ca[] = { "abc", 'd' };
"file," line 1: warning: string literal must be sole array
initializer
struct/union has no named membersA structure or union was declared in which none of the members is named.
struct s { int :4; char :0; };
"file," line 1: warning: struct/union has no named members
struct/union-valued initializer requiredANSI C allows you to initialize an automatic structure or union, but the initializer must have the same type as the object being initialized.
f(void){
int i;
struct s { int x; } st = i;
}
"file," line 3: warning: {}-enclosed initializer required
"file," line 3: struct/union-valued initializer required
switch expression must have integral typeA switch statement was written in which the controlling expression did not have integral type. The message is a warning if the invalid type is a floating-point type and an error otherwise. A floating-point switch expression is converted to int.
f(void){
float x;
switch (x) {
case 4: ;
}
}
"file," line 3: warning: switch expression must have integral
type
syntax error before or at: tokenThis is an all-purpose diagnostic that means you have juxtaposed two (or more) language tokens inappropriately. The compiler shows you the token at which the error was detected.
f(void){
int i = 3+;
}
"file," line 2: syntax error before or at: ;
syntax error in macro parametersThe macro parameter list part of a function-like macro definition is malformed. The list must be a comma-separated list of identifiers and was not.
#define mac(a,b,) a b"file," line 1: syntax error in macro parameters
syntax error, probably missing ",", ";" or "="A declaration that looked like a function definition was written, except that the type of the symbol declared was not ``function returning.'' A ; or =. is needed.
int i int j;"file," line 2: syntax error, probably missing ",", ";" or "=" "file," line 2: parameter not in identifier list: j "file," line 4: syntax error before or at: <EOF>
syntax error: empty declarationA null statement was written at file scope. This looks like an empty declaration statement and was previously permitted, but ANSI C does not.
int i;;"file," line 1: warning: syntax error: empty declaration
syntax error: "&..." invalidA &... was written in a program that was compiled with the -Xc option. &... is invalid ANSI C syntax. Do not use this notation explicitly.
syntax requires ";" after last struct/union memberThe ; that C syntax requires after the last structure or union member in a structure or union declaration was omitted.
struct s { int x };
"file," line 1: warning: syntax requires ";" after last
struct/union member
(type) tag redeclared: nameThe tag name that was originally a type (struct, union, or enum) tag was redeclared.
struct q { int m1, m2; };
enum q { e1, e2 };
"file," line 2: (struct) tag redeclared: q
token not allowed in directive: tokenA token was used in a #if or #elif directive that is neither a valid operator for constant expressions, nor a valid integer constant.
#if 1 > "1"
int i = 1;
#endif
"file," line 1: token not allowed in directive: "1"
token-less macro argumentThe actual argument to a preprocessor macro consisted of no tokens. The ANSI C standard regards this condition as undefined. The compiler treats the empty list of tokens as an empty argument, and, under the -Xc mode, it also issues this warning.
#define m(x) x+3 int i = m();"file," line 2: warning: token-less macro argument
tokens after -A- are ignoredIn the -A- option to the cc command, there were additional tokens adjacent to the option. They are ignored.
cc -A-extra -c x.c command line: warning: tokens after -A- are ignored
tokens expected after "# identifier ("When the # operator is used in a #if or #elif directive to select a predicate instead of a like-named macro, the predicate must be followed by a parenthesized list of tokens.
#if #system(
char system = "unix";
#endif
"file," line 1: tokens expected after "# identifier ("
tokens expected after "("In a #unassert directive, the assertion(s) and closing ) after the predicate were missing.
#unassert system("file," line 1: tokens expected after "("
tokens expected between parenthesesThe name of an assertion of a predicate to test was omitted in an #if or #elif directive.
#if #system()
char sysname = "??";
#endif
"file," line 1: tokens expected between parentheses
tokens ignored after "-U{identifier}"In the command line -U option, there were tokens following the name of the macro to be undefined.
cc -Uunix,u3b2 -c x.c
command line: warning: tokens ignored after "-U{identifier}"
tokens ignored at end of directive lineA directive line contains extra tokens that are not expected as part of the directive.
#undef a b /"file," line 1: warning: tokens ignored at end of directive line
too many array initializersMore initializers than the array can hold were provided for the array.
int ia[3] = { 1, 2, 3, 4 };
"file," line 1: too many array initializers
too many #else'sThe code contained more that one #else directive in a preprocessing if-section. All #else directives after the first are taken to be false.
#ifdef ONE
int i = 1;
#else
int i = 2;
#else
int i = 3;
#endif
"file," line 5: warning: too many #else's
too many errorsThe compiler encountered too many errors to make further processing sensible. Rather than produce further diagnostics, the compiler exits.
too many initializers for scalarA { }-bracketed initialization for a scalar contains more than one value.
int i = { 1, 2 };
"file," line 1: too many initializers for scalar
too many struct/union initializersToo many initializers for a structure or union were provided.
struct s { int x,y; } st = { 1,2,3 };
"file," line 1: too many struct/union initializers
trailing "," prohibited in enum declarationAn extra comma was supplied at the end of an enumeration type declaration. The extra comma is prohibited by the syntax.
enum e { e1, e2, };
"file," line 1: warning: trailing "," prohibited in enum
declaration
trigraph sequence replacedANSI C introduces the notion of trigraphs, three-character sequences that stand for a single character. All such sequences begin with ??. Because sequences that are interpreted as trigraphs may appear in existing code, the compiler produces a transitional diagnostic when such sequences are encountered in transition mode (-Xt.
char"file," line 1: warning: trigraph sequence replaced
type does not match prototype: nameA function prototype declaration for a function was provided, but it used an old-style definition. The type for parameter name in that definition is incompatible with the type you used in the prototype declaration.
int f(char"file," line 4: warning: type does not match prototype: p
The following example shows an especially confusing instance of this diagnostic.
int f(char);
int f(c)
char c;
{}
"file," line 3: warning: identifier redeclared: f
"file," line 4: warning: type does not match prototype: c
f has an old-style definition. For compatibility reasons, f's arguments must therefore be promoted according to the default argument promotions, which is how they were promoted before the existence of function prototypes. Therefore the value that must actually be passed to f is an int, although the function will only use the char part of the value. The diagnostic, then, identifies the conflict between the int that the function expects and the char that the function prototype would (conceptually) cause to be passed.
There are two ways to fix the conflict:
-
Change the function prototype to read
int f(int);
-
Define
f
with a function prototype definition:
int f(char); int f(char c) {}
typedef already qualified with "qualifier"A type specifier includes a typedef and an explicit type qualifier, qualifier. The typedef already included qualifier when it was declared.
typedef volatile int VOL; volatile VOL v;"file," line 2: warning: typedef already qualified with "volatile"
typedef declares no type nameIn a declaration with storage class typedef, no type name was actually declared. This is probably a programming error.
typedef struct s { int x; };
"file," line 1: warning: typedef declares no type name
typedef redeclared: nametypedef name was declared more than once. The later declaration has an identical type to the first.
typedef int i; typedef int i;"file," line 2: warning: typedef redeclared: i
typedef redeclares external: nametypedef name was declared, but there is an extern of the same name in the same block. The typedef hides the external.
f(void){
extern int INT;
typedef int INT;
}
"file," line 3: warning: typedef redeclares external: INT
"typedef" valid only for function declarationA function definition may not have the typedef storage class. It is ignored here.
typedef int f(void){}
"file," line 1: warning: "typedef" valid only for function
declaration
unacceptable operand for unary &An attempt was made to take the address of something whose address cannot be taken.
f(void){
int ip = &g();
}
"file," line 2: unacceptable operand for unary &
#unassert requires an identifier tokenThe #unassert directive must name a predicate to ``un-assert.''
#unassert 5"file," line 1: #unassert requires an identifier token
undefined label: labelA goto was written in the current function, but the target label was never defined anywhere within the function.
f(void){
goto L;
}
"file," line 3: undefined label: L
undefined struct/union member: nameThe program made reference to a structure or union member, name, that has not been declared as part of any structure.
struct s { int x; };
f(void){
struct s q;
q.y = 1;
}
"file," line 4: undefined struct/union member: y
undefined symbol: nameA symbol name was referred to for which there is no declaration in scope.
f(void){
g(i);
}
"file," line 2: undefined symbol: i
undefining __STDC__ANSI C prohibits undefining the predefined symbol __STDC__. However, C issue 5 permits you to do so in transition mode (only). Use this feature to test C code that has been written to work in both an ANSI C and non-ANSI C environment.
For example, suppose you have C code that checks __STDC__, declaring function prototype declarations if it is defined, and old-style function declarations (or definitions) if not. Because the compiler predefines __STDC__, you would ordinarily be unable to check the old-style code, and you would have to run the code through another (non-ANSI C) compiler. By undefining __STDC__ (usually on the command line), you can use the compiler to do the checking. This diagnostic tells you, as required, that you are violating ANSI C constraints.
#undef __STDC__ /#ifdef __STDC__ int myfunc(const char
"file," line 1: warning: undefining __STDC__ "file," line 10: syntax error before or at: int "file," line 12: syntax error before or at: {
unexpected "("A misplaced ( was encountered in a #if or #elif directive.
#if 1 (
int i = 1;
#endif
"file," line 1: unexpected "("
unexpected ")"A misplaced ) was encountered in a #if or #elif directive.
#if ) 1
int i = 1;
#endif
"file," line 1: unexpected ")"
unexpected character in asm % line: 'c'In the % specification line of an enhanced asm function, the compiler expected to see an alphabetic character that begins a storage class specifier. Instead it encountered the character c.
unknown operand size: op "operator"operator ++, --, or = was applied to an operand whose size is unknown. The operand is usually a pointer to a structure or union whose members have not been declared.
f(void){
struct s sp;
sp++;
}
"file," line 3: unknown operand size: op "++"
unnamed type memberIn the type declaration, you failed to give a member a name.
union s { int; char c; };
"file," line 1: warning: unnamed union member
unreachable case label: valueThe expression specified in a case statement has a value outside the range of the type of the controlling expression of the enclosing switch statement. Therefore the case label can never be reached. In the message, value is represented as a hexadecimal value if the case expression is unsigned, decimal if it is signed.
f(){
unsigned char uc;
switch( uc ){
case 256:
;
}
}
"file," line 5: warning: unreachable case label: 256
unreached side effect or comma operator: op operatorThe C Standard requires that constant expressions shall not contain assignment, increment, decrement, function calls, or comma operators, except when they are contained within the operand of a sizeof operator.
void f(int j){static int i = 1 ? 2 : (++j);}
"file", line 1: unreached side effect or comma operator: op "+="
unrecognized #pragma ignored: pragmaBecause #pragma directives are implementation-specific, when the -v compilation flag is set, the compiler warns about any such directives that it is ignoring. The compiler does not recognize #pragma pragma.
#pragma list"file," line 1: warning: unrecognized #pragma ignored: list
unused label: labelWhen using acomp (a component name for the ANSI C compiler) if the -v compilation flag is set, the compiler warns if a label is declared but never used in a function. When removing labels from the symbol table, it checks the SY_REF flag and warns if it is unset.
"file," line 4: warning: unused label: label
use "double" instead of "long float"An object or function was declared to be long float, which was a synonym for double. ANSI C does not permit long float, although the compiler accepts it as a transition aid.
long float f = 1.0;"file," line 1: warning: use "double" instead of "long float"
useless declarationANSI C requires that every declaration actually declare something, such as
-
a declarator,
-
a structure or union tag,
-
structure or union members, or
- enumeration constants.
A declaration was written that provided no information to the compiler.
int; /"file," line 1: warning: useless declaration "file," line 3: warning: useless declaration
using out of scope declaration: namename was previously declared in a scope that is no longer active. In some ANSI C implementations, referring to such an object would yield an error; calling such a function would be interpreted as calling a function returning int. The compiler remembers the previous declaration and uses it. This warning tells what the compiler has done.
f(void){
extern int i;
double sin(double);
}
g(void){
double d = sin(1.5);
i = 1;
}
"file," line 6: warning: using out of scope declaration: sin
"file," line 7: warning: using out of scope declaration: i
using out of scope dimension: operatorThe size of what is conceptually an incomplete external array type is needed by the operator; the compiler is able to use the dimension defined at some previous inner scope.
int i[];
foo() {
{extern int i[10];}
bar(sizeof)(i));
}
"file", line 4: warning: using out of scope dimension: sizeof()
void expressions may not be arguments: arg #nA function call contains an argument for which the expression type is void.
f(void){
void v(void);
g(v());
}
"file," line 3: void expressions may not be arguments: arg #1
void function cannot return valueA return was written statement with an expression, but the declared type of the function is void.
void v(void){
return 3;
}
"file," line 2: void function cannot return value
"void" must be sole parameterOnly the first parameter in a function prototype declaration may have void type, and it must be the only parameter.
int f(int,void);"file," line 1: "void" must be sole parameter
void parameter cannot have name: nameThe parameter name was declared in a function prototype declaration that has void type.
int f(void v);"file," line 1: void parameter cannot have name: v
\x is ANSI C hex escapeIn earlier releases, '\x' was equivalent to 'x'. However, in ANSI C, '\x' introduces a hexadecimal character escape. This diagnostic warns of the new meaning.
If valid hexadecimal characters follow '\x', they are interpreted as part of the new escape sequence. Otherwise '\x' is treated as it was in previous releases.
int i = '\x';"file," line 1: warning: \x is ANSI C hex escape
zero or negative subscriptThe size in an array declaration is zero or negative. The diagnostic is a warning if the size is zero and an error otherwise.
int ia[-5]; int ib[0];"file," line 1: zero or negative subscript "file," line 2: warning: zero or negative subscript
zero-sized struct/unionA structure or union was declared with the size of zero.
struct s { int ia[0]; };
"file," line 1: warning: zero or negative subscript
"file," line 1: zero-sized struct/union