### Compiler Error Messages EDC0200 - EDC0299

EDC0200
  #elif can only appear within a #if, #elif, #ifdef, or #ifndef block.

  #elif is only valid within a conditional preprocessor block.

  Recovery: Remove the #elif statement, or place it within a conditional preprocessor block.

EDC0201
  #else can only appear within a #if, #elif, #ifdef or #ifndef block.

  #else is only valid within a conditional preprocessor block.

  Recovery: Remove the #else statement, or place it within a conditional preprocessor block.

EDC0202
  #endif can only appear at the end of a #if, #elif, #ifdef or #ifndef block.

  Every #endif must have a corresponding #if, #ifdef, or #ifndef.

  Recovery: Remove the #endif statement, or place it after a conditional preprocessor block.

EDC0204
  Unexpected end of file.

  The end of the source file has been encountered prematurely.

  Recovery: Check for misplaced braces.

EDC0205
  &1

  The #error directive was encountered. Compilation terminated.

  Recovery: Recompile with correct macro definitions.

EDC0206
  Suffix of integer constant &1 is not valid.

  Valid integer suffixes are u or U for unsigned, l or L for long, or ll or LL for long long. Unsuffixed constants are given the smallest data type that can hold the value. Refer to the C and C++ Language Reference.

  Recovery: Change or remove the suffix.

EDC0207
  Integer constant &1 out of range.

  The specified constant is too large to be represented by an unsigned long int.

  Recovery: The constant integer must have a value less than UINT_MAX defined in <limits.h>.

EDC0209
  Character constants must end before the end of a line.

  Character literals must be terminated before the end of the line.

  Recovery: End the character literal before the end of the line. Check for misplaced quotation marks.

EDC0210
  The ## operator requires two operands.

  The ## operator must be preceded and followed by valid tokens in the macro replacement list. Refer to the C and C++ Language Reference for information on the ## operator.

  Recovery: Provide both operands for the ## operator.

EDC0211
  Parameter list must be empty, or consist of one or more identifiers separated by commas.

  The macro parameter list must be empty, contain a single identifier, or contain a list of identifiers separated by commas.

  Recovery: Correct the parameter list.

EDC0212
  Duplicate parameter &2 in definition of macro &1.

  The identifiers in the macro parameter list must be unique.

  Recovery: Change the identifier name in the parameter list.

EDC0213
  Macro name &1 cannot be redefined.

  You can define a macro multiple times only if the definitions are identical except for white space separating the tokens.

  Recovery: Change the macro definition to be identical to the preceding one, or remove it.

EDC0215
  Too many arguments specified for macro &1.

  The number of arguments specified in the macro invocation is different from the number of parameters specified in the macro definition.

  Recovery: Make the number of arguments consistent with the macro definition.

EDC0218
  Unknown preprocessing directive #&1.

  An unrecognized preprocessing directive has been encountered.

  Recovery: Check the spelling and syntax or remove the directive.

EDC0219
  #line value &1 too large.

  The value for a #line directive must not exceed 32767.

  Recovery: Ensure that the #line value does not exceed 32767.

EDC0220
  #line value &1 must contain only decimal digits.

  A non-numeric character was encountered in the #line value.

  Recovery: Check the syntax of the value given.

EDC0221
  Initializer must be a valid constant expression.

  The initializers for objects of static storage duration, for elements of an array, or for members of a structure or union must be valid constant expressions.

  Recovery: Remove the initialization or change the indicated initializer to a valid constant expression.

EDC0224
  Incorrect #pragma ignored.

  An unrecognized #pragma directive was encountered. See the C and C++ Language Reference for the list of valid #pragma directives.

  Recovery: Change or remove the #pragma directive.

EDC0226
  The ":" operator is not allowed between "&1" and "&2".

  The operands must be of compatible type.

  Recovery: Change the type of the operands.

EDC0229
  File is empty.

  The source file contains no code.

  Recovery: Check that the file name and path are correct. Add source code to the file.

EDC0231
  Error occurred while opening preprocessor output file.

  The preprocessor was unsuccessful in attempting to open the output file.

  Recovery: Ensure you have write access to the file.

EDC0232
  Divisor for modulus or division operator cannot be zero.

  The value of the divisor expression cannot be zero.

  Recovery: Change the expression used as the divisor.

EDC0234
  Expecting a new-line character on #&1 directive.

  A character sequence was encountered when the preprocessor required a new-line character.

  Recovery: Add a new-line character.

EDC0235
  Incorrect escape sequence &1. \ ignored.

  An escape sequence that is not valid has been encountered in a string literal or a character literal. It is replaced by the character following the backslash (\).

  Recovery: Change or remove the escape sequence.

EDC0236
  Macro name &1 has been redefined.

  You can define a macro multiple times in extended mode. In ANSI mode macro redefinitions are ignored.

  Recovery: Change the language level to extended (with the /Se compiler option or #pragma langlvl directive), or remove the macro redefinitions.

EDC0238
  Function argument cannot be type void.

  The void type cannot appear in the argument list of a function call. The void type can appear in a parameter list only if it is a non-variable argument function. It is the only parameter in the list, and it is unnamed.

  Recovery: Correct the argument or remove the argument.

EDC0242
  An object with external linkage declared at block scope cannot be initialized.

  You cannot declare a variable at block scope with the storage class extern and give it an explicit initializer.

  Recovery: Initialize the external object in the external declaration.

EDC0243
  Value of enumeration constant must be in range of signed integer.

  If an enum constant is initialized in the definition of an enum tag, the initial value must be an integral expression that has a value representable as an int.

  Recovery: Remove the initial value, or ensure that it is an integral constant expression that has a value representable as an int.

EDC0244
  External variable &1 cannot be redefined.

  An attempt was made to redefine an external variable.

  Recovery: Remove the redefinition.

EDC0245
  Incompatible sign adjective "&1".

  Adjectives "signed" and unsigned can only modify integer type specifiers.

  Recovery: Either remove the sign adjective or use a different type specifier.

EDC0246
  Incompatible length adjective "&1".

  Length adjectives short and long can only be applied to particular scalar types. See the C and C++ Language Reference for valid types.

  Recovery: Either remove the length adjective or use a different type specifier.

EDC0247
  Incompatible type specifier "&1".

  The type specifier is not compatible with the type adjectives used. See the C and C++ Language Reference for valid combinations of type specifiers and adjectives.

  Recovery: Either remove the adjective or use a different type specifier.

EDC0248
  More than one storage class specifier &1.

  A C declaration must only have one storage class specifier.

  Recovery: Ensure only one storage class is specified.

EDC0249
  Identifier contains a $ character.

  You cannot use the $ character in an identifier. An identifier can contain alphanumeric characters and underscores. An identifier must start with either an underscore or alphabetic character.

  Recovery: Remove the $ character.

EDC0250
  Floating point constant &1 out of range.

  The compiler detected a floating-point overflow either in scanning a floating-point constant, or in performing constant arithmetic folding.

  Recovery: Change the floating-point constant so that it does not exceed the maximum value.

EDC0251
  Static function &1 is undefined.

  A static function was declared and referenced in this file. The definition of the function was not found before the end of the file. When a function is declared to be static, the function definition must appear in the same file.

  Recovery: Define the function in the file or remove the static storage class.

EDC0258
  Hexadecimal integer constant &1 is not valid.

  An invalid hexadecimal integer constant was specified. See the C and C++ Language Reference for details on specifying hexadecimal characters.

  Recovery: Change the value to a valid hexadecimal integer constant.

EDC0260
  Octal integer constant &1 is not valid.

  An invalid octal integer constant was specified. See the C and C++ Language Reference for details on specifying octal characters.

  Recovery: Change the value to a valid octal integer constant.

EDC0261
  Suboption &1 is not valid for option &2.

  An invalid suboption was specified for some option.

  Recovery: Change the suboption.

EDC0262
  #pragma &1 must occur before first C statement in program. #pragma ignored.

  This pragma must be specified before the first C token in the input (including header files).

  Recovery: Place the #pragma directive in the file before any C code, or remove it.

EDC0263
  #pragma strings directive can be specified only once per source file. #pragma ignored.

  This #pragma specifies whether string literals are placed in read-only memory. It must appear only once and before any C code.

  Recovery: Change the location of the directive and ensure that it appears only once in the translation unit.

EDC0264
  #pragma comment(copyright) directive can be specified only once per source file.

  There can only be one #pragma comment(copyright) per source file.

  Recovery: Ensure that it occurs only once in the translation unit.

EDC0266
  Parameter(s) for #pragma are out of range.

  The #pragma parameters were invalid. See the C and C++ Language Reference for details on valid #pragma parameters.

  Recovery: Change the parameter.

EDC0267
  Unrecognized #pragma ignored.

  An invalid pragma was encountered and ignored.

  Recovery: Ensure that the #pragma name is spelled correctly. A #pragma with equivalent function, but a different name may exist. See the C and C++ Language Reference for a list of #pragma directives.

EDC0268
  Macro &1 invoked with an incomplete argument for parameter &2.

  The parameter for the macro invocation must have a complete argument.

  Recovery: Complete the specification of the macro argument list. Check for missing commas.

EDC0269
  A char array pointer cannot be assigned to a nonchar pointer.
EDC0270
  A wide char array pointer cannot be assigned to a nonwide char pointer.
EDC0271
  The indirection operator cannot be applied to a void pointer.

  The indirection operator requires a pointer to a complete type. A void pointer is an incomplete type that can never be completed.

  Recovery: Cast the pointer to a type other than void before this operation.

EDC0272
  Identifier not allowed in cast or sizeof declarations.

  Only abstract declarators can appear in cast or sizeof expressions.

  Recovery: Remove the identifier from the cast or sizeof expression and replace it with an abstract declarator.

EDC0273
  Missing type in declaration of &1.

  A declaration was made without a type specifier.

  Recovery: Insert a type specifier into the declaration.

EDC0274
  Missing declarator in structure member declaration.

  A struct or union member declaration must specify a name. A type cannot be followed by a semicolon.

  Recovery: Declare the member with a name.

EDC0275
  Unexpected text &1 encountered.

  A syntax error has occurred. This message lists the tokens that were discarded by the parser when it tried to recover from the syntax error.

  Recovery: Correct the syntax error and compile again.

EDC0276
  Syntax error: possible missing &1?

  A syntax error has occurred. This message lists the token that the parser expected and did not find.

  Recovery: Correct the syntax error and compile again.

EDC0277
  Syntax error: possible missing &1 or &2?

  A syntax error has occurred. This message lists the tokens that the parser expected and did not find.

  Recovery: Correct the syntax error and compile again.

EDC0278
  The structure definition must specify a member list.

  The declaration of a struct or a union that includes an empty member list enclosed between braces is not a valid struct or union definition.

  Recovery: Specify the members of the struct or union in the definition or remove the empty braces to make it a simple struct or union tag declaration.

EDC0279
  A function declarator cannot have a parameter identifier list if it is not a function definition.

  A function declarator that is not also a function definition may not have a K&R style parameter identifier list. An example is the "x,y" in "int (*fred(a,b)) (x,y) {}".

  Recovery: Remove the parameter identifier list.

EDC0280
  Function argument assignment between types "&1" and "&2" is not allowed.

  The type of the argument in the function call should match the corresponding parameter type in the function declaration.

  Recovery: Cast the argument to a different type, change the type or change the function prototype.

EDC0281
  Prefix and postfix increment and decrement operators cannot be applied to "&1".

  Increment and decrement operators cannot operate on pointers to function or pointers to void.

  Recovery: Change the pointer to point to an object type.

EDC0282
  The type of the parameters must be specified in a prototype.

  A prototype specifies the number and the type of the parameters that a function requires. A prototype that does not specify the type of the parameters is not correct, for example,

        fred(a,b);

  Recovery: Specify the type of the parameters in the function prototype.

EDC0283
  Functions cannot be declared &1 at block scope, &2 is ignored.

  Functions declared at block scope can only have extern as an explicit storage class specifier and cannot be inline.

  Recovery: Place the declaration of the function at file scope, or remove the storage class specifier or the inline specifier.

EDC0285
  The indirection operator cannot be applied to a pointer to an incomplete struct or union.

  A structure or union type is completed when the definition of its tag is specified. A struct or union tag is defined when the list describing the name and type of its members is specified.

  Recovery: Complete the struct or union definition.

EDC0286
  A struct or union with no named members cannot be explicitly initialized.

  Only aggregates containing named members can be explicitly initialized.

  Recovery: Name the members of the struct or union.

EDC0287
  The parameter list on the definition of macro &1 is not complete.

  There is a problem with the parameter list in the definition of the macro.

  Recovery: Complete the parameter list. Look for misplaced or extra commas.

EDC0288
  Expecting file name or new-line character on #line directive.

  The #line directive requires a line number argument as its first parameter and a file name as an optional second parameter. No other arguments are allowed. A new-line character must be present after the argument list.

  Recovery: Change the directive syntax.

EDC0289
  Macro &1 redefined with identical definition.

  Identical macro redefinitions are allowed but not necessary. The amount of white space separating the tokens have no bearing on whether macros are considered identical.

EDC0290
  Unknown macro name &1 on #undef directive.

  An attempt is being made to undefine a macro that has not been previously defined.

  Recovery: Check the spelling of the macro name or remove the #undef directive.

EDC0291
  Expecting decimal constant on #line directive.

  The value for a #line directive must be a decimal constant.

  Recovery: Specify a line number on the #line directive.

EDC0292
  Multibyte character literal not allowed on #&1 directive.

  The directive does not allow a multibyte character literal.

  Recovery: Remove the multibyte character literal.

EDC0293
  Identifier &1 assigned default value of zero on &2 directive.

  The indicated identifier in a #if or #elif expression was assigned the default value of zero. The identifier may have been intended to be expanded as a macro.

  Recovery: Add a #define for the macro before using it in a preprocessor conditional.

EDC0294
  Syntax error in expression on #&1 directive.

  The expression for a preprocessor directive contains a syntax error.

  Recovery: Replace the expression that controls the directive by a constant integral expression.

EDC0295
  File ended with a continuation sequence.

  The file ended unexpectedly with a backslash character followed by a new-line character.

  Recovery: Remove the continuation character from the last line of the file, or add code after the continuation character.

EDC0296
  #include file &1 not found.

  The file specified on the #include directive could not be found. See the C and C++ Language Reference for file search order.

  Recovery: Ensure the #include file name and the search path are correct.

EDC0297
  Unable to open input file &1. &2.

  The compiler was unable to open the input file.

  Recovery: Ensure the file exists and that the compiler can access it.

EDC0298
  Unable to read input file &1. &2.

  The compiler was unable to read the input file.

  Recovery: Ensure file exists and is accessible by compiler.

EDC0299
  Maximum #include nesting depth of &1 has been exceeded.

  The included files have been nested too deeply.

  Recovery: Reduce the number of nested include files.

Summary of Compiler Error Messages