## 'number' is an illegal array size

Array sizes must be strictly positive -- the value number is either zero or negative.

## 'number' is an illegal bit-field size

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.

## 'type' is an illegal bit-field type

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.

## 'type' is an illegal field type

You cannot declare function types in structures or unions, only pointers to functions.

## '(' expected

An opening parenthesis was expected after the built-in function `__typechk`.

## addressable object required

An addressable object is required when applying the address-of operator '`&`'. In particular, you can't take the address of a simple constant.

## assignment to const identifier 'name'

You cannot assign to const-qualified identifiers.

## assignment to const location

You cannot assign through a pointer to a `const`-qualified object nor can you assign to members of `const`-qualified structures or unions.

## bad hexadecimal escape sequence '\xchar'

The character char which is part of a hexadecimal escape sequence isn't a valid hexadecimal digit.

## 'break' not inside loop or switch statement

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.

## cannot initialize undefined 'type'

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.

## case label must be a constant integer expression

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.

## 'case' not inside 'switch'

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.

## cast from 'type 1' to 'type 2' is illegal

Casting between type 1 and type 2 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.

## cast from 'type 1' to 'type 2' is illegal in constant expression

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.

## conflicting argument declarations for function 'name'

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.

## 'continue' not inside loop statement

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.

## declared parameter 'name' is missing

In an old-style function definition, the parameter name is declared but is missing from the function.

## 'default' not inside 'switch'

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.

## duplicate case label 'number'

You have given two or more case labels the same value -- all case labels must have distinct values.

## duplicate declaration for 'name' previously declared at pos

You have used the name name to declare two objects in the same scope with identical names.

## duplicate field name 'name' in 'type'

The field name name has already been used in the structure or union type type.

## empty declaration

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.

## expecting an enumerator identifier

You must use only identifiers in enumeration types, and the enumeration type must have at least one element.

## expecting an identifier

You have not constructed an old-style parameter list correctly.

## extra 'default' cases in 'switch'

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.

## extraneous identifier 'name'

You have given more than one identifier in a declaration. This usually happens when you forget a comma.

## extraneous old-style parameter list

You have given an old-style parameter list when declaring a pointer to a function.

## extraneous return value

You have provided an expression to return from a void function -- void functions cannot return values.

## field name expected

You have not used an identifier to select a field name after '.' or '->'.

## field name missing

You have not provided a field name in a structure or union declaration.

## found 'type', expected a function

You have tried to call something which is not a function.

## frame exceeds size bytes

The size of the stack frame has exceeded size bytes which means that the application will not work at runtime.

## illegal character 'char'

The character char isn't valid in a C program. For example, '$' isn't used in C.

## illegal character '\0ooo'

The compiler has found a non-printable character which isn't valid in a C program.

## illegal expression

You have not constructed an expression correctly. This can happen for many reasons and it is impractical to list them all here.

## illegal formal parameter types

You cannot specify a formal parameter as void, only as a pointer to void.

## illegal initialization for 'name'

You cannot initialize the function name -- functions can't be initialized.

## illegal initialization for parameter 'name'

You cannot initialise parameter name in a formal parameter list.

## illegal initialization of 'extern name'

You cannot initialise the value of external variables.

## illegal return type; found 'type1' expected 'type2'

The type type1 of the expression returned is not compatible with the declared return type of the function which is type2.

## illegal return type 'type'

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.

## illegal statement termination

You have not correctly terminated a statement.

## illegal type 'type'

You can use const and volatile only on types which are not already declared const or volatile.

## illegal type 'type' in switch expression

You can only use simple types in switch expressions -- expressions which are compatible with int.

## illegal type 'type[]'

You cannot declare arrays of functions, only arrays of function pointers,

## illegal use of incomplete type 'type'

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.

## illegal use of type name 'name'

The name name is a typedef and cannot be used in an expression.

## initializer must be constant

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.

## insufficient number of arguments to 'name'

You have not provided enough arguments to the function name.

## integer expression must be constant

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.

## invalid type field declarations

Structure and union field declarations must start with a type name.

## invalid floating constant 'string'

The string string is a invalid floating-point constant.

## invalid hexadecimal constant 'string'

The string string is a invalid hexadecimal constant.

## invalid initialization type; found 'type1' expected 'type2'

The type type1 which you have used to initialize a variable is not compatible with the type type2 of the variable.

## invalid octal constant 'string'

The string string is a invalid octal constant.

## invalid operand of unary &; 'name' is declared register

You cannot take the address of register variables and name is declared as a register variable.

## invalid storage class 'class' for 'type name'

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.

## invalid type argument 'type' to 'sizeof'

You cannot apply sizeof to an undefined type or to a function.

## invalid type specification

The combination of type qualifiers and size specifiers isn't valid.

## invalid use of 'keyword'

You can't use register or auto at global level.

## invalid use of 'typedef'

You can only use typedef to define plain types without a storage class.

## left operand of . has incompatible type 'type'

The operand to the left of the '.' isn't of structure type.

## left operand of -> has incompatible type 'type'

The operand to the left of the '->' isn't a pointer to a structure type.

## lvalue required

A lvalue is required. An lvalue is an object which can be assigned to.

## missing '
missing "

A string constant hasn't been closed correctly.

## missing type tag

A structure tag is sometimes required if an undefined structure is used on its own without a typedef.

## missing { in initialization of 'type'

Types with nested structures or unions must be initialised correctly with structures delimited with '{' and '}'.

## missing array size

When declaring an array without an initialiser, you must give explicit array sizes.

## missing identifier

Your declaration is missing an identifier which defines what is being declared.

## missing label in goto

An identifier is required immediately after goto.

## missing name for parameter number to function 'name'

Only function ptototypes can have anonymous parameters; for ANSI-style function declarations all parameters must be given names.

## missing parameter type

An ANSI-style function declaration requires that all parameters are typed in the function prototype.

## operand of unary operator has illegal type 'type'

The operand's type isn't compatible with the unary operator operator.

## operands of operator have illegal types 'type1' and 'type2'

The types of the left and right operands to the binary operator operator are not allowed.

## overflow in value for enumeration constant 'name'

When declaring name as an enumation constant, the integer value of that constant exceeds the maximum integer value.

## redeclaration of 'name'
redeclaration of 'name' previously declared at position

The identifier name has already been used in this scope for another purpose and cannot be used again.

## redefinition of 'name' previously defined at position

You have redefined the initialisation of the identifier name -- only one definition of the identifier's value is allowed.

## redefinition of label 'name' previously defined at position

You have redefined the label name with the same name in the function. Labels are global to the function, not local to a block.

## size of 'type' exceeds size bytes

The size of the type type is greater than size bytes. The compiler cannot construct data items larger than size bytes for this processor.

## size of 'type[]' exceeds size bytes

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.

## 'sizeof' applied to a bit field

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.

## too many arguments to 'name'

You have provided too many arguments to the function name.

## too many errors

The compiler has stopped compilation because too many errors have been found in your program. Correct the errors and then recompile.

## too many initializers

You have provided more initializers for an array or a structure than the compiler expected. Check the bracketing for nested structures.

## type error in argument n to name; 'type' is illegal

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.

## type error in argument n to name; found 'type1' expected 'type2'

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.

## undeclared identifier 'name'

You have used the identifier name but it has not been previously declared.

## undefined label 'name'

You have used the label name in a goto statement but no label in the current function has been defined with that name.

## undefined size for 'type 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.

## undefined size for field 'type name'

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.

## undefined size for parameter 'type name'

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.

## undefined static 'type name'

You have declared the static function name which returns type type in a prototype, but have not defined the body of the function.

## unknown enumeration 'name'

You have not defined the enumeration tag name but have used it to defined an object.

## unknown field 'name' of 'type'

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.

## unknown size for type 'type'

You have tried to use an operator where the size of the type type must be known to the compiler.

## unrecognized declaration

The compiler can't recognise the declaration syntax you have used. This is usually caused by misplacing a comma in a declarator.

## unrecognized statement

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.

## user type check error: found 'type 2' expected 'type 2'

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