25.1 Errors

Symbols

\x used with no following HEX digits

The escape sequence \x should be followed by hex digits.

‘&’ constraint used with no register class

The asm statement is invalid.

‘%’ constraint used with last operand

The asm statement is invalid.

#elif after #else

In a preprocessor conditional, the #else clause must appear after any #elif clauses.

#elif without #if

In a preprocessor conditional, the #if must be used before using the #elif.

#else after #else

In a preprocessor conditional, the #else clause must appear only once.

#else without #if

In a preprocessor conditional, the #if must be used before using the #else.

#endif without #if

In a preprocessor conditional, the #if must be used before using the #endif.

#error ‘message’

This error appears in response to a #error directive.

#if with no expression

An expression that evaluates to a constant arithmetic value was expected.

#include expects “FILENAME” or <FILENAME>

The file name for the #include is missing or incomplete. It must be enclosed by quotes or angle brackets.

‘#’ is not followed by a macro parameter

The stringsize operator, ‘#’ must be followed by a macro argument name.

‘#keyword’ expects “FILENAME” or <FILENAME>

The specified ‘#keyword’ expects a quoted or bracketed file name as an argument.

‘#’ is not followed by a macro parameter

The ‘#’ operator should be followed by a macro argument name.

‘##’ cannot appear at either end of a macro expansion

The concatenation operator, ‘##’ may not appear at the start or the end of a macro expansion.

a parameter list with an ellipsis can’t match an empty parameter name list declaration

The declaration and definition of a function must be consistent.

“symbol” after #line is not a positive integer

#line is expecting a source line number which must be positive.

aggregate value used where a complex was expected

Do not use aggregate values where complex values are expected.

aggregate value used where a float was expected

Do not use aggregate values where floating-point values are expected.

aggregate value used where an integer was expected

Do not use aggregate values where integer values are expected.

alias arg not a string

The argument to the alias attribute must be a string that names the target for which the current identifier is an alias.

alignment may not be specified for ‘identifier’

The aligned attribute may only be used with a variable.

‘__alignof’ applied to a bit-field

The ‘__alignof’ operator may not be applied to a bit-field.

alternate interrupt vector is not a constant

The interrupt vector number must be an integer constant.

alternate interrupt vector number n is not valid

A valid interrupt vector number is required.

ambiguous abbreviation argument

The specified command-line abbreviation is ambiguous.

an argument type that has a default promotion can’t match an empty parameter name list declaration.

The declaration and definition of a function must be consistent.

args to be formatted is not ...

The first-to-check index argument of the format attribute specifies a parameter that is not declared ‘…’.

argument ‘identifier’ doesn’t match prototype

Function argument types should match the function’s prototype.

argument of ‘asm’ is not a constant string

The argument of ‘asm’ must be a constant string.

argument to ‘-B’ is missing

The directory name is missing.

argument to ‘-l’ is missing

The library name is missing.

argument to ‘-specs=’ is missing

The name of the specs file is missing.

argument to ‘-x’ is missing

The language name is missing.

argument to ‘-Xlinker’ is missing

The argument to be passed to the linker is missing.

arithmetic on pointer to an incomplete type

Arithmetic on a pointer to an incomplete type is not allowed.

array index in non-array initializer

Do not use array indices in non-array initializers.

array size missing in ‘identifier’

An array size is missing.

array subscript is not an integer

Array subscripts must be integers.

‘asm’ operand constraint incompatible with operand size

The asm statement is invalid.

‘asm’ operand requires impossible reload

The asm statement is invalid.

asm template is not a string constant

Asm templates must be string constants.

assertion without predicate

#assert or #unassert must be followed by a predicate, which must be a single identifier.

‘attribute’ attribute applies only to functions

The attribute ‘attribute’ may only be applied to functions.

bit-field ‘identifier’ has invalid type

Bit-fields must be of enumerated or integral type.

bit-field ‘identifier’ width not an integer constant

Bit-field widths must be integer constants.

both long and short specified for ‘identifier’

A variable cannot be of type long and of type short.

both signed and unsigned specified for ‘identifier’

A variable cannot be both signed and unsigned.

braced-group within expression allowed only inside a function

It is illegal to have a braced-group within expression outside a function.

break statement not within loop or switch

Break statements must only be used within a loop or switch.

__builtin_longjmp second argument must be 1

__builtin_longjmp requires its second argument to be 1.

called object is not a function

Only functions may be called in C.

cannot convert to a pointer type

The expression cannot be converted to a pointer type.

cannot put object with volatile field into register

It is not legal to put an object with a volatile field into a register.

cannot reload integer constant operand in ‘asm’

The asm statement is invalid.

cannot specify both near and far attributes

The attributes near and far are mutually exclusive, only one may be used for a function or variable.

cannot take address of bit-field ‘identifier’

It is not legal to attempt to take address of a bit-field.

can’t open ‘file’ for writing

The system cannot open the specified ‘file’. Possible causes are not enough disk space to open the file, the directory does not exist, or there is no write permission in the destination directory.

can’t set ‘attribute’ attribute after definition

The ‘attribute’ attribute must be used when the symbol is defined.

case label does not reduce to an integer constant

Case labels must be compile-time integer constants.

case label not within a switch statement

Case labels must be within a switch statement.

cast specifies array type

It is not permissible for a cast to specify an array type.

cast specifies function type

It is not permissible for a cast to specify a function type.

cast to union type from type not present in union

When casting to a union type, do so from type present in the union.

char-array initialized from wide string

Char-arrays should not be initialized from wide strings. Use ordinary strings.

file: compiler compiler not installed on this system

Only the C compiler is distributed; other high-level languages are not supported.

complex invalid for ‘identifier’

The complex qualifier may only be applied to integral and floating types.

conflicting types for ‘identifier’

Multiple, inconsistent declarations exist for identifier.

continue statement not within loop

Continue statements must only be used within a loop.

conversion to non-scalar type requested

Type conversion must be to a scalar (not aggregate) type.

data type of ‘name’ isn’t suitable for a register

The data type does not fit into the requested register.

declaration for parameter ‘identifier’ but no such parameter

Only parameters in the parameter list may be declared.

declaration of ‘identifier’ as array of functions

It is not legal to have an array of functions.

declaration of ‘identifier’ as array of voids

It is not legal to have an array of voids.

‘identifier’ declared as function returning a function

Functions may not return functions.

‘identifier’ declared as function returning an array

Functions may not return arrays.

decrement of pointer to unknown structure

Do not decrement a pointer to an unknown structure.

‘default’ label not within a switch statement

Default case labels must be within a switch statement.

‘symbol’ defined both normally and as an alias

A ‘symbol’ can not be used as an alias for another symbol if it has already been defined.

‘defined’ cannot be used as a macro name

The macro name cannot be called ‘defined’.

dereferencing pointer to incomplete type

A dereferenced pointer must be a pointer to an incomplete type.

division by zero in #if

Division by zero is not computable.

duplicate case value

Case values must be unique.

duplicate label ‘identifier’

Labels must be unique within their scope.

duplicate macro parameter ‘symbol’

‘symbol’ has been used more than once in the parameter list.

duplicate member ‘identifier’

Structures may not have duplicate members.

duplicate (or overlapping) case value

Case ranges must not have a duplicate or overlapping value. The error message ‘this is the first entry overlapping that value’ will provide the location of the first occurrence of the duplicate or overlapping value. Case ranges are an extension of the ANSI standard for the compiler.

elements of array ‘identifier’ have incomplete type

Array elements should have complete types.

empty character constant

Empty character constants are not legal.

empty file name in ‘#keyword’

The file name specified as an argument of the specified #keyword is empty.

empty index range in initializer

Do not use empty index ranges in initializers

empty scalar initializer

Scalar initializers must not be empty.

enumerator value for ‘identifier’ not integer constant

Enumerator values must be integer constants.

error closing ‘file’

The system cannot close the specified ‘file’. Possible causes are not enough disk space to write to the file or the file is too big.

error writing to ‘file’

The system cannot write to the specified ‘file’. Possible causes are not enough disk space to write to the file or the file is too big.

excess elements in char array initializer

There are more elements in the list than the initializer value states.

excess elements in struct initializer

Do not use excess elements in structure initializers.

expression statement has incomplete type

The type of the expression is incomplete.

extra brace group at end of initializer

Do not place extra brace groups at the end of initializers.

extraneous argument to ‘option’ option

There are too many arguments to the specified command-line option.

‘identifier’ fails to be a typedef or built in type

A data type must be a typedef or built-in type.

field ‘identifier’ declared as a function

Fields may not be declared as functions.

field ‘identifier’ has incomplete type

Fields must have complete types.

first argument to __builtin_choose_expr not a constant

The first argument must be a constant expression that can be determined at compile time.

flexible array member in otherwise empty struct

A flexible array member must be the last element of a structure with more than one named member.

flexible array member in union

A flexible array member cannot be used in a union.

flexible array member not at end of struct

A flexible array member must be the last element of a structure.

‘for’ loop initial declaration used outside C99 mode

A ‘for’ loop initial declaration is not valid outside C99 mode.

format string arg follows the args to be formatted

The arguments to the format attribute are inconsistent. The format string argument index must be less than the index of the first argument to check.

format string arg not a string type

The format string index argument of the format attribute specifies a parameter which is not a string type.

format string has invalid operand number

The operand number argument of the format attribute must be a compile-time constant.

function definition declared ‘register’

Function definitions may not be declared ‘register’.

function definition declared ‘typedef’

Function definitions may not be declared ‘typedef’.

function does not return string type

The format_arg attribute may only be used with a function which return value is a string type.

function ‘identifier’ is initialized like a variable

It is not legal to initialize a function like a variable.

function return type cannot be function

The return type of a function cannot be a function.

global register variable follows a function definition

Global register variables should precede function definitions.

global register variable has initial value

Do not specify an initial value for a global register variable.

global register variable ‘identifier’ used in nested function

Do not use a global register variable in a nested function.

‘identifier’ has an incomplete type

It is not legal to have an incomplete type for the specified ‘identifier’.

‘identifier’ has both ‘extern’ and initializer

A variable declared ‘extern’ cannot be initialized.

hexadecimal floating constants require an exponent

Hexadecimal floating constants must have exponents.

implicit declaration of function ‘identifier’

The function identifier is used without a preceding prototype declaration or function definition.

impossible register constraint in ‘asm’

The asm statement is invalid.

incompatible type for argument n of ‘identifier’

When calling functions in C, ensure that actual argument types match the formal parameter types.

incompatible type for argument n of indirect function call

When calling functions in C, ensure that actual argument types match the formal parameter types.

incompatible types in operation

The types used in operation must be compatible.

incomplete ‘name’ option

The option to the command-line parameter name is incomplete.

inconsistent operand constraints in an ‘asm’

The asm statement is invalid.

increment of pointer to unknown structure

Do not increment a pointer to an unknown structure.

initializer element is not computable at load time

Initializer elements must be computable at load time.

initializer element is not constant

Initializer elements must be constant.

initializer fails to determine size of ‘identifier’

An array initializer fails to determine its size.

initializer for static variable is not constant

Static variable initializers must be constant.

initializer for static variable uses complicated arithmetic

Static variable initializers should not use complicated arithmetic.

input operand constraint contains ‘constraint’

The specified constraint is not valid for an input operand.

int-array initialized from non-wide string

Int-arrays should not be initialized from non-wide strings.

interrupt functions must not take parameters

An interrupt function cannot receive parameters. void must be used to state explicitly that the argument list is empty.

interrupt functions must return void

An interrupt function must have a return type of void. No other return type is allowed.

interrupt modifier ‘name’ unknown

The compiler was expecting ‘irq’, ‘altirq’ or ‘save’ as an interrupt attribute modifier.

interrupt modifier syntax error

There is a syntax error with the interrupt attribute modifier.

interrupt pragma must have file scope

#pragma interrupt must be at file scope.

interrupt save modifier syntax error

There is a syntax error with the ‘save’ modifier of the interrupt attribute.

interrupt vector is not a constant

The interrupt vector number must be an integer constant.

interrupt vector number n is not valid

A valid interrupt vector number is required.

invalid #ident directive

#ident should be followed by a quoted string literal.

invalid arg to ‘__builtin_frame_address’

The argument should be the level of the caller of the function (where 0 yields the frame address of the current function, 1 yields the frame address of the caller of the current function, and so on) and is an integer literal.

invalid arg to ‘__builtin_return_address’

The level argument must be an integer literal.

invalid argument for ‘name’

The compiler was expecting ‘data’ or ‘prog’ as the space attribute parameter.

invalid character ‘character’ in #if

This message appears when an unprintable character, such as a control character, appears after #if.

invalid initial value for member ‘name’

Bit-field ‘name’ can only be initialized by an integer.

invalid initializer

Do not use invalid initializers.

Invalid location qualifier: ‘symbol’

Expecting ‘sfr’ or ‘gpr’, which are ignored on dsPIC DSC devices, as location qualifiers.

invalid operands to binary ‘operator’

The operands to the specified binary operator are invalid.

Invalid option ‘option’

The specified command-line option is invalid.

Invalid option ‘symbol’ to interrupt pragma

Expecting shadow and/or save as options to interrupt pragma.

Invalid option to interrupt pragma

Garbage at the end of the pragma.

Invalid or missing function name from interrupt pragma

The interrupt pragma requires the name of the function being called.

Invalid or missing section name

The section name must start with a letter or underscore (‘_’) and be followed by a sequence of letters, underscores and/or numbers. The names ‘access’, ‘shared’ and ‘overlay’ have special meaning.

invalid preprocessing directive #‘directive’

Not a valid preprocessing directive. Check the spelling.

invalid preprologue argument

The preprologue option is expecting an assembly statement or statements for its argument enclosed in double quotes.

invalid register name for ‘name’

File scope variable ‘name’ declared as a register variable with an illegal register name.

invalid register name ‘name’ for register variable

The specified name is not the name of a register.

invalid save variable in interrupt pragma

Expecting a symbol or symbols to save.

invalid storage class for function ‘identifier’

Functions may not have the ‘register’ storage class.

invalid suffix ‘suffix’ on integer constant

Integer constants may be suffixed by the letters ‘u’, ‘U’, ‘l’ and ‘L’ only.

invalid suffix on floating constant

A floating constant suffix may be ‘f’, ‘F’, ‘l’ or ‘L’ only. If there are two ‘L’s, they must be adjacent and the same case.

invalid type argument of ‘operator’

The type of the argument to operator is invalid.

invalid type modifier within pointer declarator

Only const or volatile may be used as type modifiers within a pointer declarator.

invalid use of array with unspecified bounds

Arrays with unspecified bounds must be used in valid ways.

invalid use of incomplete typedef ‘typedef’

The specified typedef is being used in an invalid way; this is not allowed.

invalid use of undefined type ‘type identifier’

The specified type is being used in an invalid way; this is not allowed.

invalid use of void expression

Void expressions must not be used.

“name” is not a valid filename

#line requires a valid file name.

‘filename’ is too large

The specified file is too large to process the file. Its probably larger than 4 GB, and the preprocessor refuses to deal with such large files. It is required that files be less than 4 GB in size.

ISO C forbids data definition with no type or storage class

A type specifier or storage class specifier is required for a data definition in ISO C.

ISO C requires a named argument before ‘...’

ISO C requires a named argument before ‘...’.

label label referenced outside of any function

Labels may only be referenced inside functions.

label ‘label’ used but not defined

The specified label is used but is not defined.

language ‘name’ not recognized

Permissible languages include: c assembler none.

filename: linker input file unused because linking not done

The specified filename was specified on the command line, and it was taken to be a linker input file (since it was not recognized as anything else). However, the link step was not run. Therefore, this file was ignored.

long long long is too long for GCC

The compiler supports integers no longer than long long.

long or short specified with char for ‘identifier’

The long and short qualifiers cannot be used with the char type.

long or short specified with floating type for ‘identifier’

The long and short qualifiers cannot be used with the float type.

long, short, signed or unsigned invalid for ‘identifier’

The long, short and signed qualifiers may only be used with integral types.

macro names must be identifiers

Macro names must start with a letter or underscore followed by more letters, numbers or underscores.

macro parameters must be comma-separated

Commas are required between parameters in a list of parameters.

macro ‘name’ passed x arguments, but takes just y

Too many arguments were passed to macro ‘name’.

macro ‘name’ requires y arguments, but only z given

Not enough arguments were passed to macro ‘name’.

matching constraint not valid in output operand

The asm statement is invalid.

‘symbol’ may not appear in macro parameter list

‘symbol’ is not allowed as a parameter.

Missing ‘=’ for ‘save’ in interrupt pragma

The save parameter requires an equal sign before the variable(s) are listed. For example, #pragma interrupt isr0 save=var1,var2

missing ‘(’after predicate

#assert or #unassert expects parentheses around the answer. For example:  #assert PREDICATE (ANSWER)

missing ‘(’ in expression

Parentheses are not matching, expecting an opening parenthesis.

missing ‘)’ after “defined”

Expecting a closing parenthesis.

missing ‘)’ in expression

Parentheses are not matching, expecting a closing parenthesis.

missing ‘)’ in macro parameter list

The macro is expecting parameters to be within parentheses and separated by commas.

missing ‘)’ to complete answer

#assert or #unassert expects parentheses around the answer.

missing argument to ‘option’ option

The specified command-line option requires an argument.

missing binary operator before token ‘token’

Expecting an operator before the ‘token’.

missing terminating ‘character’ character

Missing terminating character such as a single quote ‘, double quote ” or right angle bracket >.

missing terminating > character

Expecting terminating > in #include directive.

more than n operands in ‘asm’

The asm statement is invalid.

multiple default labels in one switch

Only a single default label may be specified for each switch.

multiple parameters named ‘identifier’

Parameter names must be unique.

multiple storage classes in declaration of ‘identifier’

Each declaration should have a single storage class.

negative width in bit-field ‘identifier’

Bit-field widths may not be negative.

nested function ‘name’ declared ‘extern’

A nested function cannot be declared ‘extern’.

nested redefinition of ‘identifier’

Nested redefinitions are illegal.

no data type for mode ‘mode’

The argument mode specified for the mode attribute is a recognized GCC machine mode, but it is not one that is implemented in the compiler.

no include path in which to find ‘name’

Cannot find include file ‘name’.

no macro name given in #‘directive’ directive

A macro name must follow the #define, #undef, #ifdef or #ifndef directives.

nonconstant array index in initializer

Only constant array indices may be used in initializers.

non-prototype definition here

If a function prototype follows a definition without a prototype and the number of arguments is inconsistent between the two, this message identifies the line number of the non-prototype definition.

number of arguments doesn’t match prototype

The number of function arguments must match the function’s prototype.

operand constraint contains incorrectly positioned ‘+’ or ‘=’

The asm statement is invalid.

operand constraints for ‘asm’ differ in number of alternatives

The asm statement is invalid.

operator “defined” requires an identifier

“defined” is expecting an identifier.

operator ‘symbol’ has no right operand

Preprocessor operator ‘symbol’ requires an operand on the right side.

output number n not directly addressable

The asm statement is invalid.

output operand constraint lacks ‘=’

The asm statement is invalid.

output operand is constant in ‘asm’

The asm statement is invalid.

overflow in enumeration values

Enumeration values must be in the range of ‘int’.

parameter ‘identifier’ declared void

Parameters may not be declared void.

parameter ‘identifier’ has incomplete type

Parameters must have complete types.

parameter ‘identifier’ has just a forward declaration

Parameters must have complete types; forward declarations are insufficient.

parameter ‘identifier’ is initialized

It is not legal to initialize parameters.

parameter name missing

The macro was expecting a parameter name. Check for two commas without a name between.

parameter name missing from parameter list

Parameter names must be included in the parameter list.

parameter name omitted

Parameter names may not be omitted.

param types given both in param list and separately

Parameter types should be given either in the parameter list or separately, but not both.

parse error

The source line cannot be parsed; it contains errors.

pointer value used where a complex value was expected

Do not use pointer values where complex values are expected.

pointer value used where a floating point value was expected

Do not use pointer values where floating-point values are expected.

pointers are not permitted as case values

A case value must be an integer-valued constant or constant expression.

predicate must be an identifier

#assert or #unassert require a single identifier as the predicate.

predicate’s answer is empty

The #assert or #unassert has a predicate and parentheses but no answer inside the parentheses, which is required.

previous declaration of ‘identifier’

This message identifies the location of a previous declaration of identifier that conflicts with the current declaration.

identifier previously declared here

This message identifies the location of a previous declaration of identifier that conflicts with the current declaration.

identifier previously defined here

This message identifies the location of a previous definition of identifier that conflicts with the current definition.

prototype declaration

Identifies the line number where a function prototype is declared. Used in conjunction with other error messages.

redeclaration of ‘identifier’

The identifier is multiply declared.

redeclaration of ‘enum identifier’

Enums may not be redeclared.

‘identifier’ redeclared as different kind of symbol

Multiple, inconsistent declarations exist for identifier.

redefinition of ‘identifier’

The identifier is multiply defined.

redefinition of ‘struct identifier’

Structs may not be redefined.

redefinition of ‘union identifier’

Unions may not be redefined.

register name given for non-register variable ‘name’

Attempt to map a register to a variable which is not marked as register.

register name not specified for ‘name’

File scope variable ‘name’ declared as a register variable without providing a register.

register specified for ‘name’ isn’t suitable for data type

Alignment or other restrictions prevent using requested register.

request for member ‘identifier’ in something not a structure or union

Only structure or unions have members. It is not legal to reference a member of anything else, since nothing else has members.

requested alignment is not a constant

The argument to the aligned attribute must be a compile-time constant.

requested alignment is not a power of 2

The argument to the aligned attribute must be a power of two.

requested alignment is too large

The alignment size requested is larger than the linker allows. The size must be 4096 or less and a power of 2.

return type is an incomplete type

Return types must be complete.

save variable ‘name’ index not constant

The subscript of the array ‘name’ is not a constant integer.

save variable ‘name’ is not word aligned

The object being saved must be word aligned

save variable ‘name’ size is not even

The object being saved must be evenly sized.

save variable ‘name’ size is not known

The object being saved must have a known size.

section attribute cannot be specified for local variables

Local variables are always allocated in registers or on the stack. It is therefore not legal to attempt to place local variables in a named section.

section attribute not allowed for identifier

The section attribute may only be used with a function or variable.

section of identifier conflicts with previous declaration

If multiple declarations of the same identifier specify the section attribute, then the value of the attribute must be consistent.

sfr address ‘address’ is not valid

The address must be less than 0x2000 to be valid.

sfr address is not a constant

The sfr address must be a constant.

‘size of’ applied to a bit-field

‘sizeof’ must not be applied to a bit-field.

size of array ‘identifier’ has non-integer type

Array size specifiers must be of integer type.

size of array ‘identifier’ is negative

Array sizes may not be negative.

size of array ‘identifier’ is too large

The specified array is too large.

size of variable ‘variable’ is too large

The maximum size of the variable can be 32768 bytes.

storage class specified for parameter ‘identifier’

A storage class may not be specified for a parameter.

storage size of ‘identifier’ isn’t constant

Storage size must be compile-time constants.

storage size of ‘identifier’ isn’t known

The size of identifier is incompletely specified.

stray ‘character’ in program

Do not place stray ‘character’ characters in the source program.

strftime formats cannot format arguments

While using the attribute format when the archetype parameter is strftime, the third parameter to the attribute, which specifies the first parameter to match against the format string, should be 0. strftime style functions do not have input values to match against a format string.

structure has no member named ‘identifier’

A structure member named ‘identifier’ is referenced; but the referenced structure contains no such member. This is not allowed.

subscripted value is neither array nor pointer

Only arrays or pointers may be subscripted.

switch quantity not an integer

Switch quantities must be integers.

symbol ‘symbol’ not defined

The symbol ‘symbol’ needs to be declared before it may be used in the pragma.

syntax error

A syntax error exists on the specified line.

syntax error ‘:’ without preceding ‘?’

A ‘:’ must be preceded by ‘?’ in the ‘?:’ operator.

the only valid combination is ‘long double’

The long qualifier is the only qualifier that may be used with the double type.

this built-in requires a frame pointer

__builtin_return_address requires a frame pointer. Do not use the -fomit-frame-pointer option.

this is a previous declaration

If a label is duplicated, this message identifies the line number of a preceding declaration.

too few arguments to function

When calling a function in C, do not specify fewer arguments than the function requires. Nor should you specify too many.

too few arguments to function ‘identifier’

When calling a function in C, do not specify fewer arguments than the function requires. Nor should you specify too many.

too many alternatives in ‘asm’

The asm statement is invalid.

too many arguments to function

When calling a function in C, do not specify more arguments than the function requires. Nor should you specify too few.

too many arguments to function ‘identifier’

When calling a function in C, do not specify more arguments than the function requires. Nor should you specify too few.

too many decimal points in number

Expecting only one decimal point.

top-level declaration of ‘identifier’ specifies ‘auto’

Auto variables can only be declared inside functions.

two or more data types in declaration of ‘identifier’

Each identifier may have only a single data type.

two types specified in one empty declaration

No more that one type should be specified.

type of formal parameter n is incomplete

Specify a complete type for the indicated parameter.

type mismatch in conditional expression

Types in conditional expressions must not be mismatched.

typedef ‘identifier’ is initialized

It is not legal to initialize typedef’s. Use __typeof__ instead.

‘identifier’ undeclared (first use in this function)

The specified identifier must be declared.

‘identifier’ undeclared here (not in a function)

The specified identifier must be declared.

union has no member named ‘identifier’

A union member named ‘identifier’ is referenced, but the referenced union contains no such member. This is not allowed.

unknown field ‘identifier’ specified in initializer

Do not use unknown fields in initializers.

unknown machine mode ‘mode’

The argument mode specified for the mode attribute is not a recognized machine mode.

unknown register name ‘name’ in ‘asm’

The asm statement is invalid.

unrecognized format specifier

The argument to the format attribute is invalid.

unrecognized option ‘-option’

The specified command-line option is not recognized.

unrecognized option ‘option’

‘option’ is not a known option.

‘identifier’ used prior to declaration

The identifier is used prior to its declaration.

unterminated #‘name’

#endif is expected to terminate a #if, #ifdef or #ifndef conditional.

unterminated argument list invoking macro ‘name’

Evaluation of a function macro has encountered the end of file before completing the macro expansion.

unterminated comment

The end of file was reached while scanning for a comment terminator.

‘va_start’ used in function with fixed args

‘va_start’ should be used only in functions with variable argument lists.

variable ‘identifier’ has initializer but incomplete type

It is not legal to initialize variables with incomplete types.

variable or field ‘identifier’ declared void

Neither variables nor fields may be declared void.

variable-sized object may not be initialized

It is not legal to initialize a variable-sized object.

virtual memory exhausted

Not enough memory left to write error message.

void expression between ‘(‘ and ’)’

Expecting a constant expression but found a void expression between the parentheses.

‘void’ in parameter list must be the entire list

If ‘void’ appears as a parameter in a parameter list, then there must be no other parameters.

void value not ignored as it ought to be

The value of a void function should not be used in an expression.

warning: -pipe ignored because -save-temps specified

The -pipe option cannot be used with the -save-temps option.

warning: -pipe ignored because -time specified

The -pipe option cannot be used with the -time option.

warning: ‘-x spec’ after last input file has no effect

The ‘-x’ command line option affects only those files named after its on the command line; if there are no such files, then this option has no effect.

weak declaration of ‘name’ must be public

Weak symbols must be externally visible.

weak declaration of ‘name’ must precede definition

‘name’ was defined and then declared weak.

wrong number of arguments specified for attribute attribute

There are too few or too many arguments given for the attribute named ‘attribute’.

wrong type argument to bit-complement

Do not use the wrong type of argument to this operator.

wrong type argument to decrement

Do not use the wrong type of argument to this operator.

wrong type argument to increment

Do not use the wrong type of argument to this operator.