Array sizes must be strictly positive -- the value number is either zero or negative.
The size of a bit field be within the range 0 to 8*sizeof(int). In many cases this means that long data items cannot be used in bit field specifications.
The type of a bit field must be either an unsigned integer or a signed integer, and type is neither of these. Note that enumeration types cannot be used in bit fields.
You cannot declare function types in structures or unions, only pointers to functions.
An opening parenthesis was expected after the built-in function __typechk.
An addressable object is required when applying the address-of operator '&'. In particular, you can't take the address of a simple constant.
You cannot assign to const-qualified identifiers.
You cannot assign through a pointer to a const-qualified object nor can you assign to members of const-qualified structures or unions.
The character char which is part of a hexadecimal escape sequence isn't a valid hexadecimal digit.
You have placed a break statement in the main body of a function without an enclosing for, do-while, while-do, or switch statement. This usually happens when you edit the code and remove a trailing close brace by mistake.
You cannot initialize an undefined structure or union type. Undefined structure or union types are usually used to construct recursive data structures or to hide implementation details. They are introduced using the syntax struct tag; or union tag; which makes the type's structure tag known to the compiler, but not the structure or union's size. Usually, this error indicates that an appropriate header file has not been included.
The value in a case label must be known to the compiler at compilation time and cannot depend upon runtime values. If you need to make multi-way decisions using runtime values then use a set of if-else statements.
You have placed a case label outside a switch statement in the body of a function. This usually happens when you edit the code and remove a trailing close brace by mistake.
Casting between type1 and type2 makes no sense and is illegal according to the ANSI specification. Casting, for instance, between an integer and a structure is disallowed, as is casting between structures.
Casting the pointer type type1 to type type2 is not allowed in a constant expression as the pointer value cannot be known at compile-time.
You have declared the function name with an inconsistent prototype, such as changing the type of a parameter or not matching the number of parameters.
You have placed a continue statement in the main body of a function without an enclosing for, do-while, or while-do statement. This usually happens when you edit the code and remove a trailing close brace by mistake.
In an old-style function definition, the parameter name is declared but is missing from the function.
You have placed a default case label outside a switch statement in the body of a function. This usually happens when you edit the code and remove a trailing close brace by mistake.
You have given two or more case labels the same value -- all case labels must have distinct values.
You have used the name name to declare two objects in the same scope with identical names.
The field name name has already been used in the structure or union type type.
You have started a declaration but haven't defined an object with it. This usually occurs when declaring structure or union types as the syntax is commonly misunderstood.
You must use only identifiers in enumeration types, and the enumeration type must have at least one element.
You have not constructed an old-style parameter list correctly.
You have supplied more than one default case label in a switch statement. A switch statement can have either no default case label or a single default case label.
You have given more than one identifier in a declaration. This usually happens when you forget a comma.
You have given an old-style parameter list when declaring a pointer to a function.
You have provided an expression to return from a void function -- void functions cannot return values.
You have not used an identifier to select a field name after '.' or '->'.
You have not provided a field name in a structure or union declaration.
You have tried to call something which is not a function.
The size of the stack frame has exceeded size bytes which means that the application will not work at runtime.
The character char isn't valid in a C program. For example, '$' isn't used in C.
The compiler has found a non-printable character which isn't valid in a C program.
You have not constructed an expression correctly. This can happen for many reasons and it is impractical to list them all here.
You cannot specify a formal parameter as void, only as a pointer to void.
You cannot initialize the function name -- functions can't be initialized.
You cannot initialise parameter name in a formal parameter list.
You cannot initialise the value of external variables.
The type type1 of the expression returned is not compatible with the declared return type of the function which is type2.
You have declared a function with return type type which is a function or an array -- a function cannot return an array nor a function.
You have not correctly terminated a statement.
You can use const and volatile only on types which are not already declared const or volatile.
You can only use simple types in switch expressions -- expressions which are compatible with int.
You cannot declare arrays of functions, only arrays of function pointers,
The return type type of a function must be known before it can be called or declared as a function -- that is, you cannot use incomplete types in function declarations.
The name name is a typedef and cannot be used in an expression.
The value you have used to initialize a variable is not constant and is only known at run time -- a constant which is computable at compile time is required.
You have not provided enough arguments to the function name.
The value you have used in a bit field width, in specifying the size of an array, or defining the value of an enumeration is not constant -- a constant which is computable at compile time is required.
Structure and union field declarations must start with a type name.
The string string is a invalid floating-point constant.
The string string is a invalid hexadecimal constant.
The type type1 which you have used to initialize a variable is not compatible with the type type2 of the variable.
The string string is a invalid octal constant.
You cannot take the address of register variables and name is declared as a register variable.
You have mis-declared the storage class for the variable name of type type. For example, you cannot declare global objects auto, nor can you declare parameters static or external.
You cannot apply sizeof to an undefined type or to a function.
The combination of type qualifiers and size specifiers isn't valid.
You can't use register or auto at global level.
You can only use typedef to define plain types without a storage class.
The operand to the left of the '.' isn't of structure type.
The operand to the left of the '->' isn't a pointer to a structure type.
A lvalue is required. An lvalue is an object which can be assigned to.
A string constant hasn't been closed correctly.
A structure tag is sometimes required if an undefined structure is used on its own without a typedef.
Types with nested structures or unions must be initialised correctly with structures delimited with '{' and '}'.
When declaring an array without an initialiser, you must give explicit array sizes.
Your declaration is missing an identifier which defines what is being declared.
An identifier is required immediately after goto.
Only function ptototypes can have anonymous parameters; for ANSI-style function declarations all parameters must be given names.
An ANSI-style function declaration requires that all parameters are typed in the function prototype.
The operand's type isn't compatible with the unary operator operator.
The types of the left and right operands to the binary operator operator are not allowed.
When declaring name as an enumation constant, the integer value of that constant exceeds the maximum integer value.
The identifier name has already been used in this scope for another purpose and cannot be used again.
You have redefined the initialisation of the identifier name -- only one definition of the identifier's value is allowed.
You have redefined the label name with the same name in the function. Labels are global to the function, not local to a block.
The size of the type type is greater than size bytes. The compiler cannot construct data items larger than size bytes for this processor.
The size of the array of type is greater than size bytes. The compiler cannot construct data items larger than size bytes for this processor.
You cannot use sizeof with a bit field as sizeof returns the number of bytes used for an object, whereas a bit field is measured in bits.
You have provided too many arguments to the function name.
The compiler has stopped compilation because too many errors have been found in your program. Correct the errors and then recompile.
You have provided more initializers for an array or a structure than the compiler expected. Check the bracketing for nested structures.
The nth actual argument to the function name is of type type and is not compatible with the nth formal argument given in the prototype for name. You should check that the formal and actual parameters on a function call match.
The nth actual argument to the function name is of type type1 and is not compatible with the nth formal argument given of type type2 in the prototype for name. You should check that the formal and actual parameters on a function call match.
You have used the identifier name but it has not been previously declared.
You have used the label name in a goto statement but no label in the current function has been defined with that name.
You have declared the variable name using the type type, but the size of type is not yet known. This occurs when you define a union or structure with a tag but do not define the contents of the structure and then use the tag to define a variable.
You have declared the field name using the type type, but the size of type is not yet known. This occurs when you define a union or structure with a tag but do not define the contents of the structure and then use the tag to define a field.
You have declared the parameter name using the type type, but the size of type is not yet known. This occurs when you define a union or structure with a tag but do not define the contents of the structure and then use the tag to define a parameter.
You have declared the static function name which returns type type in a prototype, but have not defined the body of the function.
You have not defined the enumeration tag name but have used it to defined an object.
You have tried to access the field name of the structure or union type type, but a field of that name is not declared within that structure.
You have tried to use an operator where the size of the type type must be known to the compiler.
The compiler can't recognise the declaration syntax you have used. This is usually caused by misplacing a comma in a declarator.
The compiler can't recognise the start of a statement. A statement must start with one of the statement keywords or must be an expression. This is usually caused by misplacing a semicolon.
The operand to the __typechk intrinsic function is incorrect. This occurs when you provide a parameter to a the macro function which checks its expected parameters using __typechk. You should check the types of parameters you pass to the macro routine