The specified label is used but is not defined.
Recovery
Define the label before using it.
The value of an enumerator must be a constant expression that is promotable to a signed int value. A constant expression has a value that can be determined during compilation and does not change during program execution.
Recovery
Change the initializer to an integral constant expression.
Templates for static data members are only partially supported, and may cause linker errors if they are overridden by explicit definitions, or if they occur in library objects. For more details, see the help on using templates in C++ programs.
Recovery
Ensure that you observe the restrictions listed in the Programming Guide.
Contravariant virtual functions are supported only for classes with single inheritance and no virtual bases.
Recovery
Ensure the class has single inheritance and no virtual bases.
The compiler must generate code to convert the actual return type into the type that the overridden function returns (so that calls to the original overridden function is supported). However, the target type is inaccessible to the overriding function.
Recovery
Make the base class accessible.
The class member specified is defined in more than one class nested within the base class and cannot be referenced from the base class if it is not qualified. This message is generated by the /Wund option.
Recovery
Use the scope operator ( :colon. :colon.) to qualify the name.
This message will be invoked with /Wund option when UNQUALIFIED_MEMBER message (about unqualified members) is generated. This message tells you about the member data and the class it belongs to.
A function name is required in this context. The specified name has been declared but it is not the name of a function.
Recovery
Ensure the name is the correctly-spelled name of a function.
#pragma priority values less than -2147482624 are reserved for system purposes.
Recovery
Change the #pragma priority value so that it is greater than -2147482624.
The current priority cannot be higher than the priority specified in the previous #pragma priority statement. As the priority value increases with each #pragma priority directive, the priority level decreases.
Recovery
Ensure priority values increase with each #pragma priority statements.
Static objects should not be initialized or terminated before the first #pragma priority directive before the first #pragma priority.
Recovery
Ensure initialization or termination follows the first "#pragma priority" statement.
The pointer type named in the directive is not one of the ILE pointer type.
Recovery
Change to a correctly-spelled ILE pointer type.
The first parameter of the #pragma pointer directive must be defined as a typedef of a pointer to void before it can be named in the #pragma pointer directive.
Recovery
Declare the typedef before the pragma pointer directive.
The identifier named as the first parameter of the directive is not a typedef.
Recovery
Change the identifier to a correctly-spelled typedef name.
The typedef name must be a typedef of void pointer.
Recovery
Change the name to a typedef of void pointer.
The typedef name has been used in a declaration before the pragma pointer directive occurs.
Recovery
Move the declaration so that is appears before the pragma pointer directive.
#pragma options with the option enum (#pragma options enum=) cannot be specified within an enumeration declaration.
Recovery
Remove the enum option from the declaration.
The enumerator type values should fit into an integer. Specifying both unsigned and negative values will exceed this limit.
Recovery
Remove the negative or unsigned values.
A different code segment for the function has been previously specified in the #pragma alloc_text or #pragma code_seg directive.
Recovery
Change or remove the current code segment of the function in the #prgama alloc_text directive or remove the conflicting #pragma code_seg.
A syntax error was found during preprocessing. The message identifies what the compiler expected and what it actually found.
Recovery
Correct the syntax error.
The ordinal value specified in a #pragma import or #pragma export directive must be a positive number within the range of short integer values.
Recovery
Change the ordinal value so that it is within the range.
(This is an undocumented second level message, do not publish it.) The overloaded functions cannot use #pragma reg_killed_by for a set of instructions specified for the function.
Recovery
Remove the #pragma reg_killed_by.
If the calling function has a 16-bit calling convention (_Far16 _Cdecl, _Far16, _Pascal, or _Far16 _Fastcall), the function being called should not have an aggregate parameter passed by value.
Recovery
Remove the by-value aggregate parameters.
If the calling function has a 16-bit calling convention (_Far16 _Cdecl, _Far16, _Pascal, or _Far16 _Fastcall), the function being called should not have an aggregate parameter passed by value.
Recovery
Remove the return of an aggregate by value.
(This is an undocumented second level message, do not publish it.) The instruction specified with the #pragma mc_func is outside the file scope.
Recovery
Move #pragma mc_func so that it is in file scope.
(This is an undocumented second level message, do not publish it.) An incorrect hexadecimal value has been specified with the "#pragma mc_func" directive.
Recovery
Ensure all characters in the instruction sequence for #pragma mc_func are hexadecimal digits.
(This is an undocumented second level message, do not publish it.) The instruction sequence specified for #pragma mc_func is not in pairs.
Recovery
Change the instruction sequence so that it would result in a complete byte.
Because the function is machine-coded, you cannot take its address.
Recovery
Remove the reference to that function.
(This is an undocumented second level message, do not publish it.) pragma mc_func cannot specify a set of instructions for overloaded functions.
Recovery
Remove the #pragma mc_func.
The pragma is not supported by this compiler or the syntax of this pragma is invalid.
Recovery
Correct or remove the #pragma.
The pragma specified is not valid. The compiler ignores it.
Recovery
Remove the invalid pragma name.
Characters in the ASCII code page &1 cannot be translated to characters in the EBCDIC code page &2. They are either incompatible code pages, or not supported.
Recovery
Change the code page specification.
The declaration of a pure virtual function must include the keyword virtual.
Recovery
Remove the initializer.
A function must be declared before it appears in the pragma descriptor directive.
Recovery
Declare the function before the pragma descriptor directive.
The compiler has detected an unknown type specified as the operational descriptor. SV :colon. &1 is a C++ type
The pragma does not expect the function to have a C++ linkage or OS linkage.
Recovery
Remove the C++ or OS linkage on the function declaration.
Compiler expected a void token but found something else instead.
Recovery
Ensure the correct token is found.
The number of parameters found are more than were specified in the function prototype.
Recovery
Ensure the number of parameters is the same as in the function prototype.
The name is not a function name or the name is mis-spelled.
Recovery
Change to the correctly-spelled name of a function.
The variable has not been declared before use.
Recovery
Declare the variable.
The compiler expected a zero value but found something else instead.
Recovery
Ensure 0 is found.
The parameter specified in the pragma is invalid or the pragma does not expect a parameter.
Recovery
Remove the pragma parameter.
The operational descriptor specifier name is invalid or the name is mis-spelled.
Recovery
Remove the operational descriptor.
An invalid object type is found by the compiler.
Recovery
Change to a valid object type.
The compiler has detected that class1 is not a valid constant expression.
Recovery
Change or remove class1 to a constant expression.
The compiler has detected that class2 is not a valid constant expression.
Recovery
Change or remove class2 to a constant expression.
The specifier is not valid for this type.
Recovery
Ensure the operational descriptor specifier is valid.
The compiler has detected an invalid #pragma pack syntax.
Recovery
Correct the syntax.
Alignment of the class must be known prior to its definition.
Recovery
Move #pragma pack so that it is before the definition of the class.
The specified alignment can only be applied to a class that has been declared.
Recovery
Declare the class before it is used in a #pragma pack.
There can only be one alignment specification per class.
Recovery
Remove or change one of the #pragma pack statements.
Each #pragma pack value is placed on a stack. There is currently no #pragma pack value on the alignment stack.
Recovery
Remove #pragma pack() directive.
The alignment value specified with #pragma pack is not valid. Check the
Recovery
Remove the invalid value.
Only one alignment value specified by #pragma pack can be used when defining a template.
Recovery
Ensure the template class matches only one #pragma pack.
The command line contained an option with an invalid sub-option.
Recovery
Remove the sub-option.
Only functions with extern "C" linkage can be mapped using #pragma map.
The linkage specified with #pragma linkage is not valid for this identifier.
Recovery
Remove the linkage specification.
Linkage, map or noinline can only apply to those identifiers which have been declared.
Recovery
Declare the identifier before linkage, mapping or noinline.
The compiler encountered a pragma with an invalid syntax. The message identifies what the compiler expected and what it actually found.
Recovery
Correct the syntax.
va_start initializes the argument to point to the beginning of the list.
Recovery
Ensure the argument to va_start is a parameter name.
The local variable is only active until the end of the function, but it is being used to initialize a member reference variable.
Recovery
Ensure that no part of your program depends on the variable or temporary.
Either you pressed Ctrl-C or the operating system killed the process. Possible cause :colon. swap space is exhausted
The _Packed type specifier can only be used in a typedef declaration.
Recovery
Use _Packed in a typedef declaration to declare the _Packed class type, then use the typedef name to declare the variable.
The _Packed specifier is only valid on a typedef declaration with a class definition.
Recovery
Define the _Packed class type in the typedef declaration.
A fetchable function cannot have C++ linkage.
Variable length parameter lists cannot be used when calling between 16 and 32 bit functions. This is a permanent restriction.
A template class is being defined in a scope other than file scope. Because all template class names have file scope this definition is not allowed.
Recovery
Move the template class definition to file scope.
The class template referenced cannot be used until the template that contains it has been instantiated. template cannot be used.
Recovery
Declare the class template at file scope or instantiate the template that contains it.
The precompiled header file has been corrupted or is not actually a precompiled header file.
Recovery
Delete the corrupted header file or use the correct option to regenerate it.
The specified error occurred when the compiler attempted to open the precompiled header file.
Recovery
Correct the condition that prevented the open.
The precompiled header cannot be used because it was created by a later version of the compiler.
Recovery
Delete the header or use the -genpcomp option to regenerate it.
The specified error occurred when the compiler attempted to write to the precompiled header file.
Recovery
Correct the condition which prevented the write operation.
A multibyte character or escape sequence in a literal has been converted to an invalid value for type wchar_t.
Recovery
Change the character or escape sequence.
The argument corresponding to the specified parameter has no tokens.
Recovery
If necessary, specify an argument.
The precompiled header was successfully created.
The specified error occurred when the compiler attempted to open the precompiled header file.
Recovery
Correct the condition which prevented the compiler from opening the file.
![]()
Summary of Compiler Error Messages