### Compiler Error Messages EDC0400 - EDC0499

EDC0400
  #pragma &1 must appear only once in any C file.

  Recovery: Remove all but one of the specified #pragma directives.

EDC0401
  Function &1 must be defined for #pragma entry.

  The function must be defined for it to be specified using #pragma entry.

  Recovery: Define the function.

EDC0402
  &1 must be an externally-defined function for use with #pragma entry.

  The identifier must be defined as a function with external linkage for it to be specified using #pragma entry.

  Recovery: Define the function.

EDC0403
  Cannot use the _Seg16 qualifier with pointers to _Far32 _Pascal functions.

  The pointer types are not compatible.

  Recovery: Remove the _Seg16 type qualifier.

EDC0404
  &1 can only qualify a pointer type.

  An attempt was made to qualify an identifier with &1 but the identifier is not a pointer.

  Recovery: Remove the &1 type qualifier from the declaration or definition, or ensure it qualifies a pointer.

EDC0405
  A 16-bit function cannot have a structure or union as a parameter.

  Passing a structure or union by value to a 16-bit function is not supported.

  Recovery: Change the parameter to a pointer to a structure or union.

EDC0406
  A 16-bit function cannot have a structure or union as a return type.

  Passing a structure or union by value from a 16-bit function is not supported.

  Recovery: Change the return type to a pointer to a structure or union.

EDC0407
  _Seg16 pointers are not supported on the target platform.

  The _Seg16 qualifier is not allowed on the target platform.

  Recovery: Remove the _Seg16 type qualifier.

EDC0408
  The linkage protocol is not supported on the target platform.

  An attempt to use an unsupported linkage protocol was made.

  Recovery: Remove the linkage protocol keywords.

EDC0409
  The static variable '&1' is defined but never referenced.

  A variable that is defined but never used probably serves no purpose.

  Recovery: Remove the variable definition if you are not going to use the variable.

EDC0410
  The automatic variable '&1' is defined but never referenced.

  A variable that is defined but never used likely serves no purpose.

  Recovery: Remove the variable definition.

EDC0411
  An array that is not an lvalue cannot be subscripted.

  A non-lvalue array is created when a function returns a structure that contains an array. This array cannot be dereferenced.

  Recovery: Remove the subscript.

EDC0412
  The variable '&1' is referenced before being initialized.

  Because the variable has not been initialized, its value is undefined. The results of using an undefined variable are unpredictable.

  Recovery: Initialize the variable before its first reference.

EDC0413
  A goto statement is used.

  The use of goto statements may result in code that is more difficult to trace.

  Recovery: Replace the goto statement with equivalent structured-programming constructs.

EDC0414
  The parameter '&1' is never referenced.

  The parameter is passed to the function, but is not referenced anywhere within the function body.

  Recovery: Remove the parameter from the function prototype.

EDC0415
  The external function definition '&1' is never referenced.

  A function that is defined but never used likely serves no purpose.

  Recovery: Remove the function definition, unless needed in another compilation unit.

EDC0416
  Taking the negative of the most negative value, '&1', of a signed type will cause truncation.

  The negative of the most negative value cannot be represented as a positive value of the same type.

  Recovery: Change the value or use a larger data type.

EDC0418
  '&1' does not evaluate to a constant that fits in its signed type.

  The expression evaluates to a number that is not within the range that can be stored by the target.

  Recovery: Change the expression so it evaluates to a value in the valid range.

EDC0419
  Converting &1 to type "&2" does not preserve its value.

  The user cast converts &1 to a type that cannot contain the value of the original type.

  Recovery: Change the cast.

EDC0420
  An unsigned comparison is performed between an unsigned value and a negative constant.

  Comparing an unsigned value with a signed value may produce unexpected results.

  Recovery: Type-cast the unsigned value to a signed type if a signed comparison is desired, or type-cast the negative constant to an unsigned type if an unsigned comparison is desired.

EDC0421
  The comparison is always true.

  The type specifiers of the values being compared result in a constant result.

  Recovery: Simplify or remove the conditional expression.

EDC0422
  The comparison is always false.

  The type specifiers of the values being compared result in a constant result.

  Recovery: Simplify or remove the conditional expression.

EDC0423
  The comparison may be rewritten as '&1'.

  The type specifiers of the values being compared may allow the expression to be simplified.

  Recovery: Simplify the comparison expression.

EDC0424
  The condition is always true.

  Because the value of the conditional expression is constant, it may be possible to simplify or remove the conditional test.

  Recovery: Change the conditional expression or remove the conditional test.

EDC0425
  The condition is always false.

  Because the value of the conditional expression is constant, it may be possible to simplify or remove the conditional test.

  Recovery: Change the conditional expression or remove the conditional test.

EDC0426
  An assignment expression is used as a condition. An equality comparison (==) may have been intended.

  A single equal sign '=' is often mistakenly used as an equality comparison operator.

  Recovery: Ensure an assignment operation was intended.

EDC0427
  A constant expression is used as a switch condition.

  The same code path will be taken through every execution of the switch statement.

  Recovery: Change the switch expression to be a non-constant value or remove the unused portions of the switch structure.

EDC0428
  The left-hand side of a shift expression is an unparenthesized arithmetic expression which has a higher precedence.

  The left-hand expression is evaluated before the shift operator.

  Recovery: Place parentheses around the left-hand expression to make the order of operations explicit.

EDC0429
  The right-hand side of a shift expression is an unparenthesized arithmetic expression which has a higher precedence.

  The right-hand expression is evaluated before the shift operator.

  Recovery: Place parentheses around the right-hand expression to make the order of operations explicit.

EDC0430
  The result of a comparison is either 0 or 1, and may not be appropriate as operand for another comparison operation.

  The comparison expression may be malformed.

  Recovery: Ensure that the resulting value from the comparison is appropriate for use in the following comparison.

EDC0431
  The left-hand side of a bitwise &, », or º expression is an unparenthesized relational, shift, or arithmetic expression which has a higher precedence.

  The left-hand expression is evaluated before the bitwise operator.

  Recovery: Place parentheses around the left-hand expression to make the order of operations explicit.

EDC0432
  The right-hand side of a bitwise &, », or º expression is an unparenthesized relational, shift, or arithmetic expression which has a higher precedence.

  The right-hand expression is evaluated before the bitwise operator.

  Recovery: Place parentheses around the right-hand expression to make the order of operations explicit.

EDC0433
  The right-hand side of a bitwise shift expression should be positive and less than the width in bits of the promoted left operand.

  This expression may not be portable.

  Recovery: Change the shift expression.

EDC0434
  The left-hand side of a bitwise right shift expression has a signed promoted type.

  This expression may not be portable.

  Recovery: Change the shift expression.

EDC0435
  An expression statement should have some side effects because its value is discarded.

  If an expression statement has no side effects, then it may be possible to remove the statement with no change in program behaviour.

  Recovery: Change or remove the expression statement.

EDC0436
  Left-hand side of comma expression should have side effects because its value is discarded.

  A comma expression evaluates to its right-hand operand.

  Recovery: Change the expression.

EDC0437
  The init or re-init expression of a for statement should have some side effects since its value is discarded.

  If the init and/or the re-init expression of a for statement have no side effects, the loop may not execute as desired.

  Recovery: Change the init and/or re-init expressions.

EDC0438
  The value of the variable '&1' may be used before being set.

  Because the variable has not been initialized, its value is undefined. The results of using an undefined variable are unpredictable.

  Recovery: Add an initialization statement or change the expression.

EDC0439
  Assigning enum type '&1' to enum type '&2' may not be correct.

  The values of the enumerated types may be incompatible.

  Recovery: Change the types of the values being assigned.

EDC0440
  Cannot assign an invalid enumerator value to enum type '&1'.

  The value being assigned is not a member of the enumeration.

  Recovery: Change the value being assigned, or make it an enumeration member.

EDC0441
  The macro definition will override the keyword '&1'.

  Overriding a C keyword with a preprocessor macro may cause unexpected results.

  Recovery: Change the name of the macro or remove it.

EDC0442
  A trigraph sequence occurs in a character literal.

  The trigraph sequence will be converted. A literal interpretation may have been desired.

  Recovery: Change the value of the character literal.

EDC0443
  A trigraph sequence occurs in a string literal.

  The trigraph sequence will be converted. A literal interpretation may have been desired.

  Recovery: Change the value of the string literal.

EDC0444
  The opening brace is redundant.

  The initialization expression contains extra, possibly unnecessary, braces.

  Recovery: Remove the extra braces.

EDC0445
  The closing brace is redundant.

  The initialization expression contains extra, possibly unnecessary, braces.

  Recovery: Remove the extra braces.

EDC0446
  Array element(s) ÿ&1ÿ will be initialized with a default value of 0.

> Some array elements were not explicitly initialized. They will be assigned the default value.

> Recovery: Add initializations if necessary.

EDC0447
  The member(s) starting from '&1' will be initialized with a default value of 0.

  Some members were not explicitly initialized. They will be assigned the default value.

  Recovery: Add initializations if necessary.

EDC0448
  Assigning a packed struct to an unpacked struct, or vice versa, requires remapping.

  Assignments between packed/unpacked structures may produce incorrect results.

  Recovery: Change the type qualifiers of the values in the assignment.

EDC0449
  Missing return expression.

  If a function has a non-void return type, then all return statements must have a return expression of the correct type.

  Recovery: Add a return expression.

EDC0450
  Obsolete non-prototype-style function declaration.

  The K&R-style function declaration is obsolete.

  Recovery: Change the function declaration to the prototyped style.

EDC0451
  The target integral type cannot hold all possible values of the source integral type.

  Data loss or truncation may occur because of the type conversions.

  Recovery: Change the types of the values in the expression.

EDC0452
  Assigning a floating point type to an integral type may result in truncation.

  Data loss or truncation may occur because of the type conversions.

  Recovery: Change the types of the values in the expression.

EDC0453
  Assigning a floating point type to another floating point type with less precision.

  Data loss or truncation may occur because of the type conversions.

  Recovery: Change the types of the values in the expression.

EDC0454
  &1 condition evaluates to &2.

  This message traces preprocessor expression evaluation.

  Recovery: No response required.

EDC0455
  defined(&1) evaluates to &2.

  This message traces preprocessor #ifdef and #ifndef evaluation.

  Recovery: No response required.

EDC0456
  Stop skipping tokens.

  This messages traces conditional compilation activity.

  Recovery: No response required.

EDC0457
  File &1 has already been included.

  This #include directive is redundant.

  Recovery: Remove the #include directive.

EDC0458
  #line directive changing line to &1 and file to &2.

  This message traces #line directive evaluation.

  Recovery: No response required.

EDC0459
  #line directive changing line to &1.

  This message traces #line directive evaluation.

  Recovery: No response required.

EDC0460
  &1 nesting level is &2.

  This message traces conditional compilation activity.

  Recovery: No response required.

EDC0461
  Generating precompiled header file &1.

  This message traces precompiled header generation activity.

  Recovery: No response required.

EDC0462
  Precompiled header file &1 is found but not used because it is not up to date.

  This message traces precompiled header file generation activity.

  Recovery: No response required.

EDC0463
  Using precompiled header file &1.

  This message traces precompiled header file generation activity.

  Recovery: No response required.

EDC0464
  Begin skipping tokens.

  This messages traces conditional compilation activity.

  Recovery: No response required.

EDC0465
  #undef undefining macro name &1.

  This message traces #undef preprocessor directive evaluation.

  Recovery: No response required.

EDC0466
  Unary minus applied to an unsigned type.

  The negation operator is inappropriate for unsigned types.

  Recovery: Remove the operator or change the type of the operand.

EDC0467
  String literals concatenated.

  Two string literals, each delimited by quotation marks, have been combined into a single literal.

  Recovery: No response is necessary. This is an informational message.

EDC0468
  Macro name &1 on #define is also an identifier.

  The name of the macro has already been used.

  Recovery: Change the name of the macro.

EDC0469
  The static function '&1' is declared or defined but never referenced.

  A function that is defined but never used serves no purpose.

  Recovery: Remove the function definition.

EDC0470
  Function 'main' should return int, not void.

  According to the ANSI/ISO standard, main should return int not void. Earlier standards (such as K&R) allowed a void return type for main.

  Recovery: Change the return type of the function.

EDC0471
  Case label is not a member of enum type '&1'

  Case labels must be members of the type of the switch expression.

  Recovery: Change the value of the case label.

EDC0472
  Statement is unreachable.

  The flow of execution is such that this statement will never be reached.

  Recovery: Change the control flow in the program, or remove the unreachable statement.

EDC0473
  An unintended semi-colon may have created an empty loop body.

  The loop body has no statements, and the conditional expression has no side effects.

  Recovery: If this is what was intended, use '{}' instead of a semi-colon as empty loop body to avoid this message.

EDC0474
  Loop may be infinite.

  The value of the conditional expression and/or the lack of exit points may result in an infinite loop.

  Recovery: Adjust the conditional expression or add loop exit statements.

EDC0475
  The real constant arithmetic expression folds to positive infinity.

  Constant folding results in an overflow.

  Recovery: Change the expression.

EDC0476
  The real constant arithmetic expression folds to negative infinity.

  Constant folding results in an overflow.

  Recovery: Change the expression.

EDC0477
  The real constant arithmetic expression folds to a NaN.

  Constant folding results in Not-a-Number (NaN).

  Recovery: Change the expression.

EDC0478
  The then branch of conditional is an empty statement.

  If the condition is true, then no statement is executed.

  Recovery: Add a statement to be executed, or remove the conditional statement.

EDC0479
  Both branches of conditional statement are empty statements.

  A conditional statement with empty branches is possibly degenerate.

  Recovery: Add code to the conditional branches.

EDC0480
  Missing break statement allows fall-through to this case.

  The preceding case did not end with a break, return, or goto statement, allowing the path of execution to fall-through to the code in this case.

  Recovery: Add an appropriate terminating statement to the previous case, unless the fall-through was intentional.

EDC0481
  The end of the function may be reached without returning a value.

  A return statement should be used to exit any function whose return type is non-void.

  Recovery: Add a return statement, or change the function to return void.

EDC0482
  The opening brace before this point is redundant.

  The initialization expression contains extra, possibly unnecessary, braces.

  Recovery: Remove the extra braces.

EDC0483
  Switch statement contains no cases or only default case.

  Code within a switch statement block that is not preceded by either 'default' or 'case' is never executed, and may be removed. Switch statements with neither 'default' or 'case' are probably incorrect.

  Recovery: Change the switch statement to include cases.

EDC0484
  External name &1 has been truncated to &2.

  The external name exceeds the maximum length and has been truncated. This may result in unexpected behavior if two different names become the same after truncation.

  Recovery: Reduce the length of the external name.

EDC0485
  Parameter declaration list is incompatible with declarator for &1.

  An attempt has been made to attach a parameter declaration list with a declarator which cannot have one.

  Recovery: Change declarator or remove parameter declaration list.

EDC0486
  A pointer to an incomplete type cannot be indexed.

  An index has been used with a pointer to an incomplete type.

  Recovery: Declare the type that is pointed at or remove the index.

EDC0487
  An argument cannot be an incomplete struct or union.

  An incomplete aggregate cannot be used as an argument to a function.

  Recovery: Declare the type that is pointed at or use a pointer to the aggregate.

EDC0488
  A call to __parmdwords can only be made inside a function with _System calling convention.

  A call to __parmdwords has been made inside of a function that does not have _System calling convention.

  Recovery: Change the function so that it has _System calling convention or remove the call to __parmdwords.

EDC0489
  The incomplete struct or union tag &1 was not completed before going out of scope.

  A struct or union tag was declared inside a parameter list or a function body, but no member declaration list was provided.

  Recovery: If the struct or union tag was declared inside a parameter list, provide a member declaration list at file scope. If the tag was declared inside a function body, provide a member declaration list within that function body.

EDC0490
  The static variable '&1' is set but never referenced.

  A variable that is initialized but never used serves no purpose.

  Recovery: Remove the variable definition if you do not intend to use it.

EDC0491
  The automatic variable '&1' is set but never referenced.

  A variable that is initialized but never used likely serves no purpose.

  Recovery: Remove the variable definition if you do not intend to use it.

EDC0492
  Redefinition of &1 hides previous definition.

  The definition within the current scope hides a definition with the same name in an enclosing scope.

  Recovery: Change the name to avoid redefining it.

EDC0493
  The external variable '&1' is defined but never referenced.

  A variable that is defined but never used likely serves no purpose.

  Recovery: Remove the variable definition, unless needed in another compilation unit.

EDC0494
  The external variable '&1' is set but never referenced.

  A variable that is initialized but never used serves no purpose.

  Recovery: Remove the variable definition, unless needed in another compilation unit.

EDC0495
  Pointer type conversion found.

  An attempt is being made to convert a pointer of one type to a pointer of another type.

  Recovery: Check the types of the values involved in the expression, and make them compatible.

EDC0496
  Parameter(s) for #pragma &1 are of the wrong type.

  The parameter for the pragma is incorrect and of the wrong type.

  Recovery: Look up correct type in the C Language Reference.

EDC0497
  Incomplete enum type not allowed.

  An incomplete enum is being used where a complete enum type is required.

  Recovery: Complete the type declaration.

EDC0498
  Member of struct or union cannot be incomplete type.

  An incomplete aggregate is being used where a complete struct or union is required.

  Recovery: Complete the type declaration.

EDC0499
  Function 'main' should return int.

  A return type other than int was specified for function main.

  Recovery: Change the return type to int.

Summary of Compiler Error Messages