Compiler Error Messages

• 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 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

	a= b;
	^ 
	file.c(15) Error: undefined identifier 'a' 

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

Command line errors

Lexical errors

Preprocessor errors

Syntax errors

Warnings

Fatal errors

Internal errors

	file/line # 

How to report an internal error

1. Place all included code into the main program body using the -e -l options on the command line.
2. Turn on the -v option for the compiler. This lets you determine which function causes the problem.
3. Find the approximate cause of the error by backtracking and removing excess code to isolate a short program that demonstrates the fault.
4. 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.
5. If applicable, put the offending code in an #ifdef BUG .. #endif block.
6. 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.

C and C++ Compiler Error Messages

'identifier' is a member of 'identifier' and 'identifier'

'identifier' is a pure virtual function

'identifier' is already defined

'identifier' is a virtual base class of 'identifier'

	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

'identifier' is not a class template

'identifier' is not a constructor

	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 

'identifier' is not a correct struct, union or enum tag identifier

'identifier' is not a member of enum 'identifier'

'identifier' is not a member of struct 'identifier'

	class X; // Forward reference
	class Y { // Declaration 
	    void g();
	    /* . . . */ 
	}; 
	class Z {
	    friend void X::f();	// ERROR 
	    friend void Y::g();	// OK
	}; 

'identifier' is not a member of forward referenced struct 'identifier'

'identifier' is not a struct or a class

'identifier' is not in function parameter list

'identifier' is not a variable

'identifier' must be a base class

	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 '::'

'identifier' must be a public base class of 'identifier'

	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

identifier storage class is illegal in this context

• 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. 
	    }
	    /* ... */ 
	} 

number actual arguments expected for identifier, had number

number exceeds maximum of number parameters

number operands expected for the identifier instruction

':' expected

'::' or '(' expected after class 'identifier'

	class x;
	f= *(x*)y; 

';' expected

',' expected

']' expected

'(' expected

')' expected

'{' expected

'}' expected

'{' or tag identifier expected

'=', ';' or ',' expected

// comments are not ANSI C

## cannot appear at beginning or end

See ANSI 3.8.3.3 for more information.

# must be followed by a parameter

See ANSI 3.8.3.2 for more information.

'#else' or '#elif' found without '#if'

'#endif' found without '#if'

#include <typeinfo.h> in order to use RTTI

#pragma pack(pop) does not have corresponding push

'<' expected following cast

See ARM 5.2 for more information.

'<' expected following 'identifier'

See ARM 14.1 for more information.

'>' expected

See ARM 5.2 for more information.

0 expected

	class X
	{   virtual pure_virtual_func() = 0; // OK 
	    /* ... */
	}; 

0 or 1 expected

a '...' handler must be the last one for a try-block

See ARM 15.3 for more information.

a catch must follow a try-block

	try { statements } catch (exception-decl) { statements } 

access declaration must be in public or protected section

	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

	class base
	{ public: 
	    int x, y;
	    /* ... */ 
	}; 

	class sub : base
	{ public: 
	  void x();
	  base::x; // ERROR: same name as x() 
	  base::y; // OK
	}; 

alignment must be a power of 2

alloca() cannot be used in Windows functions

already seen initializer for 'identifier'

	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'

See ARM 11.3 for more information.

ambiguous reference to function

	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

	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

See ARM 12.1 for more information.

argument to postfix ++ or --must be int

	operator ++()
	operator ++(int) 
	operator --()
	operator --(int) 

array dimension must be > 0

See ANSI 3.5.4.2 for more information.

array of functions is illegal

	int (x[10])();	// ERROR: an array of functions 

	int (*x[10])();	// OK: an array of pointers to 
			// functions returning int 

array of functions or refs is illegal

	int (&x[10])();	// ERROR: an array of functions 
			// returning int 

	int (*x[10])();	// OK: an array of pointers to 
			// functions returning int 

array or pointer required before '[ '

assembler opcode expected

assignment to 'this' is obsolete, use X::operator new/delete

at least one parameter must be a class or a class&

bad -D switch, identifier

bad file name 'filename'

bad member-initializer for 'identifier'

	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

The following code will cause this error:

	class __far base { }; 

	class __near sub : public base { }; 

binary exponent part required for hex floating constants

	0x1.FFFFFEp127f
	0x1p-23 
	-0x1.2ACp+10 

blank arguments are illegal

	#define TWICE(x) (x + x) 
	TWICE(10) // OK
	TWICE() // ERROR 

'break' is valid only in a loop or switch

can only delete pointers

can't assign to const variable

can't build filespec 'filename'

can't declare member of another class identifier

	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

	class X
	{ public: 
	    X(int);
	}; 

	void foo(X = X(1));	// ERROR: X(1) is a
				// constructor. 

can't have unnamed bit fields in unions

can't open response file

can't pass const/volatile object to non-const/volatile member function

	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

	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

can't take sizeof bit field

cannot convert identifier* to a private base class identifier*

	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'

	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

cannot delete pointer to const

See ARM 8.5.3 for more information.

cannot find constructor for class matching

	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'

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 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.

cannot generate template instance from -XI identifier

cannot have member initializer for 'identifier'

cannot implicitly convert

cannot mix C++ EH with NT structured EH

cannot raise or lower access to base member 'identifier'

	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 

cannot throw object of 'identifier' not of ambient memory model

case number was already used

casts and sizeof are illegal in preprocessor expressions

See ARM 15.3 for more information.

catch type masked by previous catch

• 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 ~

code segment too large

comma not allowed in constant expression

See ANSI 3.4 for more information.

comments do not nest

	#if
	    ....
	#endif 

compile all files with -EH to support exception handling

compile all files with -ER to support RTTI

const or reference 'identifier' needs initializer

See ANSI 3.4 for more information.

constant expression does not fit in switch type

constant initializer expected

	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

conversion of int to far or handle pointer

	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 * 
	} 

	float far *ptr;
	int f(); 

	ptr = f();
	float far * // EROR ptr = ()
	f(); // OK 

data or code defined in precompiled header

declarator for 0 sized bit field

'default:' is already used

different configuration for precompiled header

divide by 0

duplicate direct base class 'identifier'

See ARM 10.1 for more information.

DS is not equal to DGROUP

duplicate file names 'filename'

empty declaration

See ANSI 3.5 for more information.

end of file found before '#endif'

end of file found before end of comment, line number

end of line expected

	#ifdef DEBUG
	    printf("oops\n"); 
	#endif DEBUG // Not ANSI-compatible 
	#ifdef DEBUG
	    printf("oops\n"); 
	#endif	// DEBUG
		// ANSI-compatible 

error writing output file

exception specifications must match exactly for each declaration of a function

	void func() throw(int);
	void func() throw(unsigned); // ERROR 

expected assembler directive PTR to follow assembler cast

	unsigned long 1;
	asm { 
		mov AX,word PTR ;OK 
		mov AX, word 1 ;ERR
	} 

expected data def of 'identifier', not func def

	void f()
	{ 
	    void g() { } // ERROR: Nested
	}		 // function. 

exponent expected

expression expected

expression must be a pointer

	dynamic_cast <type-name> (expression) 

See ARM 5.2.6 for more information.

expression must be a pointer or reference to a polymorphic type

See ARM 5.2.6 for more information.

external with block scope cannot have initializer

See ANSI 3.5.7 for more information.

'_far16' is only valid in -mf memory model

'_far16' functions can only be extern

field 'identifier' must be of integral type

filespec string expected

__finally or __except expected

forward referenced class 'identifier' cannot be a base class

	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

See ARM 9.6 for more information.

function member 'identifier' has no prototype

function 'identifier' is too complicated to inline

function definition must have explicit parameter list

	typedef int functype(int q, int r); 
	functype funky	// ERROR: No explicit
	{		// parameter list 
	    return q + r;
	} 

function expected

functions can't return arrays or functions

	typedef char ARRAY[256];
	ARRAY func_returning_array(); // ERROR 
	ARRAY *func_returning_ptr_to_array(); // OK 

GetExceptionCode() only valid in exception filter or handler

GetExceptionInformation() only valid in exception filter

global anonymous unions must be static

See ARM 9.5 for more information.

hex digit expected

identifier expected

identifier found in abstract declarator

	x = sizeof(int a[3]);	// ERROR: a is a variable 
				// name.
	x = sizeof(int[3]); 	// OK 

identifier is longer than 254 chars

identifier or '(declarator) ' expected

illegal addressing mode

illegal cast

illegal character, ascii number decimal

illegal combination of types

• 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

illegal operand

	dec a + b 

illegal operand types

illegal pointer arithmetic

illegal return type for operator->()

• 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->()

illegal type combination, possible missing ';' after struct

illegal type for 'identifier' member

	struct X
	{   void var; // ERROR 
	};

illegal type/size of operands for the identifier instruction

	char c;
	__asm push c; 

	mov AX, c 

This can also happen for the following FPU instruction format, which is accepted by other compilers:

	fmul st(0)

	fmul st, st(0)

implied return at closing '}' does not return value

initialization of 'identifier' is skipped

See ARM 6.7 for more information.

initializer for static member must be outside of class def

	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. 

initializer or function body for dllimport not allowed

integer constant expression expected

integral expression expected

internal error identifier number

invalid instruction set 'set' for memory model 'model'

invalid reference initialization

• A volatile reference to a const.
• A const reference to a volatile.
• A plain reference to a const or volatile.

invalid storage class for friend

keyword not supported

last line in file had no \n

__leave must be within a __try block

line number expected

linkage specs are "C", "C++", and "Pascal", not "identifier"

local class cannot have static data member 'identifier'

	void f()
	{ 
	    class local_class
	    { int a, b; 
	      static int c;	// ERROR: Can't have void g();
				// static var in 
	    } l1, l2;		// local class 
	    // ...
	} 

long long not supported for ANSI or 16 bit compiles

lvalue expected

	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

See ARM 3.4 for more information.

maximum width of number bits exceeded

	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

See ANSI 3.8.8 for more information.

malformed template declaration

	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));
	} 

maximum length of macro text exceeded

max of number characters in string exceeded

member 'identifier' can't be same type as struct 'identifier'

member 'identifier' is const but there is no constructor

	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

member 'identifier' of class 'identifier' is private

	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'

	int x y; 

missing decl-specifier-seq for declaration of 'identifier'

See ARM 7 for more information.

must be void operator delete(void *[, size_t]);

	void operator delete(void *); // OK 

	void operator delete(void *, size_t);// OK 

must use delete[] for arrays

	delete[] a; // OK 

	delete a; // ERROR 

need at least one external def

See ANSI 3.7 for more information.

no constructor allowed for class 'identifier'

no definition for static 'identifier'

	static void f();
	void g() { f(); } 

no identifier for declarator

	void f(char [3]) // ERROR: No identifier
	{ 
	    // ...
	} 

	int [3]; // ERROR: No identifier
	int a[3]; // OK: Identifier is a 

no input file specified

no instance of class 'identifier'

• 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.

	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'

no match for function 'identifier'

no return value for function 'identifier'

	int f()
	{ 
	    if (x)
		return;
	}

no tag name for struct or enum

non-const reference initialized to temporary

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

not an overloadable operator token

	.	.*	::	?:	sizeof	#	## 

not in a switch statement

number 'number' is too large

number is not representable

	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

octal digit expected

one argument req'd for member initializer for 'identifier'

only classes and functions can be friends

only one identifier is allowed to appear in a declaration appearing in a conditional expression

• The pointer to object selection operator (->)
• The function call operator (())
• The array operator ([])

operator overload must be a function

	struct X
	{ int operator<<; // ERROR 
	};

out of memory

• 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

	class base
	{
	  public: 
	    void f(int);
	  private: 
	    void f(float);
	}; 

	class sub : base
	{   base::f;	// ERROR: f() is 
	};		// overloaded. 

parameter list is out of context

	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'

	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

pointer required before '->', '->*' or after '*'

pointer required before '->' or after '*'

pointer to member expected to right of .* or ->*

possible extraneous ';'

	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"); 

	while (fread(file) == unwanted_data)
	    ; // OK: semicolon is intentional 

possible unintended assignment

	if (x = y) {...} // WARNING: x= y is an assignment 

	if (x == y) {...} // OK: x == y is a test 

	if ((x = y) != 0) {...} // OK: (x = y) != 0 is a test 

pragma cseg must be at global scope

precompiled header compiled with C instead of C++

precompiled header compiled with C++ instead of C

prefix opcode must be followed by an assembler opcode

premature end of source file

prototype for 'identifier' should be identifier

	func(int s); 

	func(short s); 

pure function must be virtual

	class B
	{ virtual void f() = 0; // OK 
	  void g() = 0;		// ERROR
	}; 

qualifier or type in access declaration

	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 
	};

recursive prototype, turn off autoprototyping

redefinition of default parameter

	// 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. 

reference to 'identifier' caused a 386 instruction to be generated

	unsigned long UL;
	ASM { 
	    INC UL // incrementing a long is 32 bit
	} 

reference must refer to same type or be const

return type cannot be specified for conversion function

	class X
	{ char* operator char* (); // ERROR 
	  operator char* (); // OK
	}; 

returning address of automatic 'identifier'

segment size is number, exceeding 64KB

should be number parameter(s) for operator

size of identifier is not known

	struct x
	{ int a[]; // ERROR 
	  /* ... */
	}; 

	struct y
	{ int a[100]; // OK 
	  /* ... */
	}; 

size of type exceeds 64KB

statement expected

	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

static or non-member functions can't be const or volatile

static variables in inline functions not allowed

storage class for 'identifier' can't be both extern and inline

string expected

struct-declaration-list can't be empty

See ANSI 3.5.2.1 for more information.

template-argument 'identifier' must be a type-argument

	template <class T, int x> foo(T y)
		// ERROR: x is an expression argument. 
	{ return x + y; 
	} 

template-argument 'identifier' not used in function parameter types

	template <class T1, class T2>
	int bar(T1 x)	// ERROR: T2 isn't in 
	{		// function's
	    T2 y;	// argument list. 
	    // ...
	} 

too many errors

too many initializers

	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

	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

type conversions must be members

type is too complex

type mismatch

type must be a pointer or a reference to a defined class or void*

type must be void *operator new(size_t [,..]);

See ARM 5.2.6 for more information.

type of 'identifier' does not match function prototype

types may not appear more than once in an exception specification

	void func() throw(int, int); 

unable to open input file 'filename'

unable to open output file 'filename'

undefined escape sequence

undefined identifier 'identifier'

undefined label 'identifier'

undefined tag 'identifier'

undefined use of struct or union

	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

	fdiv 0x50 

union members cannot have ctors or dtors

unrecognized pragma

unrecognized parameter 'identifier'

unrecognized preprocessing directive '#identifier'

unrecognized token

unsupported based type

	__based(__segname("_DATA")) => __near
	__based(__segname("_STACK")) => __ss 
	__based(__segname("_CODE")) => __cs 

unsupported __declspec type

	declspec(dllimport)
	declspec(dllexport) 
	declspec(naked)
	declspec(thread) 

unterminated macro argument

unterminated string

See ANSI 3.1.3.4 for more information.

use delete[] rather than delete[expr], expr ignored

	delete [expr] p; // WARNING: obsolete 

	delete [] p; // OK 

using operator++() (or --) instead of missing operator++(int)

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]

value of expression is not used

	x == y; // WARNING: The value of x
		// doesn't change. 
	x = y;	// OK: x and y have same value. 

	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

vectors cannot have initializers

very large automatic

voids have no value

voids have no value, ctors and dtors have no return value

'while' expected

	do
	{
	    x = f(y); 
	} (x != 0);	// ERROR: missing while. 
	do
	{
	    x = f(y); 
	} while (x != 0); // OK