### Compiler Error Messages EDC0300 - EDC0399

EDC0300
  Insufficient storage available.

  The compiler ran out of memory trying to compile the file. This sometimes happens with large files or programs with large functions. Note that very large programs limit the amount of optimization that can be done.

  Recovery: Shut down any large processes that are running, ensure your swap path is large enough, turn off optimization, or limit the optimizer's working set maximum. You can also divide the file into several small sections or shorten the function.

EDC0301
  Redeclaration cannot specify fewer parameters than previous declaration.

  The function definition has fewer parameters than the prototype.

  Recovery: Modify one of the function declarations so that the number and types of the parameters match.

EDC0302
  The declarations of the function &1 must be consistent in their use of the ellipsis.

  The prototyped redeclaration of the function is not correct. Fewer parameters appear before the ellipsis in this function redeclaration than the previous declaration.

  Recovery: Ensure that the redeclaration is consistent with the previous declaration.

EDC0303
  The type of the parameter &1 cannot conflict with the previous declaration of function &2.

  Nonprototype function declarations, popularly known as K&R prototypes, specify only the function return type. The function parentheses are empty; no information about the parameters is given.

  Nonprototype function definitions specify a list of parameter names appearing between the function parentheses followed by a list of declarations (located between the parentheses and the opening left brace of the function) that indicates the type of the parameters. A nonprototype function definition is also known as a K&R function definition.

  A prototype function declaration or definition specifies the type and the number of the parameters in the parameter declaration list that appears inside the function parenthesis. A prototype function declaration is better known as an ANSI prototype, and a prototype function definition is better known as an ANSI function definition.

  When the nonprototype function declarations/definitions are mixed with prototype declarations, the type of each prototype parameter must be compatible with the type that results from the application of the default argument promotions.

  Most types are already compatible with their default argument promotions. The only ones that aren't are `char`, `short`, and `float`. Their promoted versions are, respectively, `int`, `int`, and `double`.

  This message can occur in several situations. The most common is when mixing ANSI prototypes with K&R function definitions. If a function is defined using a K&R-style header, then its prototype, if present, must specify widened versions of the parameter types. Here is an example.

        int fn(short);
        int fn(x)
          short x;
        {}

  This is not valid because the function has a K&R-style definition and the prototype does not specify the widened version of the parameter. To be correct, the prototype should be

        int fn(int);

  because `int` is the widened version of `short`.

  Another possible solution is to change the function definition to use ANSI syntax. This particular example would be changed to

        int fn(short);
        int fn(short x)
        {}

  This second solution is preferable, but either solution is equally valid.

  Recovery: Give a promoted type to the parameter in the prototype function declaration.

EDC0304
  No function prototype given for '&1'.

  A prototype declaration of the function specifying the number and type of the parameters was not found before the function was used. Errors may occur if the function call does not respect the function definition.

  Recovery: Add an appropriate function prototype before calling the function.

EDC0306
  Subscript operator requires an array operand in the offsetof macro.

  A subscript was specified in the offsetof macro but the operand is not an array.

  Recovery: Either change the operand to be an array type or remove the subscript operator.

EDC0307
  Array index must be a constant expression in the offsetof macro.

  The offsetof macro is evaluated at compile time. Thus all arguments must be constant expressions.

  Recovery: Change the expression.

EDC0308
  Operand of the offsetof macro must be a struct or a union.

  The first operand of the offsetof macro must be a structure or union type.

  Recovery: Change the operand.

EDC0309
  The offsetof macro cannot be used with an incomplete struct or union.

  An incomplete struct or union is not a valid argument to the offsetof macro. A structure or union type is completed when the definition of its tag is specified.

  Recovery: Ensure the struct or union is a complete type.

EDC0310
  The type "&1 &2" was introduced in a parameter list, and will go out of scope at the end of the function declaration or definition.

  The tag will be added to parameter scope. Thus it will go out of scope at the end of the declaration or function definition.

  Recovery: If the tag is needed for declarations outside its scope, move the tag declaration outside of parameter scope.

EDC0311
  Wide character constant &1 has more than one character. Last character is used.

  All but the last character in the constant will be discarded.

  Recovery: Remove all but one character or change the character constant into a string literal.

EDC0312
  Compiler internal name &1 has been defined as a macro.

  Do not redefine internal compiler names.

  Recovery: Remove the macro definition or change the name of the macro being defined.

EDC0313
  Compiler internal name &1 has been undefined as a macro.

  Do not redefine internal compiler names.

  Recovery: Remove the macro undefinition.

EDC0314
  The tag of this expression's type has gone out of scope.

  The tag used in the type declaration of the object has gone out of scope, however the object is still referenced in the expression.

  Recovery: Either remove the reference to the object or move the tag's definition to a scope that encloses both the referenced object and the object's declaration.

EDC0320
  Operation is not allowed because the size of &1 is unknown.

  The operand must be a complete type for the compiler to determine its size.

  Recovery: Provide a complete type definition.

EDC0321
  You can specify an initializer only for the first named member of a union.

  There can only be an initializer for the first named member of a union.

  Recovery: Remove all union initializers other than the one attached to the first named member.

EDC0322
  Illegal multibyte character &1.

  The multibyte character specified is not valid.

  Recovery: Correct the multibyte character.

EDC0323
  "double" should be used instead of "long float".

  The type long float is not valid; it is treated as a double.

  Recovery: Remove the long type specifier or use double instead of float.

EDC0324
  "&1" cannot be converted to "&2".

  The cast between the two types is not allowed.

  Recovery: Remove the cast.

EDC0327
  An error occurred while opening the listing file, &1.

  The compiler was unable to open the listing file.

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

EDC0328
  "&1" is not a valid hex digit.

  Valid hex digits are the letters A,B,C,D,E,F,0,1,2,3,4,5,6,7,8,9.

  Recovery: Change the digit.

EDC0334
  Identifier &1 has already been defined on line &2 of "&3".

  There is more than one definition of an identifier.

  Recovery: Remove one of the definitions or change the name of the identifier.

EDC0335
  Parameter identifier list contains multiple occurrences of &1.

  Identifier names in a parameter list must be unique.

  Recovery: Change the name of the identifier or remove the parameter.

EDC0336
  A Pascal string is too long; the length has been set to 255.

  Pascal strings have a length limit of 255 characters.

  Recovery: Shorten the length of the string.

EDC0337
  The result of string concatenation is a Pascal string.

  A Pascal string is prefixed with a "\P". The string length is encoded in the string and it is not null terminated. A 'C' string is a null terminated string. The two are not compatible. Concatenation requires that both strings be of the same type.

EDC0338
  The result of string concatenation is a non-Pascal string.

  A Pascal string is prefixed with a "\P". The string length is encoded in the string and it is not null terminated. A 'C' string is a null terminated string. The two are not compatible. Concatenation requires that both strings be of the same type.

EDC0339
  A character string literal cannot be concatenated with a wide string literal.

  A string that has a prefix L cannot be concatenated with a string that is not prefixed. Concatenation requires that both strings be of the same type.

  Recovery: Check the syntax of the value given.

EDC0340
  A Pascal string literal cannot be concatenated with a wide string literal.

  A string that has a prefix L cannot be concatenated with a string that is not prefixed.

  Recovery: Check the syntax of the value given.

EDC0341
  #include header must be ended before the end of the line.

  A #include directive was specified across two or more lines.

  Recovery: Ensure that the #include directive and its arguments are contained on a single line.

EDC0342
  "/*" detected in comment.

  You can ignore this message if you intended "/*" to be part of the comment. If you intended it to start a new comment, move it out of the enclosing comment.

  Recovery: Remove "/*" or ensure that "/*" was intended in the comment.

EDC0343
  Redeclaration of &1 differs from previous declaration on line &2 of "&3".

  The redeclaration is not compatible with the previous declaration.

  Recovery: Either remove one declaration or make the types compatible.

EDC0344
  Member &1 has already been defined on line &2 of "&3".

  Member names must be unique within the same aggregate.

  Recovery: Change the name.

EDC0345
  The data in precompiled header file &1 does not have the correct format.

  The precompiled header file may have become corrupt and is ignored.

  Recovery: Regenerate the precompiled header files.

EDC0346
  Unable to open precompiled header file &1 for input. The original header will be used.

  The compiler was unable to open the precompiled header file for reading and will use the original header.

  Recovery: Regenerate the precompiled header files.

EDC0347
  Precompiled header file &1 was created by a more recent release of the compiler. The original header will be used.

  The compiler cannot understand the format of the precompiled header, since it was generated using a more recent version of the compiler. The original text version of the header will be used.

  Recovery: Regenerate the precompiled header files.

EDC0348
  Unable to write to precompiled header file &1.

  The compiler was unable to write to the precompiled header files.

  Recovery: Ensure that the compiler has write access to the precompiled header files.

EDC0349
  Value of enumeration constant must be in range of unsigned integer.

  If an enum constant is initialized in the definition of an enum tag, the value that it is initialized to 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.

EDC0350
  Error writing to intermediate files. &1.

  An error occurred during compilation.

  Recovery: Ensure the compiler has write access to the directory specified by the TMP environment variable and that there is enough disk space free. Recompile the module.

EDC0351
  Error opening intermediate files.

  An error occurred during compilation.

  Recovery: Recompile module. Ensure the compiler has write access to the directory specified by the TMP environment variable and that there is enough disk space free.

EDC0352
  Incompatible specifications for options -qarch and -qtune.

  The values specified for the arch and tune options are not compatible.

  Recovery: Change option values.

EDC0354
  The -qmacpstr option is ignored when supplied with the -qmbcs/dbcs options.

  Pascal strings are not compatible with multibyte characters.

  Recovery: Do not combine Pascal strings with multibyte characters.

EDC0355
  The option ENUM is not allowed in the middle of a declaration of an enum. This option is ignored.

  An attempt has been made to change the ENUM option inside of an enum declaration. This is not allowed because it would make the storage type of the enumerated values inconsistent.

  Recovery: Move the option to before or after the enum declaration.

EDC0356
  Compilation unit is empty.

  There is no code in the compilation unit.

  Recovery: Ensure the correct source file is specified. Recompile.

EDC0357
  Unable to generate prototype for "&1" because one or more enum, struct, or union specifiers did not have a tag.

  A prototype could not be generated for the function because the enum, struct or union declaration did not have a tag.

  Recovery: Specify a tag.

EDC0358
  "&1" is defined on line &2 of &3.

  This message indicates where a previous definition is located.

  Recovery: Remove one of the definitions or change the name of the identifier.

EDC0359
  Automatic variable &1 contains a const member and is not initialized. It will be initialized to zero.

  An automatic variable that has a const member is not initialized. The compiler is using zero as the initializer.

  Recovery: Initialize the const member.

EDC0360
  Same #pragma &1 has already been specified for object "&2"; this specification is ignored.

  The repetition of the #pragma is redundant and is ignored.

  Recovery: Remove the duplicate #pragma.

EDC0361
  A different #pragma &1 has already been specified for object "&2", this specification is ignored.

  A previous #pragma for the object is taking precedence over this #pragma.

  Recovery: Remove one of the #pragma directives.

EDC0362
  Identifier "&1" was referenced in #pragma &2, but was never actually declared.

  A #pragma refers to an identifier that has not been declared.

  Recovery: Declare identifier or remove #pragma.

EDC0363
  Packing boundary must be specified as one of 1, 2, 4, 8 or 16.

  Objects must be packed on 1, 2, 4, 8 or 16 byte boundaries.

  Recovery: Change the packing specifier.

EDC0364
  The calling convention is not valid for main. _Optlink is assumed.

  An inappropriate calling convention has been specified for the main function. This function is the starting point of the program so only _Optlink calling conventions is allowed.

  Recovery: Remove explicit calling convention specifier for main.

EDC0366
  Declaration cannot specify multiple calling convention specifiers.

  A declaration can specify only one calling convention.

  Recovery: Remove extra calling convention specifiers.

EDC0367
  Only functions or typedefs of functions can be given a calling convention.

  A calling convention protocol keyword has been applied to an identifier that is not a function type or a typedef to a function type.

  Recovery: Check that correct identifier is specified or remove #pragma.

EDC0368
  A calling convention must appear to the left of the identifier to which it applies.

  A declaration has been discovered which resembles `int foo _System ();`. Keyword _System must appear immediately to the left of the identifier "foo".

  Recovery: Correct the declaration.

EDC0369
  The function cannot be redeclared with a different calling convention.

  The redeclaration of this function cannot have a different calling convention than the previous declaration. The function could have been given a calling convention through a typedef, or via a previous declaration.

  Recovery: Make sure all declarations of the function specify the same calling convention.

EDC0370
  A _fastcall function cannot be defined in a 32-bit program.

  A callback function cannot have a 16-bit fastcall calling convention. However, you can call 16-bit fastcall functions.

  Recovery: Change the calling convention.

EDC0371
  Functions taking a variable number of parameters cannot have _Pascal calling convention.

  A function with _Pascal calling convention cannot have a variable number of parameters.

  Recovery: Change the calling convention protocol specification or change the declaration to be a fixed parameter function.

EDC0372
  Precompiled header files may cause inaccuracies for &1. &2 option ignored.

  Precompiled header files are not compatible with some utilities so the precompiled header files may not be used.

  Recovery: Do not use precompiled headers with the specified utility.

EDC0373
  &1 option ignored because &2 option ignored in previous conflict.

  When there is a conflict between options and precompiled header files, the option to generate precompiled header files is also ignored to avoid refreshing the precompiled header files.

  Recovery: Do not use precompiled header files with the specified utility.

EDC0374
  Pointer types "&1" and "&2" are not compatible.

  The types pointed to by the two pointers are not compatible.

  Recovery: Change the types to be compatible.

EDC0375
  /Gr+ must be specified to use the _Far32 _Pascal calling convention.

  Recovery: Specify the ring zero option (/Gr) on the command line or change the calling convention.

EDC0376
  Redeclaration of &1 has a different number of fixed parameters than the previous declaration.

  The number of fixed parameters in the redeclaration of the function does not match the original number of fixed parameters.

  Recovery: Change the declarations to have the same number of parameters, or rename or remove one of the declarations.

EDC0377
  The type "&1" of parameter &2 differs from the previous type "&3".

  The type of the corresponding parameter in the previous function declaration is not compatible.

  Recovery: Change the parameter declaration or rename the function declaration.

EDC0378
  Prototype for function &1 cannot contain "..." when mixed with a nonprototype declaration.

  A function prototype and a nonprototype declaration can not be compatible if one contains "...".

  Recovery: Convert nonprototype declaration to a prototyped one or remove the "...".

EDC0379
  Prototype for function &1 must contain only promoted types if prototype and nonprototype declarations are mixed.

  Nonprototype declarations have their parameters automatically promoted. Integral widening conversions are applied to integral types and float is converted into double.

  Recovery: Promote the parameter types in the prototyped declaration.

EDC0380
  Parameter &1 has type "&2" which promotes to "&3".

  Nonprototype declarations have their parameters automatically promoted. Integral widening conversions are applied to integral types and float is converted into double.

  Recovery: Promote the parameter types in the prototyped declaration.

EDC0381
  The type "&1" of parameter &2 in the prototype declaration is not compatible with the corresponding parameter type "&3" in the nonprototype declaration.

  The types of the parameters must be compatible.

  Recovery: Change the parameters so that they are compatible.

EDC0382
  The type "&1" of identifier &2 differs from previous type "&3".

  The two types are not compatible.

  Recovery: Change the parameter types so that they are compatible.

EDC0383
  Expecting "&1" to be an external identifier.

  The identifier must have external linkage.

  Recovery: Change the storage class to extern.

EDC0384
  Expecting "&1" to be a function name.

  "&1" should be a function symbol.

  Recovery: Specify a different name or change the type of the symbol.

EDC0385
  User segment &1 has already been declared.

  The user segment has already been specified as being another type of segment. Data segments and text segments must have distinct names.

  Recovery: Remove one of the declarations for the segment.

EDC0386
  The maximum number of user-defined segments has been exceeded.

  There can only be a certain number of user-defined segments and this limit has been exceeded.

  Recovery: Reduce the number of user-defined segments.

EDC0387
  The enum cannot be packed to the requested size. Use a larger value for /Su.

  Enums may be 1, 2, or 4 bytes in size.

  Recovery: Change the value specified for the enum packing option (/Su).

EDC0388
  Value &1 specified in #pragma &2 is out of range.

  Refer to the C and C++ Language Reference for more information about the valid values for the #pragmas.

  Recovery: Specify a different value.

EDC0389
  Some program text was not scanned due to &1 option or #pragma &2.

  A compiler option or #pragma directive was used to limit the valid text region in a source file.

  Recovery: Remove the /Sg or /Sq option, or remove the #pragma margins or sequence, or specify a more inclusive text region.

EDC0390
  The function or variable &1 cannot be declared as an import in the same compilation unit in which it is defined.

  An object or function has both a definition and an import directive in this compilation unit. This creates a conflict, since the function or object can be defined either here or where it is exported from, but not both.

  Recovery: Remove the #pragma import directive or __import keyword or change the definition of the object or function into an extern declaration.

EDC0391
  Variable &1 cannot be defined with use of #pragma import.

  You cannot define the function or variable if it is used in a #pragma import.

  Recovery: Rename the variable.

EDC0392
  A DLL module name must be specified in #pragma import.

  Module name is the name of the DLL where the entry point of the import function exists. It must be specified in the parameter list of #pragma import.

  Recovery: Name the DLL in the parameter list.

EDC0393
  &1 value must contain only decimal digits.

  A non-numeric character was encountered in the &1 value.

  Recovery: Check the syntax of the value given.

EDC0394
  Ordinal value on #pragma &1 is out of range.

  The specified ordinal number should be between 0 and 65535, inclusive.

  Recovery: Change the value accordingly.

EDC0395
  Variable &1 must be an external object or a function name for use with #pragma import.

  The identifier specified by the pragma is not a function or external object.

  Recovery: Declare the object with storage class "extern".

EDC0396
  Option &1 is incompatible with option &2 and is ignored.

  The option is not compatible with another option so it is ignored.

  Recovery: Remove one of the options.

EDC0397
  Undefined function or variable &1 cannot have a #pragma export or _Export.

  Only defined variables or functions can be specified as an export.

  Recovery: Define the function or variable.

EDC0398
  Bit-field type specified for &1 is non-portable. The type should be signed int, unsigned int or int.

  The specification of the bit-field type may cause problems with porting the code to another system.

  Recovery: Change the type specifier.

EDC0399
  The alignment of a structure/union is determined at the left brace of the definition.

  The alignment of an aggregate is constant throughout its definition.

Summary of Compiler Error Messages