[Home]
[Search]
[CTG]
[RTL]
[IDDE]
Compiler Error Messages
This chapter lists and describes the error and warning messages
generated by the compiler. Use this reference to:
- Check or confirm that an error has been reported.
- Discover possible causes for an error.
- Discover possible ways to correct an error.
Messages marked C++ are generated only by the C++ compiler (SC).
Messages marked C are generated only by the C compiler (SC).
Messages marked Warning indicate code that may not execute as
you expect but that does compile. This appendix lists messages in
alphabetical order.
Some descriptions contain a margin note that refers to sections in
one of these books; the sections contain information relevant to the
cause of the error:
- The Annotated C++ Reference Manual (ARM) (Addison-Wesley)
by Ellis and Stroustrup.
- The ANSI C Standard (ANSI) (X3.159).
What's in This Chapter
- How to recognize compiler errors.
- Types of errors.
- How to report internal errors.
- The Digital Mars C and C++ compiler error messages in
alphabetical order, and what each message means.
Recognizing Compiler Error Messages
When the compiler encounters a line in source code that it does not
understand, it prints that line with a message. For example:
a= b;
^
file.c(15) Error: undefined identifier 'a'
The caret (^) does not indicate what causes a problem but where the
compiler recognizes a problem. If the caret points to a macro, try
compiling the file using the Show Results of Preprocessor (-e
command line option) to see which part of the macro is causing the
error.
The message under the caret starts with the name of the file, the line
number where the problem occurs, and whether the message is an
error or a warning. The rest of the message identifies what the
compiler considers as the problem.
Error Message Types
There are seven error message types. Each message usually contains
specific information about the problem.
Command line errors
Command line errors result from incorrect command line options or
parameters. For a quick way to find an online summary of command
line options and parameters, type sc from the DOS prompt.
Lexical errors
Lexical errors occur when the compiler encounters an unidentified
or incomplete token. While they do not immediately terminate
compilation, lexical errors do prevent the compiler from generating
executable code. An error log tracks lexical errors.
Preprocessor errors
Errors can occur in one of the preprocessing directives. While they
do not immediately terminate compilation, preprocessor errors can
prevent the compiler from generating executable code.
Syntax errors
While they do not immediately terminate compilation, syntax errors
can prevent the compiler from generating executable code. The
compiler normally lists four errors of the preprocessor, syntax,
lexical types before exiting. Use the -x option to let compilation
continue to the end of the source file before exiting with an error.
Warnings
Warnings occur when the compiler finds a statement that is
legitimate but probably not what you intended. Warnings are not
errors and do not terminate compilation or prevent the compiler
from generating code.
Fatal errors
Fatal errors immediately terminate compilation. A typical fatal error
occurs when the compiler runs out of memory.
Internal errors
Internal errors, a class of fatal error, take the following form:
file/line #
An assertion failure within the compiler generates this type of error.
The error number is useful only in designating where in the compiler
code the error occurs. The cause of this message may be an error in
source code that the compiler cannot handle intelligently or a bug in
the compiler itself. If your code generates this type of error, report it
to Digital Mars, even if your code causes the error. Reporting the
problem enables Digital Mars to improve error reporting in future
releases.
How to report an internal error
Before reporting an internal error to technical support, try to isolate
the error in a small program fragment. Use the following procedure:
- Place all included code into the main program body
using the -e -l options on the command line.
- Turn on the -v option for the compiler. This lets you
determine which function causes the problem.
- Find the approximate cause of the error by backtracking
and removing excess code to isolate a short program that
demonstrates the fault.
- Use mnemonic names for objects and variables in the
sample code. Code containing class Base rather than
class Hyperxytrisms59 is much easier for the
technical support staff to understand.
- If applicable, put the offending code in an
#ifdef BUG .. #endif block.
- Write a comment header with the following information:
your name, telephone number, address, version of
compiler and linker as well as any other software
involved, the nature of the problem, and any other
relevant details.
A short bug report lets the technical support staff quickly find the
problem.
C and C++ Compiler Error Messages
This is a list of error messages the compiler may generate.
Remember, only the C++ compiler generates messages marked C++
and only the C compiler generates messages marked C. Only the
Inline Assembler generates messages marked Inline Assembler.
'identifier' is a member of 'identifier' and 'identifier'
Inline Assembler. The member appears in more than one struct;
you need to specify which is correct.
'identifier' is a pure virtual function
C++. The compiler cannot directly call a pure virtual function.
'identifier' is already defined
The object is already declared.
'identifier' is a virtual base class of 'identifier'
C++. You cannot convert a pointer to a virtual base class into a
pointer to a class derived from it. Also, you cannot create a pointer
to a member of a virtual base class. For example:
class virtual_class
{ public:
int x;
};
class sub_class : virtual public virtual_class { };
void main()
{
virtual_class *v;
sub_class *s;
int virtual_class::*i;
s = (sub_class *) v; // error
i = &sub_class::x;
}
'identifier' is far
C++. A near reference cannot apply to far data.
'identifier' is not a class template
C++. The compiler expects to find the name of a class template but
doesn't find one. If you are declaring a template member function,
make sure the function's class name is a template. If you use a type
of the form foo< bar>, make sure you declare as a template the
class name before the less-than sign.
'identifier' is not a constructor
C++. You can use a member initialization list only when you're
defining base constructors and member initializers. For example:
struct base { base(int); };
struct other { other(int); };
class sub : base
{ sub(int); // A constructor.
sub2(int); // Just a method.
other o;
};
sub::sub(int a) : o(a), base(a) { }// OK
sub::sub2(int a): o(a), base(a) { }// ERROR
See ARM 12.6.2 for more information.
'identifier' is not a correct struct, union or enum tag identifier
The struct, union, or enum includes invalid characters or is
already defined.
'identifier' is not a member of enum 'identifier'
member identifier is not a member of this enum. Make sure to
correctly spell the member name and that the member actually
belongs to the enum with which you're using it.
'identifier' is not a member of struct 'identifier'
The member identifier is not a member of this class, struct or
union. Make sure to correctly spell the member name and that the
member actually belongs to the struct with which you're using it.
If the member is for a different struct but you want to use it with
this struct anyway, cast the struct. Also check for a class
member function that is forward referenced. For example:
class X; // Forward reference
class Y { // Declaration
void g();
/* . . . */
};
class Z {
friend void X::f(); // ERROR
friend void Y::g(); // OK
};
See ARM 11.4 for more information
'identifier' is not a member of forward referenced struct 'identifier'
You need to define a struct before referencing its members.
'identifier' is not a struct or a class
C++. You can derive new classes only from a class or a struct.
It is not possible, for instance, to derive a class from a union.
'identifier' is not in function parameter list
The parameter identifier is not listed as a parameter to the function
in the function definition.
'identifier' is not a variable
The identifier is not declared as a variable. Make sure you spell the
name correctly.
'identifier' must be a base class
C++. When naming a member of a base class in a derived class
declaration, qualify the member with a base class identifier. For
example:
class other;
class base
{
private: /* . . . */
};
class sub : base
{ public:
other::a; // ERROR: other must be a
/* ... */ // base class of sub.
};
'identifier' must be a class name preceding '::'
C++. The identifier before the double colon operator must be either
a class, a struct, or a union.
'identifier' must be a public base class of 'identifier'
C++. When you use the syntax p->class::member, class must be a
public base class member of the class to which p is referring. For
example:
class public_base
{ public:
int x;
};
class other_class
{ public:
int z;
};
class sub : public public_base
{ /* ... */
};
void main()
{
sub *s;
s->public_base::x = 1; // OK
s->other_class::z = 1; // ERROR
}
'identifier' previously declared as something else
You previously declared the identifier as another type. For example,
you may have used a function without declaring it, so the compiler
automatically declares it as a function returning an int. Now you
declare that function to be something else.
identifier storage class is illegal in this context
Check for one of the following:
- You declared a template outside the global scope.
- You declared a function argument static or extern.
- You used an auto or register variable with global
scope.
register int global; // ERROR: Can't declare global
// variable as register.
void f()
{
template<class T> T ave(T* a, int size)
{
// ERROR: Can't declare template // in a function.
}
/* ... */
}
See ARM 14.1 for more information.
number actual arguments expected for identifier, had number
Warning. The compiler expects a different number of arguments for
the function or template. You may be incorrectly using the function,
or you may be calling a function with a variable number of
arguments without including its header file.
number exceeds maximum of number parameters
The compiler does not support macros with more than 251
parameters.
number operands expected for the identifier instruction
Inline Assembler. The instruction includes an incorrect number of
operands.
':' expected
The compiler expects a colon after a constant expression in a case
statement and after the keywords public, private, and
protected in a class declaration.
'::' or '(' expected after class 'identifier'
C++. The compiler expects two colons or an open parenthesis after a
class name in an expression. Casting, however, does not allow two
colons. For example:
class x;
f= *(x*)y;
';' expected
The compiler expects a semicolon at the end of a statement.
',' expected
Make sure parameters are separated by commas.
']' expected
The compiler expects a close bracket at the end of an array
declaration or reference.
'(' expected
The compiler expects the expression after the if, while, or for
keywords to be enclosed in parentheses.
')' expected
The compiler expects a set of parentheses to be closed. Check for a
pair of mismatched parentheses or a bad expression.
'{' expected
The compiler expects an open brace.
'}' expected
The compiler expects a close brace.
'{' or tag identifier expected
The compiler expects a tag name or an open brace to follow the
keywords struct, class, union, and enum.
'=', ';' or ',' expected
A variable is declared incorrectly. A declaration, must include an
equals sign, a semicolon, or a comma after the variable name.
// comments are not ANSI C
C. The Enforce ANSI Compatibility option in the IDDE (the -A
command line option) is on, but the
program is using C++ style comments. C++-style comments begin
with two slashes.
## cannot appear at beginning or end
The double-number sign operator cannot appear at the beginning or
end of a list of tokens. The operator must be between two tokens.
For example, a ## b.
See ANSI 3.8.3.3 for more information.
# must be followed by a parameter
The number sign operator must appear only in front of a macro
parameter. For example, #c.
See ANSI 3.8.3.2 for more information.
'#else' or '#elif' found without '#if'
More #else or #elif preprocessor directives appear than
preceding #if, #ifdef, or #ifndef directives.
'#endif' found without '#if'
More #endif preprocessor directives appear than preceding #if,
#ifdef, or #ifndef directives.
#include <typeinfo.h> in order to use RTTI
To compile with run-time type identification, you need to include
the <typeinfo.h> header file.
#pragma pack(pop) does not have corresponding push
Every #pragma pack(pop) directive requires a corresponding
#pragma pack(push) directive.
'<' expected following cast
C++. A type id enclosed in angle brackets (<>) is expected following
static_cast, const_cast, reinterpret_cast, or
dynamic_cast.
See ARM 5.2 for more information.
'<' expected following 'identifier'
C++. In a class or function template, the argument list must be
between angle brackets.
See ARM 14.1 for more information.
'>' expected
A type id enclosed in angle brackets (<>) is expected following
static_cast, const_cast, reinterpret_cast, or
dynamic_cast.
See ARM 5.2 for more information.
0 expected
C++. A pure virtual function is declared incorrectly. The following is
the syntax for a pure virtual function:
class X
{ virtual pure_virtual_func() = 0; // OK
/* ... */
};
0 or 1 expected
Only binary digits can follow the characters 0b. No spaces should be
between the b and the number.
a '...' handler must be the last one for a try-block
C++. catch(...) must appear as the last catch in a list of catch
handlers for a try-block.
See ARM 15.3 for more information.
a catch must follow a try-block
C++. The syntax for a catch is:
try { statements } catch (exception-decl) { statements }
See ARM 15.1 for more information.
access declaration must be in public or protected section
C++. A class member's access can change only if that class member
is in a public or protected section. For example:
class base
{ int a;
public:
int x;
};
class sub : private base
{ base::a; // ERROR
public:
base::x; // OK: x is public
};
a derived class member has the same name identifier
C++. A base member's access cannot change when a derived class
defines a member with the same name. For example:
class base
{ public:
int x, y;
/* ... */
};
class sub : base
{ public:
void x();
base::x; // ERROR: same name as x()
base::y; // OK
};
See ARM 11.3 for more information.
alignment must be a power of 2
Alignment for structure members must be 1, 2, 4, 8, and so on.
alloca() cannot be used in Windows functions
The alloca() function requires the setup of a special stack frame.
That frame conflicts with the stack frames that Windows requires.
already seen initializer for 'identifier'
C++. Either more than one member-initializer for the identifier exists,
or more than one initializer for the base class exists. For example:
class base
{ int x;
base(int);
};
class sub : base
{ base b;
sub(int);
};
sub::sub(int a) :
base(a + 1), // OK
b(a * 2), // OK
base(a - 2) // ERROR
{
x = a;
}
ambiguous reference to base class 'identifier'
C++. This class has more than one base class, and it is not clear to
which the program is referring.
See ARM 11.3 for more information.
ambiguous reference to function
C++. In calling an overloaded function, more than one definition of
the function matches the call. For example:
struct X
{ X(int);
};
struct Y
{ Y(int);
};
void f(X); // f() can take an argument of
void f(Y); // either type X or type Y.
void main()
{
f(1); // ERROR: Ambiguous,
// f(X(1)) or f(Y(1))?
f(X(1)); // OK
f(Y(1)); // OK
}
ambiguous type conversion
C++. The compiler cannot find an unambiguous type conversion.
For example:
struct X
{ operator int();
operator void*();
};
void main()
{
X x;
if (x)
; // ERROR
if ((int) x)
; // OK
if ((void*) x)
; // OK
}
argument of type 'identifier' to copy constructor
C++. Copy constructors for class X cannot take an argument of type
X. Instead, use the reference to X.
See ARM 12.1 for more information.
argument to postfix ++ or --must be int
C++. Only declarations of the following form can declare overloaded
functions for the prefix and postfix operators ++ and --:
operator ++()
operator ++(int)
operator --()
operator --(int)
See ARM 13.4.7 for more information.
array dimension must be > 0
A negative number or zero cannot act as an array dimension when
declaring an array.
See ANSI 3.5.4.2 for more information.
array of functions is illegal
An array of pointers to functions, not an array of functions, can be
declared. For example, instead of this:
int (x[10])(); // ERROR: an array of functions
// returning int
use this:
int (*x[10])(); // OK: an array of pointers to
// functions returning int
array of functions or refs is illegal
C++. An array of pointers to functions, not an array of functions, can
be declared. For example, instead of this:
int (&x[10])(); // ERROR: an array of functions
// returning int
use this:
int (*x[10])(); // OK: an array of pointers to
// functions returning int
See ARM 8.4.3 for more information.
array or pointer required before '[ '
The brackets operator can only follow an array or pointer identifier.
assembler opcode expected
Inline Assembler. If the ASM keyword is being used, an assembler
opcode or a label should start each instruction.
assignment to 'this' is obsolete, use X::operator new/delete
Warning. C++. Avoid performing storage management by assigning
to this. Instead, overload the operators new and delete. Assigning
to this is not part of the latest definition of C++, and future compilers
may not support it.
at least one parameter must be a class or a class&
C++. An operator overloaded function that is not a class member
must have at least one parameter that is a class or class reference.
bad -D switch, identifier
The command line macro definition is invalid.
bad file name 'filename'
The filename is invalid.
bad member-initializer for 'identifier'
C++. A syntax error exists in the base class initializer for the class
identifier. For example:
struct base
{ base(int);
};
struct sub : base
{ sub(int);
int var;
};
sub::sub(int a) : base(a),, var(a) { } // ERROR: Extra comma
base class 'name' has different ambient memory model
C++. The base class name is declared as __far, and a subclass of
name is declared as __near, or visa versa. Change either
declaration to match the other.
The following code will cause this error:
class __far base { };
class __near sub : public base { };
binary exponent part required for hex floating constants
The exponent is missing from a hexadecimal floating-point constant.
A hexadecimal floating point constant comprises an optional sign,
the 0x prefix, a hexadecimal significand, the letter p to indicate the
start of the exponent, a binary exponent, and an optional type
specifier. These are valid hexadecimal floating-point constants:
0x1.FFFFFEp127f
0x1p-23
-0x1.2ACp+10
C++. A bit field cannot occur in an anonymous union. A named
union can have a bit field.
blank arguments are illegal
Arguments are missing from a macro reference that is defined to take
them. For example:
#define TWICE(x) (x + x)
TWICE(10) // OK
TWICE() // ERROR
'break' is valid only in a loop or switch
The break statement can occur only within a for, while,
switch, or do/ while statement.
can only delete pointers
C++. The delete operator works only on pointers. Use delete on
a pointer to an object and not the object itself.
can't assign to const variable
A new value is assigned to a const variable. Remove the
assignment or remove the restriction from the variable.
can't build filespec 'filename'
The named file cannot write to disk, probably because the disk is
full.
can't declare member of another class identifier
C++. In a class declaration, a class name modifies a member function
name. For example:
class X
{ void func_in_X();
};
class Y
{
void X::func_not_in_X(); // ERROR
int func_in_Y(); // OK
};
can't handle constructor in this context
C++. It is illegal to have a constructor as a default function
parameter. For example:
class X
{ public:
X(int);
};
void foo(X = X(1)); // ERROR: X(1) is a
// constructor.
can't have unnamed bit fields in unions
It is illegal to use an unnamed bit field in a union. Use a named bit
field or remove the bit field.
can't open response file
The compiler cannot open the response file specified on the
command line. Ensure that the file exists and that the correct path is
specified.
can't pass const/volatile object to non-const/volatile member function
C++. An object declared as const or volatile is trying to call a
member function that is not. Declare the member function const or
volatile, or remove the restriction from the object. For example:
struct A
{ int regular_func();
int const_func() const;
};
void main()
{
const A const_obj;
A regular_obj;
const_obj.regular_func(); // ERROR
const_obj.const_func(); // OK
regular_obj.const_func(); // OK
regular_obj.regular_func(); // OK
}
can't return arrays, functions or abstract classes
C++. A function cannot return an array, function, or abstract class.
However, a function can return a pointer to an array or a pointer to
a function. For example:
typedef char ARRAY[256];
ARRAY func_returning_array(); // ERROR
ARRAY *func_returning_ptr_to_array(); // OK
can't take address of register, bit field, constant or string
It is not possible to take the address of a register variable, a bit field
in a structure, a constant, or a string. Declare the object differently,
or avoid taking its address.
can't take sizeof bit field
It is illegal to use sizeof to determine the size of a bit field member
of a struct.
cannot convert identifier* to a private base class identifier*
C++. A pointer to a class X cannot convert to a pointer to a private
base class Y unless the current function is a member or a friend of
X.
class Y { }:
class X : Y;
void f(void)
{
class X *Px;
class Y *Py;
Py = (class Y *) Px;
cannot create instance of abstract class 'identifier'
C++. An abstract class contains at least one pure virtual function by
the declaration virtual func() = 0. It is illegal to declare objects
of such a class. For example:
class abstract_class
{ public:
virtual int func() = 0;
int x, y;
};
class subclass : abstract_class
{ public:
virtual int func()
{ return (x* 2); }
int a, b;
};
void main()
{
subclass a; // OK
abstract_class b; // ERROR
// ...
}
cannot define parameter as extern
Extern is an illegal storage class for a function parameter.
cannot delete pointer to const
C++. It is illegal to use the delete operator on a const pointer.
Remove the const casting, or remove the delete.
See ARM 8.5.3 for more information.
cannot find constructor for class matching
C++. The compiler cannot find a constructor that matches the current
initializers. Use different initializers. Coerce some initializers so that
they match those of a constructor, or define a new constructor. For
example:
struct X
{ X(char *);
};
void main()
{
X a = 1L; // ERROR
X b = 3.1e20; // ERROR
X c = "hello"; // OK
}
cannot generate identifier for class 'identifier'
C++. The compiler cannot define a copy constructor (X::X(X&))
for class X or an assignment operator (X& operator=(X&)) for
class X for the class. If a class needs these methods, explicitly
define them.
The compiler cannot define an assignment operator if one of these
conditions is true:
- The class has a const member or base.
- The class has a reference member.
- The class has a member that is an object of a class with a
private operator=().
- The class is derived from a class with a private
operator=().
The compiler cannot generate a copy constructor if one of these
conditions is true:
- The class has a member that is an object of a class with a
private copy constructor.
- The class is derived from a class with a private copy
constructor.
See ARM 12.1 and 12.8 for more information.
cannot generate template instance from -XI identifier
C++. The compiler cannot generate a template instance from the
specifier on the command line. Include the template definition in the
program and correctly spell the template instance.
cannot have member initializer for 'identifier'
C++. The constructor initializer can initialize only nonstatic members.
See ARM 8.12.6.2 for more information.
cannot implicitly convert
This expression requires the compiler to perform an illegal implicit
type conversion. To perform this conversion, explicitly cast the
expression.
cannot mix C++ EH with NT structured EH
C++. You need to use one scheme or the other; you cannot mix
them.
cannot raise or lower access to base member 'identifier'
C++. Access declarations in a derived class cannot grant or restrict
access to an otherwise accessible member of a base class. For
example:
class base
{ public:
int a;
private:
int b;
protected:
int c;
};
class sub : private base
{ public:
base::a; // OK
base::b; // ERROR: can't make b
// accessible
protected:
base::c; // OK
base::a; // ERROR: can't make a
}; // inaccessible
See ARM 11.3 for more information.
cannot throw object of 'identifier' not of ambient memory model
C++. You cannot throw near classes in large data models; likewise,
you cannot throw far classes in small data models.
case number was already used
This value already occurs as a case within the switch statement.
casts and sizeof are illegal in preprocessor expressions
An extension to ANSI C allows the use of the sizeof
operator and performs a cast in preprocessor directives. Turning on
the Enforce ANSI Compatibility option in the IDDE (the -A
command line option), disallows use of these expressions in a
preprocessor directive.
See ARM 15.3 for more information.
catch type masked by previous catch
C++. One of the following has occurred:
- The catch type appears more than once.
- A base class appears before a derived class.
- A pointer or reference to a base class appears before a
pointer or reference to a derived class.
class name identifier expected after ~
C++. A destructor is declared incorrectly. The proper name is
class::~class(). If the class is named X, its destructor is X::~X().
code segment too large
The size of the code segment exceeds 64K bytes.
comma not allowed in constant expression
It is illegal to use a comma in a constant expression or to separate
numbers by commas or spaces.
See ANSI 3.4 for more information.
comments do not nest
Warning. Avoid nesting comments; it's easy to nest incorrectly and
accidentally comment out the wrong code. Instead, use #if 0 and
#endif to block out sections of code. Avoid crossing existing #if.
For example, the following statements comment out the enclosed
code:
#if
....
#endif
compile all files with -EH to support exception handling
All code that handles exceptions must be compiled with -EH.
compile all files with -ER to support RTTI
To support run-time type identification, compile all files in the
project with -ER.
const or reference 'identifier' needs initializer
Nonextern consts or references must be initialized.
See ANSI 3.4 for more information.
constant expression does not fit in switch type
The value of a case is larger than the type of the switch expression.
This error occurs, for example, if a 100000 was assigned to a
short value.
constant initializer expected
When initializing a variable being declared, any nonpointer type
initializer must be either a constant or the address of a previously
declared static or extern item. For example:
const float pi = 3.1415;
float a = 3.0;
static float b;
float w = a * 2; // ERROR: a isn't const float
x = pi * pi; // OK: pi declared const
float *y = &a; // ERROR: a isn't static
float *z = &b; // OK: b is static
'continue' is valid only in a loop
A continue statement occurs out of context. Use it only within
for, while, and do/while statements.
conversion of int to far or handle pointer
In this expression, the compiler needs to convert an integer to a far
or handle pointer. This conversion probably means that a function
that is not declared as a function returns a pointer. The compiler
assumes the function returns an integer. For example:
float __far *f();
void main()
{
float __far *a, *b;
a = g(); // ERROR: g() not declared, so
// compiler assumes it returns
// int, not float *.
b = f(); // OK: f() declared as function
// returning float *
}
If the function is declared a function and the conversion is desired,
cast the integer to a long integer and then to a pointer, for example:
float far *ptr;
int f();
ptr = f();
float far * // EROR ptr = ()
f(); // OK
data or code defined in precompiled header
Precompiled headers can contain only declarations, not definitions.
declarator for 0 sized bit field
A bit field must have a size.
'default:' is already used
The default: statement appears more than once in a switch
statement.
different configuration for precompiled header
The precompiled header being used is precompiled with different
options. Precompile the header again with the current options or
check the current options for accuracy.
divide by 0
A constant expression tries to divide by zero or use modulo (%) of
zero.
duplicate direct base class 'identifier'
C++. When declaring a new class, the same class occurs more than
once in its list of direct base classes.
See ARM 10.1 for more information.
DS is not equal to DGROUP
Warning. You have used the -W (Windows target) compiler option
with the b modifier (assume DS != DGROUP), and a segment fixup
was made to DGROUP.
duplicate file names 'filename'
While compiling files, the compiler tries to open the same list
(.lst) or dump file (.dmp) in two places. It is illegal to refer to the
same file in both the command line and source code. It is also illegal
to use the same file for different outputs, such as .obj, .lst.
empty declaration
A declaration must declare at least a declarator, a tag, or the
members of an enumeration.
See ANSI 3.5 for more information.
end of file found before '#endif'
Missing #endif causes the compiler to reach the end of the file in
the middle of a conditional compilation statement list.
end of file found before end of comment, line number
A missing */ causes the compiler to reach the end of the file in the
middle of a comment.
end of line expected
Using the Enforce ANSI Compatibility option in the IDDE (the -A
command line option) does not allow any text to follow the #endif
keyword, unless the text is a comment. For example:
#ifdef DEBUG
printf("oops\n");
#endif DEBUG // Not ANSI-compatible
#ifdef DEBUG
printf("oops\n");
#endif // DEBUG
// ANSI-compatible
error writing output file
The compiler cannot write an output file, probably because the disk
is full.
exception specifications must match exactly for each declaration of a function
C++. For example:
void func() throw(int);
void func() throw(unsigned); // ERROR
See ARM 15.4 for more information.
expected assembler directive PTR to follow assembler cast
Inline Assembler. An assembler cast requires the word PTR. For
example:
unsigned long 1;
asm {
mov AX,word PTR ;OK
mov AX, word 1 ;ERR
}
expected data def of 'identifier', not func def
It is illegal to declare nested functions in C or C++. For example:
void f()
{
void g() { } // ERROR: Nested
} // function.
exponent expected
The compiler cannot find the exponent for the floating point number
written. Do not put any white space between the e and the
following exponent.
expression expected
The compiler expects to find an expression but cannot find one. A
semicolon or a close brace may cause this problem.
expression must be a pointer
C++. The expression:
dynamic_cast <type-name> (expression)
must be a pointer.
See ARM 5.2.6 for more information.
expression must be a pointer or reference to a polymorphic type
C++. This message indicates an invalid use of dynamic_cast. (A
polymorphic type is a class with at least one virtual function.)
See ARM 5.2.6 for more information.
external with block scope cannot have initializer
It is illegal to initialize a variable declared extern. Instead, initialize
the variable in the file where it is defined.
See ANSI 3.5.7 for more information.
'_far16' is only valid in -mf memory model
The _far16 type modifier is only valid when compiling for the
OS/2 2.0 (Flat) memory model.
'_far16' functions can only be extern
The compiler cannot generate code for a _far16 function body; it
can only call it.
field 'identifier' must be of integral type
An inappropriate type occurs for a member of a bit field structure.
Use signed/unsigned char, short, int, or long.
filespec string expected
The compiler cannot find the filename string in an #include
statement. Enclose the filename in double quotes or angle brackets.
__finally or __except expected
C++. For Structured Exception Handling, __finally or __except
must be part of the syntax for a __try block.
forward referenced class 'identifier' cannot be a base class
C++. A class must be declared before it can be used as a base class
for a new class. A forward declaration is not sufficient. For example:
class A; // Forward reference for A
class B { // Declaration of B
int a, b, c;
void f();
};
class X : A { /*...*/ };// ERROR: A isn't
// declared
class Y : B { /*...*/ };// OK: B is
// declared
function 'identifier' can't be in an anonymous union
C++. An anonymous union cannot have function members.
See ARM 9.6 for more information.
function member 'identifier' has no prototype
The compiler cannot find a function prototype for this function. The
C++ compiler requires function prototypes by default. With C, this
message occurs only when the -r option is selected.
function 'identifier' is too complicated to inline
Warning. A function declared as inline is too complex to compile
inline, so the compiler compiles it as a normal function.
function definition must have explicit parameter list
A function definition requires an explicit parameter list. It cannot
inherit a parameter list from a typedef. For example, this definition
does not compile:
typedef int functype(int q, int r);
functype funky // ERROR: No explicit
{ // parameter list
return q + r;
}
See ANSI 3.7.1 for more information.
function expected
The compiler expects to find a function declaration but does not.
Check for mismatched braces, parentheses not preceded by a
function name, or a template declaration not followed by a class or
function declaration.
functions can't return arrays or functions
C. A function cannot return an array or a function. However, a
function can return a pointer to an array or a pointer to a function.
For example:
typedef char ARRAY[256];
ARRAY func_returning_array(); // ERROR
ARRAY *func_returning_ptr_to_array(); // OK
GetExceptionCode() only valid in exception filter or handler
C++. GetExceptionCode() is part of Structured Exception
Handling.
GetExceptionInformation() only valid in exception filter
C++. GetExceptionInformation() is part of Structured
Exception Handling.
global anonymous unions must be static
C++. Anonymous unions must be extern or static.
See ARM 9.5 for more information.
hex digit expected
The compiler expects to find a hexadecimal digit after the characters
0x. Do not put any white space after the x.
identifier expected
The compiler expects to find an identifier, but finds instead another
token.
identifier found in abstract declarator
A type in a sizeof expression, typedef statement, or similar
place incorrectly includes a variable name. For example:
x = sizeof(int a[3]); // ERROR: a is a variable
// name.
x = sizeof(int[3]); // OK
identifier is longer than 254 chars
The maximum size of an identifier is 254 characters.
identifier or '(declarator) ' expected
The compiler expects to find a declaration for a static variable, an
external variable, or a function. If this error appears in a function,
check to see if there are more left braces than right braces.
illegal addressing mode
Inline Assembler. An illegal operand, such as [ah], appears.
illegal cast
It is illegal to cast an object to an inappropriate type. For example,
structs or unions cannot cast to other types but can cast
numerical values and pointers.
illegal character, ascii number decimal
The source file includes a character, such as @ or $, that is not part
of the C character set outside a comment or a string.
illegal combination of types
Certain types cannot occur together. For example, you cannot:
- Use near and far in the same declaration.
- Use a modifier on a reference.
- Use pascal on a pointer.
- Have a stack pointer to a function.
- Declare a variable to be a short long int.
illegal constuctor or destructor declaration
C++. A constructor or destructor is incorrectly declared. For example,
a constructor may be declared as virtual or friend, a destructor
may be declared as friend, or a return value may be specified for a
constructor or destructor.
illegal operand
Inline Assembler. The inline assembler cannot evaluate an
expression, such as when adding two vars:
dec a + b
Inline assembler operands must be representable in one instruction.
illegal operand types
The operands are of the wrong type, casting the operands to a
different type.
illegal pointer arithmetic
The only legal operations on pointers are adding or subtracting an
integer from a pointer; subtracting a pointer from another pointer;
and comparing two pointers with <, >, ==, <=, or >=.
illegal return type for operator->()
C++. operator->() must return one of these:
- A pointer to an object of the class that defines
operator->()
- A pointer to an object of another class that defines
operator->()
- A reference to an object of another class that defines
operator->()
- An object of another class that defines operator->()
See ARM 13.4.6 for more information.
illegal type combination, possible missing ';' after struct
You may have omitted a semicolon (;) after a struct declaration.
illegal type for 'identifier' member
Variables cannot be of type void.
struct X
{ void var; // ERROR
};
illegal type/size of operands for the identifier instruction
Inline Assembler Warning. An operand for an instruction is specified
as the wrong size. This can be a warning or an error. The following
example generates an error; it is illegal because the PUSH instruction
does not allow for an 8-bit operand:
char c;
__asm push c;
On the other hand, this is a warning:
mov AX, c
It moves 16 bits from c.
This can also happen for the following FPU instruction format,
which is accepted by other compilers:
fmul st(0)
Rewrite it as:
fmul st, st(0)
implied return at closing '}' does not return value
Warning. A function is declared to return a value, but it returns
without specifying one.
initialization of 'identifier' is skipped
A goto or case statement has resulted in an explicit or implicit
initialization of a variable being skipped.
See ARM 6.7 for more information.
initializer for static member must be outside of class def
C++. Static class members must initialize outside the class definition.
For example:
class A
{ static int a = 5; // ERROR: Can't initialize static
// class var in class def.
void f();
};
class B
{ static int b;
void f();
};
int B::b = 6; // OK: Initialize static class var
// outside class def.
See ARM 9.4 for more information.
initializer or function body for dllimport not allowed
Functions or data objects you declare with the dllimport attribute
must be extern declarations.
integer constant expression expected
An integer constant expression must occur in case statements; array
size declarations; and the #if, #elif, #exit, and #line
preprocessor commands.
integral expression expected
An integer type must occur in case statements; in array size
declarations; and the #if, #elif, #exit, and #line preprocessor
commands.
internal error identifier number
A compiler error has occurred. Please report this error to Digital Mars.
invalid instruction set 'set' for memory model 'model'
You have specified a 16-bit instruction set for a 32-bit memory
model.
invalid reference initialization
C++. It is illegal to use invalid reference initialization errors, which
result from trying to initialize:
- A volatile reference to a const.
- A const reference to a volatile.
- A plain reference to a const or volatile.
See ARM 8.4.3 for more information.
invalid storage class for friend
C++. Friend functions cannot be virtual.
keyword not supported
Digital Mars C/C++ recognizes but does not support the keyword. Use
the int_xxx routines in the function library instead of the
__interrupt keyword. This is the only instance of this message.
last line in file had no \n
Compiling with the Enforce ANSI Compatibility option in the
IDDE (the -A command line option) on means that the last line of a
source file must end with a newline character. A backslash cannot
precede the newline.
__leave must be within a __try block
C++. For Structured Exception Handling, __leave must be part of
the syntax for a __try block.
line number expected
The line number in the #line directive must be a constant
expression.
linkage specs are "C", "C++", and "Pascal", not "identifier"
C++. The compiler supports only the C++, C, and Pascal linkage
types.
local class cannot have static data member 'identifier'
C++. A local class (that is, a class declared within a function) cannot
have a static data member. For example:
void f()
{
class local_class
{ int a, b;
static int c; // ERROR: Can't have void g();
// static var in
} l1, l2; // local class
// ...
}
See ARM 9.4 for more information.
long long not supported for ANSI or 16 bit compiles
64-bit ints are only supported for 32-bit memory models. The long
long data type is not an ANSI standard data type.
lvalue expected
The compiler expects to assign a value to an expression, such as a
variable. For example:
short short_f(void);
short *pshort_f(void);
void function(void)
{
short i;
short *p = &i; // Operand of ++ must be an lvalue
7++; // NO
short_f()++; // NO
pshort_f()++; // NO
// Left operand of an assignment
// must be an lvalue.
A, B = i; // NO
pshort_f() = i; // NO
*pshort_f() = i; // OK: Produces an lvalue
(*p)++; // OK
(*pshort_f())++; // OK
}
main(), WinMain(), or LibMain() cannot be static or inline
C++. It is illegal to declare any of the functions main(),
WinMain(), or LibMain() as static or inline.
See ARM 3.4 for more information.
maximum width of number bits exceeded
This field can contain number bits. For example:
struct X
{ char x:9; // ERROR: char is 8 bits
short y:17; // ERROR: short is 16 bits
long z:33; // ERROR: long is 32 bits
};
macro 'identifier' can't be #undef'd or #define'd
It is illegal to redefine or undefine this predefined macro. To
suppress non-ANSI predefined macros, set the Suppress
Predefined Macros option in the IDDE (the -u command line
option).
See ANSI 3.8.8 for more information.
malformed template declaration
C++. A template class or function is declared incorrectly. The
following are correct declarations:
template<class T, int x> // OK
class vector
{
T v[x];
public:
vector();
T& operator[](int);
/* ... */
};
template<class T> // OK
T ave(T x, T y)
{
return ((T)((x + y) / 2));
}
See ARM 14 for more information.
maximum length of macro text exceeded
The maximum length of a macro replacement text string has been
exceeded.
max of number characters in string exceeded
This string can contain number characters.
member 'identifier' can't be same type as struct 'identifier'
A member of a structure with type identifier cannot itself have type
identifier.
member 'identifier' is const but there is no constructor
C++. If a class has a const member, the class must also have a
constructor. Initialize a const variable only in the constructor, for
example:
class A
{ // ERROR: no constructor
const int x; // to initialize x
int y, z;
void f();
};
class B
{ const int x;
int y, z;
void f();
B(); // OK: x can be
}; // initialized.
member 'identifier' of class 'identifier' is not accessible
C++. A class member that is private or protected cannot be accessed.
member 'identifier' of class 'identifier' is private
C++. Only a class function or a derived function of the class can use
a private member. For example:
class super
{ private:
int x;
int f();
};
class sub : super
{
int g();
};
int super::f()
{
return (x++); // OK: B::f() is a
} // member function
int sub::g()
{
return (x++); // ERROR: sub::g() is a
} // member function
// of a derived class
void main()
{
super s;
s.x = 3; // ERROR: main() isn't a
return 0; // member function
} // or a friend
// function
missing ', ' between declaration of 'identifier' and 'identifier'
You probably wrote something like:
int x y;
where x was to be a macro.
missing decl-specifier-seq for declaration of 'identifier'
You can only omit the decl-specifier-seq (the storage class followed
by the declaration's type) in function definitions and function
declarations.
See ARM 7 for more information.
must be void operator delete(void *[, size_t]);
C++. The improper prototype occurs when the delete operator for
a class that uses the C++ model is overloaded. The prototype for an
operator delete overload must be either:
void operator delete(void *); // OK
or
void operator delete(void *, size_t);// OK
must use delete[] for arrays
C++. To delete an array a, use this statement:
delete[] a; // OK
and not
delete a; // ERROR
See ARM 5.3.4 for more information.
need at least one external def
There must be at least one global symbol defined.
See ANSI 3.7 for more information.
no constructor allowed for class 'identifier'
C++. The class includes a variable with the same name as the class.
This prevents the use of a constructor that must have that name.
no definition for static 'identifier'
A static is referred to, but no definition is provided. For example:
static void f();
void g() { f(); }
See ANSI 3.7 for more information.
no identifier for declarator
An identifier is missing from this declaration. For example:
void f(char [3]) // ERROR: No identifier
{
// ...
}
int [3]; // ERROR: No identifier
int a[3]; // OK: Identifier is a
no input file specified
This command line must include an input file.
no instance of class 'identifier'
C++. It is illegal to attempt the following:
- Call a nonstatic member function without using an
instance of the class.
- Access a nonstatic data member without using an instance
of the class.
- Define a nonstatic data member outside a class.
However, it is legal to attempt the following:
- Call a static member function without an object.
- Access a static data member without an object.
- Define a static data member outside a class.
For example:
struct CLASS
{
static void static_func();
void nonstatic_func();
static int static_data;
int nonstatic_data;
};
int CLASS::nonstatic_data = 1; // ERROR
int CLASS::static_data = 1; // OK
void main()
{
CLASS object;
int i = CLASS::nonstatic_data; // ERROR
int j = object.nonstatic_data; // OK
CLASS::nonstatic_func(); // ERROR
CLASS::static_func(); // OK
object.nonstatic_func(); // OK
}
no instance of class 'identifier' for member 'identifier'
C++. You attempted to reference a member of a class without a
this pointer being available.
no match for function 'identifier'
C++. The function is overloaded, and the compiler cannot find a
function that matches the call.
no return value for function 'identifier'
A function has a return type other than void, but it has no return
statement or has a path by which it doesn't return. For example:
int f()
{
if (x)
return;
}
See ARM 6.6.3 for more information.
no tag name for struct or enum
Warning. If a struct or an enum does not have a tag name, further
objects of this type cannot be declared later in the program. Give
every struct and enum a tag name so that the compiler's type-safe
linkage system can use it.
non-const reference initialized to temporary
Warning. In most cases, this message means that a temporary
occurs and the warning initializes the reference to that temporary.
Since the reference is not const, the referenced temporary may
change its value.
However, this message becomes an error when the Enforce ANSI
Compatibility option in the IDDE (the -A command line option) is
set.
See ARM 8.4.3 for more information.
not a struct or union type
The type of object preceding the object member operator selector
(.) or the pointer to object selection (operator ->) is not a class,
a struct, or a union.
not an overloadable operator token
C++. You cannot overload these operators:
. .* :: ?: sizeof # ##
not in a switch statement
It is illegal to use a case or default statement outside a switch
statement.
number 'number' is too large
The number is too large to be represented in an object with long
type.
number is not representable
The compiler cannot represent a numeric constant because of the
constraints listed in the following table:
You cannot represent… If it is…
Integer greater than ULONG_MAX (in limits.h)
Floating point number less than DBL_MIN or greater than DBL_MAX
(in float.h)
Enumeration constant greater than INT_MAX
(in limits.h)
Octal character constant greater than 255
object has 0 size
The compiler does not allow objects of zero size. Trying to subtract
two pointers that point to zero size objects causes division by zero.
octal digit expected
The compiler expects that a number with a leading 0 is an octal
digit. Using an 8 or 9 is illegal.
one argument req'd for member initializer for 'identifier'
C++. Member initializers in which the member lacks a constructor
must have exactly one parameter because the member is initialized
by assignment.
only classes and functions can be friends
C++. It is legal to declare other classes or functions friend only
when declaring a function within a class.
only one identifier is allowed to appear in a declaration appearing in a conditional expression
C++. Pointers and references to references are invalid.
operator functions ->() and [] must be non-static members
C++. It is illegal to declare as static these operators:
- The pointer to object selection operator (->)
- The function call operator (())
- The array operator ([])
operator overload must be a function
C++. It is illegal to declare an overloadable operator as a variable.
For example:
struct X
{ int operator<<; // ERROR
};
out of memory
The compiler is out of memory. Try the following:
- Break the file or function into smaller units.
- If the error occurs while optimizing a function, turn off
optimization for that function.
- Use a DOS-extended version of the compiler, if
applicable.
overloaded function 'identifier' has different access levels
C++. It is illegal to adjust the access of an overloaded function that
has different access levels. For example:
class base
{
public:
void f(int);
private:
void f(float);
};
class sub : base
{ base::f; // ERROR: f() is
}; // overloaded.
See ARM 11.3 for more information.
parameter list is out of context
Parameters in a function definition are illegal and are discarded. For
example:
int f(a, b); // ERROR
int g(int, int); // OK
int h(int a, int b); // OK
parameter lists do not match for template 'identifier'
C++. The parameter list for the template instantiation does not match
the formal parameter list for the class definition.
template<class T, int size> class vector;
template< class T, unsigned size> class
vector; // no {}
vector<int, 20> x; // OK
vector<float, 3.0> // ERROR: 3.0 is not an int.
pascal string length number is longer than 255
This __pascal string's length exceeds 255 characters.
pointer required before '->', '->*' or after '*'
C++. These operators can apply only to pointers. The operators ->
and ->* must precede the pointer, and the operator * must follow
it.
pointer required before '->' or after '*'
C. These operators can apply to pointers only. The operator ->must
precede the pointer, and the operator * must follow it.
pointer to member expected to right of .* or ->*
C++. The identifier after . or ->* must be a pointer to a member of
a class or struct.
possible extraneous ';'
Warning. The compiler finds a semicolon immediately after an if,
switch, or while statement and executes the next statement,
regardless of whether the test evaluates to true or false. For example:
int x = 1, y = 0;
if (x== y); // WARNING: Extra
printf("x == y\n"); // semicolon.
printf(); // always executed.
if (x == y) // OK
printf("x == y\n");
If a semicolon is desired, suppress the warning by putting white
space, such as a space or a return, between the close parenthesis
and the semicolon.
while (fread(file) == unwanted_data)
; // OK: semicolon is intentional
possible unintended assignment
Warning. The assignment operator (=) instead of the equality
operator (==) appears in the test condition of an if or while
statement. For example:
if (x = y) {...} // WARNING: x= y is an assignment
instead of
if (x == y) {...} // OK: x == y is a test
Test the value of the assignment explicitly, like this:
if ((x = y) != 0) {...} // OK: (x = y) != 0 is a test
The compiler produces identical code for the first and third
examples.
pragma cseg must be at global scope
A #pragma cseg statement must occur in the global scope and not
within a function body or type definition.
precompiled header compiled with C instead of C++
C++. You have included a C precompiled header in a C++
compilation.
precompiled header compiled with C++ instead of C
C. You have included a C++ precompiled header in a C compilation.
prefix opcode must be followed by an assembler opcode
The opcode must immediately follow the LOCK, REP, REPE, REPNE,
or REPZ instruction prefixes.
premature end of source file
A string that is missing a closing quote or a comment that is missing
a */ causes the compiler to reach the end of the file while
processing a function.
prototype for 'identifier' should be identifier
A function of the form: func(s) short s; { ... } should be
prototyped as:
func(int s);
rather than:
func(short s);
See ANSI 3.5.4.3 for more information.
pure function must be virtual
C++. Pure member functions must be declared as virtual, like this:
class B
{ virtual void f() = 0; // OK
void g() = 0; // ERROR
};
qualifier or type in access declaration
C++. It is illegal to specify a storage class or type when adjusting the
access to a member of a base class. For example:
class base
{ public:
int b, c, d;
int bf();
};
class sub : private base
{ int e;
public:
base::b; // OK
int base::c; // ERROR
static base::d; // ERROR
};
See ARM 11.3 for more information.
recursive prototype, turn off autoprototyping
Use the -p compiler option (see Chapter 2) to turn off
autoprototyping.
redefinition of default parameter
C++. It is illegal to redefine the default argument for a parameter
even if redefined to the same value. For example:
// Prototyping the function.
int f(int, int = 0);
// Defining the function.
int f(int a, int b = 0) // ERROR: Can't
{ // redefine default
return g(a, b); // argument, even to
} // the same value.
The line given for the error is sometimes past the closing brace of
the body of the function.
reference to 'identifier' caused a 386 instruction to be generated
Inline Assembler Warning. This warning occurs when not using 32-
bit compilation when a reference to a variable causes a 32-bit mode
instruction to generate, such as:
unsigned long UL;
ASM {
INC UL // incrementing a long is 32 bit
}
reference must refer to same type or be const
When initializing a reference, the object being used as an initializer
must be of the same type as the reference, or it must have const
type.
return type cannot be specified for conversion function
C++. It is illegal to specify the return type of a conversion function.
For example:
class X
{ char* operator char* (); // ERROR
operator char* (); // OK
};
See ARM 12.3.2 for more information.
returning address of automatic 'identifier'
Warning. This results in an invalid pointer beyond the end of the
stack. When the function returns, the caller receives an illegal
address that can cause a general protection fault.
segment size is number, exceeding 64KB
Code and data for 16-bit compilations are output into 64KB
segments, one of which exceeds 64KB. This can happen when
declaring objects whose combination is larger than 64KB. For
example: int a[50000]. Divide the source module into smaller
pieces, or switch to a 32-bit memory model.
should be number parameter(s) for operator
C++. The incorrect number of arguments appears in a declaration of
an overloaded operator. The function call operator () is n-ary; it can
take any number of arguments.
size of identifier is not known
It is illegal to use a struct or an array with an undefined size. For
example:
struct x
{ int a[]; // ERROR
/* ... */
};
struct y
{ int a[100]; // OK
/* ... */
};
size of type exceeds 64KB
Data objects in 16-bit memory models cannot exceed 64KB unless
declared with the _huge modifier.
statement expected
The compiler expects a statement but does not encounter one. A
missing comma or semicolon or a label without a statement can
cause this error. For example:
while (TRUE)
{ // ...
if (done)
goto end1;
// ...
end1:
} // ERROR: No statement after
// label.
while (TRUE)
{ // ...
if (done)
goto end2;
// ...
end2: ; // OK: Null statement after label.
}
static function 'identifier' can't be virtual
You cannot mix static and virtual storage classes for member
functions. (Note that the operators new() and delete() are static.)
static or non-member functions can't be const or volatile
C++. It is illegal to declare a static class member function or a
nonmember class function as const or volatile.
static variables in inline functions not allowed
C++. It is illegal to declare a static variable within an inline function.
storage class for 'identifier' can't be both extern and inline
C++. It is illegal to use the inline type specifier for a function
declared external.
string expected
The compiler expects to encounter a string but cannot find one.
Check for an #ident directive not followed by a string.
struct-declaration-list can't be empty
C. A struct must contain at least one member.
See ANSI 3.5.2.1 for more information.
template-argument 'identifier' must be a type-argument
C++. In a function template, all template arguments must be type
arguments. Unlike class templates, function templates cannot have
expression arguments. For example:
template <class T, int x> foo(T y)
// ERROR: x is an expression argument.
{ return x + y;
}
See ARM 14.4 for more information.
template-argument 'identifier' not used in function parameter types
C++. When defining a template, every template argument in the
template's argument list must appear in the function's argument list.
For example:
template <class T1, class T2>
int bar(T1 x) // ERROR: T2 isn't in
{ // function's
T2 y; // argument list.
// ...
}
See ARM 14.4 for more information.
too many errors
The compiler has reached its limit of four errors. For the compiler to
continue past its limit, set the Turn Off Error Maximum option in
the Compiler Output dialog box in the IDDE (the -x command
line option).
too many initializers
The item contains too many initializers. For example:
char a[3]="hello"; // ERROR
char b[3]="hi!"; // ERROR: No room for
// null character
char c[3]="hi"; // OK
trailing parameters must have initializers
C++. Parameters with default initializers must occur at the end of a
parameter list. For example:
int f(int, int= 1, int = 0); // OK
int g(int = 0, int = 1, int); // ERROR
int h(int = 0, int, int = 1); // ERROR
__try only valid for -mn memory model
Code that uses the __try modifier must be compiled for the
Windows NT memory model.
type conversions must be members
C++. It is illegal to declare a type conversion function outside a class.
Declare it inside a class.
type is too complex
C++. The compiler appends information regarding parameter and
return types to the end of a function name. With this information
added, the identifier exceeds the compiler's maximum of 254
characters.
type mismatch
This error is either a syntax error or a warning message. The
compiler expects to find one data type but finds another. More
information about which types it expects and what it finds follows
this message.
type must be a pointer or a reference to a defined class or void*
This message refers to the type specified in a dynamic_cast.
type must be void *operator new(size_t [,..]);
C++. The wrong prototype appears when the new operator for a
class that uses the C++ model is overloaded. When operator new is
overloaded, it must have a return type of void * and take a first
argument of size_t. The compiler automatically sets the value of
the first argument to be the class size in bytes.
See ARM 5.2.6 for more information.
type of 'identifier' does not match function prototype
The arguments of the function do not match the prototype
previously given.
types may not appear more than once in an exception specification
It is illegal to write an exception specification like:
void func() throw(int, int);
See ARM 15.4 for more information.
unable to open input file 'filename'
The compiler cannot find the file. Correctly spell the name and
specify the correct folder.
unable to open output file 'filename'
The compiler cannot open the file. Specify a valid file name and
make sure there is enough disk space.
undefined escape sequence
The compiler recognizes only the following escape sequences in a
string or character constant:
undefined identifier 'identifier'
It is illegal to use an identifier without declaring it. Correctly spell the
identifier.
undefined label 'identifier'
The goto command to go to a label must be defined. Correctly spell
the label and make sure the label appears in the same function as
the goto.
undefined tag 'identifier'
The structure or union is not defined.
undefined use of struct or union
It is illegal to use operators, such as arithmetic or comparison
operators, that do not apply to structs, classes, or unions.
Table 29-1 Defined escape sequences
This sequence… Represents…
\' single quote
\" double quote
\? question mark
\\ backslash
\a alert (bell)
\b backspace
\f form feed
\n newline
\r return
\t tab
\v vertical tab
\xXXX the character specified with the hexadecimal
number
\000 the character with the octal number
unknown operand type for this floating point instruction
Inline Assembler. It is illegal to enter an inappropriate operand, such
as a numeric constant, on a floating point instruction. For example:
fdiv 0x50
union members cannot have ctors or dtors
C++. A union cannot contain a member that is an object of a class
with a constructor or a destructor.
unrecognized pragma
Warning. The compiler does not recognize this #pragma directive.
See Chapter 3, "Digital Mars C++ Language Implementation" for a list of
valid pragmas.
unrecognized parameter 'identifier'
The compiler does not recognize a parameter or option on the
command line. Command line options are case sensitive.
unrecognized preprocessing directive '#identifier'
The compiler does not support the specified preprocessor directive.
unrecognized token
The compiler does not recognize the token as valid. Check for an
extra U or L suffix in an integer constant. It is illegal to use $ and @
in identifiers.
unsupported based type
C++. Valid based types are:
__based(__segname("_DATA")) => __near
__based(__segname("_STACK")) => __ss
__based(__segname("_CODE")) => __cs
unsupported __declspec type
Supported __declspec types are:
declspec(dllimport)
declspec(dllexport)
declspec(naked)
declspec(thread)
unterminated macro argument
A macro argument is missing a close quote or parenthesis.
unterminated string
A string is missing a close quote, or a file contains a lone quote
mark. The compiler found end of line or end of file before the string
terminator.
See ANSI 3.1.3.4 for more information.
use delete[] rather than delete[expr], expr ignored
Warning. C++. This syntax for deleting an array of objects is
outdated, although the current version of the compiler supports it
and ignores expr:
delete [expr] p; // WARNING: obsolete
New code uses this syntax instead:
delete [] p; // OK
using operator++() (or --) instead of missing operator++(int)
Warning. C++. It is illegal to use the postfix increment (or
decrement) operator on an object of a class, such as x++, without
overloading the postfix operator for that class. However, the prefix
operator is overloaded. The compiler uses the prefix version of the
operator.
To overload the postfix increment operator x++, use
operator++(). To overload the prefix increment operator ++ x,
use operator++(int).
valid memory models are -m[tsmcrzlvfnpx]
This command line error indicates that the options for memory
model selection are incorrect.
value of expression is not used
Warning. It is illegal to compute an expression without using its
value, such as the equality operator (==) instead of the assignment
operator (=). For example:
x == y; // WARNING: The value of x
// doesn't change.
x = y; // OK: x and y have same value.
Failure to assign the result of a computation to a variable can also
cause this error. For example:
t - 5; // WARNING: Result of this
// computation is lost.
x = t - 5; // OK: x contains the result.
t -= 5; // OK: t contains the result.
variable 'identifier' used before set
Warning. The optimizer discovers that a specified variable appears
before it is initialized. The program may generate inexplicable
results.
vectors cannot have initializers
C++. It is illegal to initialize a vector of objects with a constructor that
has an argument list.
very large automatic
Warning. Large automatic variables can cause stack overflow.
Dynamically allocate the memory with a function such as
malloc().
voids have no value
C. It is illegal to return a value from a function declared void or to
use the value of a function declared void.
voids have no value, ctors and dtors have no return value
C++. It is illegal to return a value from a constructor, destructor, or
function declared void or a reference to a void. It is also illegal to
use the value of a constructor, destructor, or function declared void.
'while' expected
The keyword while is missing from the end of a do/while loop.
For example:
do
{
x = f(y);
} (x != 0); // ERROR: missing while.
do
{
x = f(y);
} while (x != 0); // OK
Copyright © 1995-2001 Digital Mars. All Rights Reserved.