Compiler Fatal Error Messages

Number Compiler Fatal Error Message

C1000 UNKNOWN FATAL ERROR
Contact Microsoft Product Support Services
  An unknown error condition was detected by the compiler.
  Note the circumstances of the error, and notify Microsoft Corporation by following the instructions in the Microsoft Product Assistance Request form at the back of one of your manuals.
C1001 INTERNAL COMPILER ERROR
(compiler file filename, line number)
Contact Microsoft Product Support Services
  The compiler detected an internal inconsistency.
  Note the circumstances of the error, and notify Microsoft Corporation by following the instructions in the Microsoft Product Assistance Request form at the back of one of your manuals. Note the filename and line number where the error occurred; an internal file and line number are provided in addition to the file and line number of your source file.
C1002 compiler is out of heap space in pass 2
  The compiler ran out of dynamic memory space during execution of the second pass of the compiler (C2.EXE). Usually this means the program has too many symbols and/or complex expressions.
  One of the following may be a solution:

Divide the file into several smaller source files.

Break expressions into smaller subexpressions.

Remove other programs or drivers running in the system that could be consuming significant amounts of memory.

C1003 error count exceeds number; stopping compilation
  Errors in the program were too numerous to allow recovery, and the compiler must terminate.
C1004 unexpected end of file found
  The default disk drive did not contain sufficient space for compiler-generated temporary files. The space required is approximately two times the size of the source file.
  This message also appears when an #if directive evaluates to false without a corresponding closing #endif directive.
C1005 string too big for buffer
  A string in a compiler intermediate file overflowed a buffer.
C1006 write error on compiler intermediate file
  The compiler was unable to create the intermediate files used in the compilation process.
  This error can be caused by a disk media error or by an open floppy drive door.
C1007 unrecognized flag string in option
  The string in the command-line option was not valid.
  Check the CL command line and CL environment variable for option specifications.
C1008 no input file specified
  The compiler was not given a file to compile.
  The compiler must be given a C or C++ source file to compile. Check the CL command line and CL environment variable for filename specifications.
C1009 compiler limit : macros nested too deeply
  Too many macros were being expanded at the same time.
  This error occurs when a macro definition contains macros to be expanded and those macros contain other macros. The compiler has a limit of 256 levels of nested macros.
  Try to split the nested macros into simpler macros.
C1011 compiler limit : identifier : macro definition too big
  The macro definition was longer than allowed.
  Try to split the definition into shorter definitions.
C1012 unmatched parenthesis nesting : missing character
  The parentheses in a preprocessor directive were not matched. The missing character is either a left or right parenthesis.
C1013 compiler limit : too many open parentheses
  Too many levels of parentheses were used.
  Simplify the expression, or calculate part of the expression in a separate statement.
C1015 compiler limit : too many segments
  Too many segments were opened.
  This error occurs only with the /f or /qc fast-compilation options or with the /Oq p-code generation option.
  There are several ways to correct this situation:

Reduce the number of segments used by your program.

Separate the source code into multiple files so that fewer segments are referenced in a single module.

Recompile the program without the /f, /qc, or /Oq command-line option.

C1016 #if[n]def expected an identifier
  The #ifdef or #ifndef conditional compilation directive was not supplied with an identifier to evaluate.
  An identifier must be specified with the #ifdef and #ifndef directives.
C1017 invalid integer constant expression
  The expression in an #if directive either did not exist or did not evaluate to a constant.
C1018 unexpected #elif
  The #elif directive did not appear within an #if, #ifdef, or #ifndef construct.
  Make sure that there is a #if, #ifdef, or #ifndef statement in effect before this statement.
C1019 unexpected #else
  The #else directive did not appear within an #if, #ifdef, or #ifndef construct.
  Make sure that there is a #if, #ifdef, or #ifndef statement in effect before this statement.
C1020 unexpected #endif
  An #endif directive appeared without a matching #if, #ifdef, or #ifndef directive.
  Make sure that there is a matching #endif for each #if, #ifdef, and #ifndef statement.
C1021 invalid preprocessor command string
  The characters following the number sign (#) did not form a valid preprocessor directive.
  The number sign cannot be used as the first character in an identifier.
C1022 expected #endif
  An #if, #ifdef, or #ifndef directive was not terminated with an #endif directive.
  Make sure that there is a #if, #ifdef, or #ifndef statement in effect before this statement.
C1023 cannot open source file filename
  The given file either did not exist, could not be opened, or was not found.
  Make sure that the environment settings are valid and that the correct path for the file is specified.
  If this error appears without an error message, the compiler has run out of file handles. To increase the number of file handles available under DOS, change the FILES setting in CONFIG.SYS. FILES=50 is the recommended setting.
C1024 cannot open include file filename
  The specified file in an #include preprocessor directive could not be found.
  Make sure that the settings for the INCLUDE and TMP environment variables are valid and that the correct path for the file is specified.
  If this error appears without an error message, the compiler has run out of file handles. To increase the number of file handles available under DOS, change the FILES setting in CONFIG.SYS. FILES=50 is the recommended setting.
C1026 parser stack overflow : program too complex
  The program could not be processed because the space required to parse the program caused a stack overflow in the compiler.
  Simplify the program by decreasing the complexity of expressions. Decrease the level of nesting in for and switch statements by putting some of the more deeply nested statements in separate functions. Break up very long expressions involving comma operators or function calls.
C1027 DGROUP data allocation exceeds 64K
  More than 64K of variables were allocated to the default data segment.
  For compact-, large-, or huge-model programs, use the /Gt option to move items into separate segments. In small- or medium-model programs, consider explicitly allocating some variables outside of DGROUP by using __based or __far.
  This limit does not exist when compiling programs for 32-bit operating systems, such as the Microsoft DOS Extender.
C1031 compiler limit : function calls nested too deeply
  The program exceeded the dynamic compiler limit on nested function calls.
  Split the nested calls, saving the return value from one of the nested functions in a temporary variable.
C1032 cannot open object code listing file filename
  The output listing file specified with the /Fl command-line option could not be opened.
  There are several possible causes for this error:

The given name is not valid.

The file cannot be opened because of a lack of space.

A read-only file with the given name already exists.

The file is in use by another process.

C1033 cannot open assembly language output file filename
  The output listing file specified with the /Fc or /Fa command-line option could not be opened.
  There are several possible causes for this error:

The given name is not valid.

The file cannot be opened because of a lack of space.

A read-only file with the given name already exists.

The file is in use by another process.

C1035 expression too complex; simplify expression
  The compiler was unable to generate code for a complex expression.
  Try to split the expression into simpler subexpressions and recompile.
C1036 cannot open source listing file filename
  The output listing file specified with the /Fs command-line option could not be opened.
  There are several possible causes for this error:

The given name is not valid.

The file cannot be opened because of a lack of space.

A read-only file with the given name already exists.

The file is in use by another process.

C1037 cannot open object file filename
  The object file specified with the /Fo command-line option could not be opened.
  There are several possible causes for this error:

The given name is not valid.

The file cannot be opened because of a lack of space.

A read-only file with the given name already exists.

The file is in use by another process.

C1039 unrecoverable heap overflow in pass 3
  The postoptimizer compiler pass overflowed the heap and could not continue.
  One of the following may be a solution:

Break up the function containing the line that caused the error.

Recompile with the /Od option to remove optimization.

Remove other programs or drivers running in the system that could be consuming significant amounts of memory.

C1040 unexpected end-of-file condition in source file filename
  The compiler detected an unexpected end-of-file condition while creating a source listing or mixed source and object listing.
  This error occurs if the source file is deleted or overwritten while it is being read.
C1041 cannot open compiler intermediate file—no more files
  The compiler could not create intermediate files for use in the compilation process because no more file handles were available.
  To increase the number of file handles available under DOS, change the FILES setting in CONFIG.SYS. FILES=50 is the recommended setting.
C1042 cannot open compiler intermediate file—no such file or directory
  The compiler could not create intermediate files for use in the compilation process because the TMP environment variable was set to an invalid directory or path.
  Use the SET command to change the TMP environment variable so that it points to a valid directory.
C1043 cannot open compiler intermediate file
  The compiler could not create intermediate files for use in the compilation process. The exact reason could not be determined.
  One of the following may be a solution:

Make sure that the environment variable TMP points to a drive and directory in which a file can be created.

Delete unneeded files in the TMP directory.

C1044 out of disk space for compiler intermediate file
  The compiler could not create intermediate files for use in the compilation process because no more space was available.
  Make more space available on the disk pointed to by the TMP environment variable and then recompile.
C1045 compiler limit : linkage specifications nested too deeply
  The nesting of externals exceeded the capacity of the compiler. Nested externals are allowed when specifying the external linkage type (such as extern "C++").
  Make sure that nested externals have appropriate closing braces.
C1046 compiler limit : structure nested too deeply
  The given structure, union, or class exceeded the nesting limit of the compiler.
  Structures, unions, and classes cannot be nested to more than 15 levels.
  Rewrite the definition so that fewer structures, unions, or classes are nested. The structure, union, or class can be split into two or more parts by defining one or more of the nested structures using typedef.
C1047 limit of option exceeded at string
  The given option was specified too many times. The given string is the argument to the option that caused the error.
  Check the CL environment variable for additional occurrences of the given command-line option.
C1048 unknown option character in option
  The given character was not a valid letter for the option.
  For example, the following line:

#pragma optimize( "*", on )

  causes the following error:

unknown option '*' in '#pragma optimize'

C1049 invalid numerical argument string
  The compiler expected a numerical argument but received the given string.
  This error may be caused by giving a hexadecimal number without the necessary \x prefix or by a misformed floating-point number.
C1050 segment : code segment too large
  A code segment grew to within 36 bytes of 64K during compilation of a 16-bit program.
  To avoid this error, choose a memory model that allows multiple code segments, such as medium, large, or huge. This error can also be avoided by using the /Gy command-line option to have the compiler generate packaged functions.
  A 36-byte pad is used because of a bug in some 80286 chips that can cause programs to exhibit strange behavior when, among other conditions, the size of a code segment is within 36 bytes of 64K.
C1052 compiler limit : #if or #ifdef nested too deeply
  The program exceeded the maximum of 32 nesting levels for #if and #ifdef directives.
  This error can be caused by include files that use these preprocessor directives.
C1054 compiler limit : initializers nested too deeply
  The compiler limit on the nesting of initializers was exceeded. The limit depends on the combination of types being initialized and may range from 10 to 15 levels.
  Simplify the data types being initialized to reduce the levels of nesting, or assign initial values in separate statements after the declaration.
C1055 compiler limit : out of keys
  The file being compiled contained too many symbols.
  Try to split the file into smaller files, and compile them separately.
C1056 compiler limit : out of macro expansion space
  The compiler overflowed an internal buffer during the expansion of a macro.
  Try to split the macros into simpler macros or remove nonessential space and tab characters from macro definitions that were used in the expansion.
C1057 unexpected end of file in macro expansion
  The compiler has encountered the end of the source file while gathering the arguments of a macro invocation. Usually this is the result of a missing right parenthesis in the macro invocation.
C1058 compiler limit : too many formal arguments
  The function declaration had too many formal arguments.
  Reduce the number of arguments by passing structures or pointers to structures.
C1059 compiler is out of near heap space
  The compiler ran out of storage for items that it stores in its near (default data segment) heap.
  One of the following may be a solution:

Eliminate unnecessary include files, especially unneeded function prototypes.

Split the function at the given line number into two or more functions.

Split the current file into two or more files and compile them separately.

C1060 compiler is out of far heap space
  The compiler ran out of storage for items that it stores in its far heap. Usually this is the result of having too many symbols.
  One of the following may be a solution:

Eliminate unnecessary include files, especially unneeded #defines and function prototypes.

Eliminate some global variables.

Split the current file into two or more files and compile them separately.

Remove other programs or drivers running in the system, which could be consuming significant amounts of memory.

C1061 compiler limit : blocks nested too deeply
  Nested blocks in the program exceeded the nesting limit allowed by the compiler.
  This error occurs only with the /f or /qc fast-compilation option.
  Rewrite the program, putting one or more nested blocks into a separate function, or recompile the program without the /f or /qc option.
C1062 error while writing to preprocessor output file
  The compilation command included the /P option to produce a preprocessor output file, but not enough disk space was available to hold the file.
  Free more space on the destination drive or choose an alternate output drive.
C1063 compiler limit : compiler stack overflow
  The program was too complex and caused the compiler stack to overflow.
  Simplify the program, making it more modular, and recompile. If the /f or /qc fast-compilation command-line option is being used, recompile without it.
C1064 compiler limit : token overflowed internal buffer
  The compiler read an identifier that was longer than the internal buffer used for identifier names.
  Shorten the name and recompile.
C1065 compiler limit : out of tags
  The file being compiled contained too many symbols.
  Try to split the file into smaller files, and compile them separately.
C1066 compiler limit : decorated name length exceeded
  After the symbol's name was made unique ("decorated"), it became too long. The maximum length of a decorated C++ name is 247 characters.
  Shorten the name of the symbol.
C1068 cannot open file filename
  The given file either did not exist, could not be opened, or was not found.
  Make sure that the environment settings are valid and that the correct path for the file is specified.
  If this error appears without an error message, the compiler has run out of file handles. To increase the number of file handles available under DOS, change the FILES setting in CONFIG.SYS. FILES=50 is the recommended setting.
C1069 write error on file filename
  An error occurred while the compiler was trying to write to the file. One possible cause of this error is insufficient disk space.
C1070 mismatched #if/#endif pair in file filename
  The preprocessor found the #if, #ifdef, or #ifndef directive but did not find a corresponding #endif directive in the same source file.
C1071 unexpected end of file found in comment
  The compiler found the end of a file while scanning a comment.
  Probably a comment was not terminated. Begin at the end of the file and search backward for the beginning of a comment. A comment begins with /* and ends with */ as in:

/* This is a

comment */

  A comment cannot be split across source files.
C1072 filename : cannot read file
  The compiler encountered an error when trying to read a file.
  This error can be caused by a disk error or by a file-sharing conflict.
C1090 segment data allocation exceeds 64K
  The size of the named segment exceeded 64K.
  In a 16-bit program, segments cannot exceed 64K. This error occurs with __based allocation.
  Choose a segment that has more space available, or use the huge memory model.
C1126 identifier : automatic allocation exceeds size
  The space allocated for the local variables of a function exceeded the given limit.
  Use the malloc run-time function or the new function to allocate large amounts of space for data.
C1127 segment : segment redefinition
  A segment was overwritten by another segment with the same name.
  For example, compiling in large model with:

#pragma alloc_text( _TEXT, func1 )

  creates two segments, the default segment module_TEXT and the specified segment _TEXT. However, in small model, the default segment is _TEXT, and the specified segment _TEXT will overwrite the default segment.
C1500 filename : cannot open inline function definition file
  The given file either did not exist, could not be opened, or was not found.
  Make sure that the environment settings are valid and that the correct path for the file is specified.
  If this error appears without an error message, the compiler has run out of file handles. To increase the number of file handles available under DOS, change the FILES setting in CONFIG.SYS. FILES=50 is the recommended setting.
C1501 compiler limit : too many temporary variables
  The source file contained more than 17,500 temporary variables.
  Split the file into smaller parts.
C1502 inline member-function definition missing '}'
  The compiler reached the end of the file and did not find a matching closing brace.
  Make sure that curly braces are matched.
C1503 default parameter definition missing ',' or ')'
  After one or more default parameters were defined, neither a comma to indicate continuation nor a closing parenthesis to indicate termination of the function declaration was found.
  Make sure that there are matching parentheses around the set of formal parameters.
C1504 type ambiguous after number tokens
  The compiler could not resolve the type after looking ahead in the code.
  Simplify the code to make the statement clearer. This error can often be eliminated by using an explicit type cast to an ambiguous expression.
C1505 unrecoverable parser lookahead error
  The compiler could not evaluate the code.
  Simplify the code by making smaller classes or functions.
C1506 unrecoverable block scoping error
  The block was too large to compile.
  This error can be caused by mismatched curly braces or by an extremely large function or class.