I Messages


Compiler messages 650
Message format 650
Errors in asm macros and asm strings 651
C compiler message detail 651
Assembler messages 717
Linker messages 718

This appendix provides additional information on messages generated by the compilers and some of the other tools.

In analyzing messages, remember that a message can be generated for code which is apparently correct. Such a message is often the result of earlier errors. If a message persists after all other errors have been cleared, please report the circumstances to Customer Support.

Compiler messages

Message format

Compiler messages have the form:

"file", line #: severity-level (compiler:error #): message

Messages have one of four severity-level values as follows. The severity-level for each message is shown in parentheses in the message description; for example, (w) for a warning message.

Table I-1   Compiler message severity levels 
severity- level   Type   Compilation continues   Object file produced   Notes  

i  

Information  

Yes  

Yes  

Usually provides detailed information for an earlier message.  

w  

Warning  

Yes  

Yes  

 

e  

Error  

Yes  

No  

 

f  

Fatal  

No  

No  

 

In each message, "compiler" identifies the compiler reporting the error: dcc for the C compiler, dplus for the C++ compiler, or fastj for the Java compiler.

Example:

"err1.c", line 2: error (dcc:1525): identifier i not declared

Errors in asm macros and asm strings

Errors in assembly code embedded in C or C++ using asm macros or asm string statements are caught by the assembler, not by the compiler.

If the -S option is not used, the compiler will generate a temporary assembly file which is discarded after assembly. To preserve the assembly file for use in diagnosing errors reported in asm macros or asm strings, either:

C compiler message detail

Numbered messages are issued by the compiler subprogram. Unnumbered messages are issued by the driver and are listed first.

driver can't find program program-name
program-name will be the name of some component of the compiler or other Diab tool. (f)

Possible causes:

  • The compiler is not installed properly

  • One of the compiler files has been deleted, hidden, or protected

  • The dtools.conf or other configuration file is incorrect

driver can't fork
The system cannot start a new process. (f)

driver missing comma in -Y option
The -Yc,dir option must include a comma. (f)

driver illegal output name file
Specific output file names given with the -o option are invalid to avoid common typing mistakes. (f)

dplus a.c -o b.c # b.c is an illegal output file name

driver invalid option unknown
The driver was started with an unrecognizable -W or -Y option. Note: -X options that are not recognized generate an "unknown option" message, and unrecognized but otherwise valid non -X options are passed to the linker. (f)

driver program tool-name terminated
The given executable has detected an internal error. May result from other errors reported earlier. If the problem does not appear to be a consequence of some earlier error, please report it to Wind River. (f)

1000 (general compiler error)
The compiler has detected an internal error. May result from other errors reported earlier. If the problem does not appear to be a consequence of some earlier error, please report it to Wind River. (f)

1001 illegal argument type
The operand cannot be used with the operator. (e)

if ( i > pointer ) . . .

1003 function takes no arguments
Function was defined without arguments, but was called with arguments. (e)

int fun (){}
main(){
    fun(1);
}

1004 wrong number of arguments
Number of arguments given does not match prototype or function definition, (w) in C modules if -Xpcc or -Xk-and-r or -Xmismatch-warning, (e) otherwise.

int fn(int, int); ... fn(1,2,3);

1006 string in string
The compiler has detected an internal error. May result from other errors reported earlier. If the problem does not appear to be a consequence of some earlier error, please report it to Wind River. (f)

1007 ambiguous conversion -- cannot cast operand
The compiler cannot find an unambiguous way to convert an item from one type to another. (e)

1010 Ooperator, type-designator, argument must be of pointer or integral type
An operator that requires an integral or pointer type was applied to a different type.

float f;
f = ~f;

1012 operator, type-designator, argument must be of pointer or arithmetic type
The operator requires a pointer or arithmetic type operand. (e)

struct S {
    int i;
}s;
struct S *p;
*p -> i =3;     //

1013 left argument must be of integral type
The left operand must be an integral type. (e)

pointer | 3;

1015 Type-designator, operator, type-designator, left argument must be of arithmetic type
The operand to the left of the operator must be of arithmetic type. (e)

pointer * 2;
pointer / 2;

1017 right argument must be of integral type
The right operand must be an integral type. (e)

7 | pointer;

1019 type-designator, operator, type-designator, right argument must be of arithmetic type
The operand on the right of the operator must be of arithmetic type. (e)

2 * pointer;
2 / pointer;

1025 division by zero
The compiler has detected a source expression that would result in a division by 0 during target execution. (w)

int z = 0; fn(10/z);

1028 type-designator [type-designator] requires a pointer and an int
A subscripted expression requires a pointer and an integer. (e)

main(){
    int x;
    x[3]=4;
}

1030 can't take address of main
Special rules for the function main( ) are violated. (e)

int *p;
p = main;

1031 can't take address of a cast expression
The address operator requires an lvalue for its operand. (e)  

int i, *p;
float f;
p = &(int)f;

1032 (anachronism): address of bound member function
The correct way to refer to the address of a member function is to use the '::' operator. The C method, using the dot '.' operator, causes the compiler to generate the "anachronism" warning. (w)

class C {
public:
    fun();
} c;

main(){
    class C * p;
    p= &c.fun; // Old way to reference a function
}

1033 can't take address of expression
Cannot use '&' or other means to find the address of the expression. (e)

int *pointer;
&pointer++;

1034 can't take address of bit-field expression
The address of bit-fields is not available. (e)

int *p;
struct {
    int i:3;
}s;
p = &s.i;

1041 returning from function with address of local variable
A return statement should not return the address of a local variable. That stack area will not be valid after the return. (w)

int i;
return &i;

1042 `?' type-designator ':' type-designator, bad argument type(s)
Incompatible types have been used with the conditional operator. (e)

int i, *pointer, *p;
p = (2>1) ? i : pointer;

1043 trying to decrement object of type bool
A a boolean cannot be decremented. (e)

bool b;
b--;

1044 assignment to constant expression
A constant cannot be assigned a value after the constant is defined. (e)

const int i=5;
i=7;

1045 assignment to non-lvalue of type type-designator
The operand being assigned is not an lvalue type. (e)

const c = 5;
c = 7;

1046 assignment from type-designator to type-designator
An attempt has been made to assign a type to an incompatible type. (e)

int i, j;
i = &j;

1047 trying to assign 'ptr to const' to 'ptr'
A pointer to a const cannot be assigned to an ordinary pointer. (e)

const int *pc; int pi; ... pi = pc;

1050 bad left argument to operator operator not a pointer
The operator requires a pointer for its left operand. (e)

int int1, j;
int1 -> j=3;

1051 not a class/struct/union expression before ...
The left hand side of a '.' or '.*' or '->' or '->*' operator must be of type class or pointer to class. (e)

5->a = 128; // 5 is not a pointer to a class

1055 illegal function call
The function call is not valid. (e)

int i;
i();

1056 illegal function definition
A function definition is invalid. (e)

fun(iint i);

1057 main() may not be called from within a program
Calling main() is not permitted. (e)

fun(){
    main();
}

1059 (compiler error)
The compiler has detected an internal error. May result from other errors reported earlier. If the problem does not appear to be a consequence of some earlier error, please report it to Wind River. (f)

1060 possibly '=' instead of '==' ?
Encountered a conditional where the left hand side is assigned a constant value: (w)

if (i = 0) ... /* should possibly be i == 0) */

1061 illegal cast from type-designator to type-designator
An attempt is made to perform a cast to an invalid type, i.e., a structure or array type. (e)

struct a = (struct abc)x;

1063 ambiguous conversion from type-designator to type-designator
The compiler cannot find an unambiguous way to convert an item from one type to another. (e)

1074 illegal cast
An attempt is made to perform a cast to an invalid type, i.e., a structure or array type. (e)

1075 friend declaration outside class/struct/union declaration
The keyword friend is used in a invalid context (e)

friend class foo {
    ...
};

1076 static only allowed inside { } in a linkage specification
Attempt to declare a static object in a one-line linkage specification. (e)

extern "C" static int i; // static + extern at same time?

1077 typedefs cannot have external linkage
Linkage specification ignored for typedef, cannot have 'C or "C++" linkage. (w)

extern "C" typedef int foo;

1079 identifier name previously declared linkage
The identifier was already declared with another linkage specification. (e)

int foo;
extern "C" int foo;

1080 inconsistent storage class specification for name
The identifier was already declared, with another storage class. (e)

bar()
{
    int foo; // foo is auto by default
    static int foo; // now static
}

1081 illegal storage class
External variables cannot be automatic. Parameters cannot be automatic, static, external, or typedef. (e)

int fn(i)
static int i; { ... }

1082 illegal storage class
A variable has been declared, but cannot legally be assigned to storage. (e)

register int r;           // Outside of any function

1083 only functions can be inline
The inline keyword was applied to a non-function, for example, a variable. (e)

1084 only non-static member functions can be virtual
For example, operators new and delete cannot be virtual.

virtual void *operator new( size_t size){...}

1086 redeclaration of identifier
It is invalid to redeclare a variable on the same block level. (e)

int a; double a;

1087 redeclaration of function
A function was already declared. May be caused by mis-typing the names of similar functions. (e)

1088 illegal declaration
Common causes and examples: (e)

    A scalar variable can only be initialized to a single value of its type.  

        int i = 1, 2;  

    Functions cannot return arrays or functions.  

        char fn()[10];  

    Variables cannot be of type void. (Usually caused by a missing asterisk, e.g. void *p; is correct.)  

        void a;  

    Only one void is allowed as function argument.  

        int fn(void, void);  

    An array cannot contain functions.  

     

1089 illegal initializer
An initializer is not of the proper form for the object being initialized. Often caused by a type mismatch or a missing member in a structure constant. (e)

1090 static/external initializers must be constant expressions
Static initializations can only contain constant expressions. (e)

static int i = j+3;

1091 string too long
A string initializer is larger than the array it is initializing. (e)

char str[3] = "abcd";

1092 too many initializers
The number of initializers supplied exceeds the number of members in a structure or array. (e)

int ar[3] = { 1,2,3,4 };

1094 illegal type for identifier identifier
This can indicate a template was instantiated with the wrong arguments. (e)

template<class T>
class C{};

C<int, int> WrongArgs;

1096 typedef may not have the same name as its class
Only constructors and destructors for a class may have the same name as the class. (e)

1097 function-declaration in wrong context
A function may not be declared inside a struct or union declaration. (e)

struct { int f(); };

1098 only non-static member functions can be string
Only non-static member functions can be const or volatile.

class A {
    static foo() const;
};

1099 all dimensions must be specified for non-static arrays
For an array in a class all dimensions must be specified, even if the array is not static. (e)

1100 member is incomplete
The structure member has an incomplete type, i.e., an empty array or undefined structure. (e)

struct { int ar[]; };

1101 anonymous union member may not have the same name as its class
Only constructors and destructors for a class may have the same name as the class. (e)

1102 anonymous unions can't have member functions

1103 anonymous unions can't have protected or private members

1104 name of anonymous union member name already defined
An identifier with the same name as an anonymous union member was already declared in the scope. (e)

int i;
static union {
    int i; // i already declared
}

1105 anonymous unions in file scope must be static
A special rule for an anonymous unions is violated. (e)

1106 friends can't be virtual
A friend is not a member of the class; it cannot be virtual. (e)

1107 conversion functions must be members of a class
It is not valid to define a conversion function that is not a class member. A conversion function cannot take arguments. A conversion function cannot convert to the type of the class if it is a member of, or a reference to it. (e)

1108 member function declared as friend in its own class
Invalid declaration. (e)

class A {
    foo(int);
    friend A::foo(int);
}

1110 identifier identifier is not a member of class class-name
The identifier to the right of :: is not in the class on the left side. (e)

1111 identifier identifier not member of struct/union
The expression on the right side of a '.' or '->' operator is not a member of the left side's struct or union type. (e)

1112 member declaration without identifier
A struct or union declaration contains an incomplete member having a type but no identifier. (w)

struct foo { int; ...};
struct { struct bar { ... }; ... };

1113 identifier name used both as member and in access declaration
A use of the name would be ambiguous. (e)

class A {
    public:
    int foo;
};

struct B : private A {
    int foo;
    A::foo;
};

1114 array is incompletely specified
An array cannot be declared with an incomplete type. (e)

int a[]; // No array size

1115 type ... is incomplete
Attempt to access a member in an incomplete type. (e)

1117 identifier identifier not an argument
An identifier that is not in the parameter list was encountered in the declaration list of an old-style function. (e)

f(a) int b; { ... }

1120 constant expression expected
The expression used in an enumerator list is not a constant. (e)

enum a { b = f(), c };

1121 integer constant expression expected
The size of an array must be computable at compile time. (e)

int ar[fn()];

1123 illegal type of switch-expr
A switch expression is of a non-integral type. (e)

1124 duplicate default labels
A switch has should not have more than one default label.

1125 int constant expected
A bit-field width must be an integer constant. (e)

1126 case expression should be integral constant
Case expressions must be integral constants. (e)

int i,j;
switch (i) {
  case j:
    i = 8;
}

1127 duplicate case constants
A case constant should not occur more than once in a switch statement. (e)

case 1: ... case 1:

1127 duplicate case constants
Duplicate case constants were detected. (e)

main(){
    int year,j;
    switch (year) {
      case 2000:
        j = 8;
      case 2000:
        j = 9;
    }
}

1128 function must return a value
Found a return statement with no value in a function. (e)

int foo()
{
    return; // Must return a value.
}

1129 constructors and destructor may return no value
A constructor or destructor must not return a value. (e)

1130 parameter decl. not compatible with prototype
There is a mismatch between a prototype and the corresponding function declaration in either number of parameters or parameter types. (e)

int fn(int, int);
int fn(int a, float b) { ... }

1131 multiple initializations
A variable was initialized more than once. (e)

static int a = 4;
static int a = 5;

1133 extern objects can only be initialized in file scope
An extern object cannot be initialized inside a function. (e)

main(){
    extern int i=7;
}

1133 extern objects can only be initialized in file scope
Attempt to initialize an extern object in a function. (e)

foo()
{
    extern int one = 1;
}

1134 can't initialize arguments
It is not valid to attempt to initialize function parameters. (e)

f(i) int i = 5; { ... }

1135 can't init typedefs
A typedef declaration cannot have an initializer. (e)

typedef unsigned int uint = 5;

1136 initialization of automatic aggregates is an ANSI extension
When the compiler is run in PCC compatibility mode on a C module (-Xpcc), it will report initialization of automatic aggregate types. (w)

f() { int ar[3] = {1,2,3}; ... }

1140 too many parameters for operator ...
Overloaded operator declared with too many parameters. (e)

1141 too few parameters for operator ...
Overloaded operator declared with too few parameters. (e)

1142 second argument to postfix operator '++' or '--' must be of type int
The argument is of the wrong type. (e)

struct A {
    operator++(double); // Arg type must be int
};

1143 operator->( ) must return class or reference to class
If a class object is used on the left hand side of the -> operator, the operator->( ) must be defined for that class. The return type for operator->( ) must be a class with operator->( ) defined or a pointer to that class. (e)

1144 operator ... can only be overloaded for classes
The operators ',' and '=' and the unary '&' can only be overloaded for classes. (e)

1145 operator . . . must be a non-static member function
The operators (), [], and -> must be non-static member functions. These operators can only be defined for classes. (e)

1146 non-member operator function must take at least one argument of class or enum type or reference to class or enum type
A non-member operator function must take at least one argument, which is of a class or enum type or a reference to a class or enum type. (e)

Date operator+(int i, j){...}

1147 constructors can't be declared string
Constructors cannot be declared static or virtual.

1148 constructors can't have a return type
A constructor declaration is invalid. (e)

1149 constructor is illformed, must have other parameters
A constructor declaration is invalid. (e)

1151 can't have a destructor in a nameless class/struct/union
A nameless class cannot have a destructor since the destructor takes its name from the class. (e)

class {
    ~foo();
};

1152 destructors must have same name as the class/struct/union
The destructor declaration is invalid. (e)

const ~k(){}

1153 destructors may have no return type

1154 destructors can't be declared string
Destructors cannot be declared static.

1155 destructors may take no arguments
The destructor declaration is invalid. (e)

1156 conversion functions may take no arguments
It is not valid to define a conversion function that is not a class member. A conversion function cannot take arguments. A conversion function cannot convert to the type of the class if it is a member of, or a reference to it. (e)

1157 conversion to original class or reference to it
It is not valid to define a conversion function that is not a class member. A conversion function cannot take arguments. A conversion function cannot convert to the type of the class if it is a member of, or a reference to it. (e)

1159 no type found for identifier, can be omitted for member functions only
The identifier has not been declared. (e)

1160 class already has operator delete with number of argument(s)
The delete operator cannot be overloaded. (e)

1161 member operator functions can't be static
Operator functions in a class cannot be declared static. (e)

1162 member of abstract class
A class member cannot be of abstract type. (e)

1163 unions can't have virtual member functions
Union cannot have virtual functions as members. (e)

1164 member function of local class must be defined in class definition
Because functions cannot be defined in other functions, any function in a local class must be defined in the class body. (e)

1165 redeclaration of member identifier
A member occurs more than once in a struct, union, or class. (e)

struct { int m1; int m1; };

1166 member name already declared
Attempt to re-declare a member. (e)

class A {
    int a;
    int a; // Already declared
};

1167 static data member may not have the same name as its class
Only constructors and destructors for a class may have the same name as the class. (e)

1168 a local class can't have static data members
Only non-static members can be used in a local class. (e)

1169 unions can't have static data members
Union cannot have static data members. (e)

1170 illegal union member
An object of a class with a constructor, a destructor, or a user defined assignment operator cannot be a member of a union. (e)

1171 illegal storage class for class member
A class member cannot be auto, register, or extern. (e)

1172 parameter has no identifier
When declaring a function, a name as well as a type, must be supplied for each parameter. (e)

int fn(int a, int) { ... }

1173 compiler out of sync: probably missing ';' or '}'
The compiler is unable to parse what appears to be an external declaration. Could be due to a missing or misspelled token or keyword. (e)

int i int j;            missing ';' after i
dribble f;              should be double 

1174 ellipsis not allowed as argument to overloaded operator
Cannot declare an overloaded operator with "..." as arguments. (e)

1175 ellipsis not allowed in pascal functions
Functions declared with the pascal keyword are not allowed to have a variable number of arguments as indicated by an ending ellipsis "...". (e)

1176 argument n to string must be of type size_t
For example, operator delete's second argument must be of type size_t

void operator delete(void *type, int x){
    free(type);
}

1177 string must return void *
For example the operator new must return a void pointer.

int *operator new(size_t size){...}

1179 string takes one or two arguments
For example, operator delete takes one or two arguments (e).

void operator delete(void *type, size_t size, int x){...}

1180 operator delete must have a first argument of type void *
The first argument of delete must be of type void*.

void operator delete(int x){
    free(x);
}

1181 string must return void
For example, operator delete must return void.

int operator delete(void *type){...}

1182 class class-name has no constructor
It is invalid to initialize an object that does not have a constructor by using the constructor initialization syntax. (e)

struct A {
    int b, c;
};
A a(1,2);

1186 const member identifier must have initializer
A constant member of a class must be initialized. (e)

class line{
    const int length;
...
};

1188 jump past initializer
An object cannot be accessed before it has been constructed.

class C
{
    public:
    int i;
    C(int ii) : i(ii) {}
};

void AllAlarmsOnOff (int function)
{
    switch ( function )
    {
         case 1:
             C c(0);
             break;
         default:
             c.i = 12;  // invalid access
             break;
    }
}

1190 this cannot be used outside a class member function body
The keyword this was used outside the body of a (non-static) class member function. (e)

1192 mismatching parenthesis, bracket or ? : around expression
Mostly likely, a parenthesis or bracket was left out of an expression, or the '?' and ':' in a conditional expression where interchanged. (e)

int i = (5 + 4]; // ] should have been a )

1193 Missing operand for operator
An operand is missing. (e)

i & ;

1194 (compiler error)
The compiler has detected an internal error. May result from other errors reported earlier. If the problem does not appear to be a consequence of some earlier error, please report it to Wind River. (f)

1195 missing operand somewhere before :
An operand was left out of an expression. (e)

1196 missing expression inside parenthesis
An expression was expected between the parentheses. (e)

i =() ;

1197 missing operand for operator ... inside parenthesis
An operand was left out of an expression. (e)

1198 too many operands inside parenthesis
An operator between the operands is missing. (e)

1199 missing expression inside brackets
An expression was expected between the brackets. (e)

int x[5];
int i = x[]; // x must be subscripted

1200 missing operand for operator ... inside brackets
An operand was left out of an expression. (e)

1201 too many operands inside brackets
An operator between the operands is missing. (e)

1202 Missing operator before string
An operator is needed before string.

i = (2>1) 3: 4; // Conditional operator needs '?'

1205 operator ? without matching :
Operator '?' must be followed by a ':' . (e)

int i = 4 ? 5; // Missing : part

1207 syntax error near token
The parser has found an unexpected token. (e)

if (a == 1 ( /* missing ')' */

1208 expression expected
Could not find an expression where it was expected. (e)

if () { // The condition is missing.
    ...
}

1209 illegal expression
There was something wrong with the expression. Another error has probably already been reported. (e)

1210 to 1216 (compiler error)
The compiler has detected an internal error. May result from other errors reported earlier. If the problem does not appear to be a consequence of some earlier error, please report it to Wind River. (f) For users searching online: 1211, 1212, 1213, 1214, 1215, 1216.

1219 internal error
The compiler has detected an internal error. May result from other errors reported earlier. If the problem does not appear to be a consequence of some earlier error, please report it to Wind River. (f)

1221 don't know size of object
The sizeof operator is used on an incompletely specified array or undefined structure, or an array of objects of unknown size is declared. (e)

extern int ar[]; sz = sizeof(ar);

1224 type must have default constructor
The class must have a default constructor. (e)

1227 EOF in comment
The source file ended in a comment. (w) if -Xpcc, (e) otherwise.

1228 too many characters in character constant
A character constant has more than four characters. The limit is four on 32 bit machines. (e)

int i1 = 'abcd';  /* ok */
int i2 = 'abcde'; /* not ok */

1229 EOF in character constant
The source file ended at an unexpected place during parsing. (f)

1230 newline in character constant
The end of a line was found while parsing a character constant. Usually caused by a missing single quote character at the end of the constant. (e)

char TAB = '\t;

1231 empty character constant
There are no characters in a character constant. If an empty string is desired, use string quotes "". (e)

int i3 = '';    /* This is two single quotes characters. */

1232 too many characters in wide character constant
By default, wide characters are implemented as long integers (32 bits). See also the -Xwchar=n option on p.114.

1234 newline in wide character constant
A newline is in a wide character constant. Example: in the following, the wide character constant is intended to be L'ab', but is broken across two lines.

int i = L'a
b';

1235 empty wide character constant
Empty wide character constants are not allowed:

int i = L'';

1236 EOF in string constant
The source file ended at an unexpected place during parsing. (f)

1237 newline in string constant
The end of a line was found while parsing a string constant. Usually caused by a missing double quote character at the end of the constant. (e)

char * message = "Not everything that counts can be counted.

1238 illegal hex constant
Reported whenever an 'x' or 'X' is found in a numeric constant and is not prefixed with a single zero. (e)

i = 1xab;

1239 too long constant
A numeric constant is longer than 256 characters. (e)

1240 floating point value (...) out of range
A floating point constant exceeds the range of the representation format. (e)

double d = 1e10000;

1241 floating point overflow
Floating point overflow occurred during constant evaluation. (e)

float f=4E200;

1242 bad octal constant
A numeric constant with a leading zero is an octal constant and can only contain digits '0' through '7'. (w)

i = 078;    // '8' is invalid in an octal constant

1243 constant out of range
Constant overflows its type. (e)

int i = 4294967299; // Constant bigger than ULONG_MAX

1243 constant out of range [ operator ]
A constant is out of the range of the context in which it is used. If the operator is present, it shows the operator near the use of the invalid constant. (w)

int j = 0xffffffffff;

1244 constant out of range (string)
An invalid constant was used. (w)

const int x=0xfffffffff;
if ((char)c==257) ...

1245 illegal character: 0n (octal)
The source file contains a character with octal code n that is not defined in the C language. This can only occur outside of a string constant, character constant, or comment. (e)

name$from$PLM = 1;

1246 no value associated with token
The compiler has detected an internal error. May result from other errors reported earlier. If the problem does not appear to be a consequence of some earlier error, please report it to Wind River. (f)

1247 syntax error after string, expecting string
The expression is missing a semicolon or some token. (e)

int i

1248, 1249 label identifier already exists
A label can only refer to a single place in a function. (e)

1250 label identifier not defined
The label used in a goto statement is not defined. (e)

1251 label identifier not used
The label is never used. One possible cause is the misspelling of a label. This message appears if the -Xlint option is used. (w)

main(){
agian:               // typo?
    goto again;
}

1252 typedef specifier may not be used in a function definition
Bad use of the typedef specifier. (e)

typedef int foo()
{
}

1253 virtual specifier may only be used inside a class declaration
Function cannot be declared virtual outside class body. (e)

struct A {
    foo();
};
virtual A::foo() {} // Not virtual in the class declaration

1254 redefinition of function
The function is already defined. (e)

int foo() {}
int foo() {}

1255 unions may not have base classes
Union cannot have base classes. (e)

1256 unions can't be base classes
Union cannot be used as base classes. (e)

1257 inconsistent exception specifications
Two function declarations specify different exceptions. (e)

int foo() throw (double);
int foo() throw (int);

1258 exception handling disabled
Exception handling has been turned off. Use -Xexception=1 to enable it. (e)

1259 rtti disabled
RTTI (run-time type information) can be enabled or disabled through the -Xrtti-... option. See Enable run-time type information (-Xrtti, -Xrtti-off), p.104.

1260 non-unique struct/union reference
In PCC mode (-Xpcc) the compiler attempts to locate a member of another struct if given an invalid reference. If no unique member can be found, this error is issued. (e)

struct a { int i; int m; };
struct b { int m; int n; };
int i; ... i->m = 1;

1261 insufficient access rights to member-name in base-class-name base class of derived-class-name
Attempt to access a member in a private or protected base class. (e)

1264 main can't be overloaded
Special rules for the function main( ) are violated. (e)

1265 can't distinguish function_name1 from function_name2
Two overloaded functions cannot be distinguished from each other; they effectively have the same number and types of arguments in the same order. (e)

int foo(int);
int foo(int &);

1266 function function-name already has "C" linkage
Only one of a set of overloaded functions can have "C" linkage. (e)

extern "C" foo(int);
extern "C" foo(double);

1268 only virtual functions can be pure
Pure specifier found after non-virtual function. (e)

class foo {
    bar() = 0 // Must be virtual
};

1269 Identifier is not a struct/class/union member
The identifier is not a member of a structure, class, or union. (e)

int i;
i.j = 3; // j is not a member of a structure.

1272 member name used outside non-static member function
Attempt to reference a class member directly in a static member function or an inlined friend function. That is invalid in a function where keyword this cannot be used. (e)

1275 error string
This error number can indicate a number of different kinds of errors. In some cases, this message gives additional information about an error message displayed above this one. For example, if a function call is ambiguous, this error prints the names of candidate functions.

1276 can't use ... in default argument expression
Class members can only be used in default arguments if they are static. Function arguments cannot be used in default arguments. Local variables cannot be used unless they are declared extern. (e)

int foo(int  a, int b = a)
{
    ...
}

1278 can't restrict access to identifier
An access declaration cannot restrict access to a member that is accessible in the base class, nor can an access declaration enable access to a member that is not accessible in the base class. (e)

1279 can't enable access to identifier
An access declaration cannot restrict access to a member that is accessible in the base class, nor can an access declaration enable access to a member that is not accessible in the base class. (e)

1281 no function matches call to string
The compiler did not find a match for a class method, or a template function. This can also indicate that a class does not have a default constructor. (e)

class line{
public:
    line(){}
};
line l(5,6);

Second example:

template< class T> T max(T a, T b) {
    return(a>b) ? a : b;

main(){
    int i;
    char c;
    max(i,c);
}

1282 can't resolve function call, possible candidates:
An overloaded function was called, but the function arguments did not match any prototype. (e)

fun(int i){}
fun(char c){}

main(){
    float f;
    fun(f);
}

1285 ambiguous reference to identifier, could be candidate1 candidate2 ...
The identifier could not be resolved unambiguously. The error message is followed by a list of possible candidates. (e)

struct A { int a; };
struct B { int a; };
struct C : public A, public B {};

foo()
{
    C c;
    c.a = 1; // Which a, A::a or B::a?
}

1288 return type not compatible with ...
A virtual function has a return type that is incompatible with the return type of the virtual function in the base class. (w)

1292 too many arguments for function style cast to string
Function style casts to a basic type or a union type can only take a single argument. (e)

int i = int(3.4, 5.6);

1293 non-type in new expression
A new expression requires a type.

class list {};
. . .
class list * cp;
cp = new lis; // Spelled wrong

1294 type in new expression is abstract
The type in a new expression must not be abstract.

1295 first dimension must be an integral expression
The first dimension of an array type in a new expression must be an integral expression. (e)

double d;
int *p = new int[d];

1296 can't create void objects
The type in a new expression was void.

void *p = new void;


1297 type in new expression is incompletely specified

1298 object of abstract class
Attempt to declare an object of an abstract class. (e)

1298 can't construct object of abstract type
The type in a new expression is of abstract class. (e)

struct A {
    virtual foo() = 0;
};
A *p = new A;

1299 can't construct objects of array type
Array elements in an array allocated with new cannot be given initial values. (e)

struct A {};
A *p = new A[5](1,2,3,4,5);

1304 already volatile
A variable was declared volatile more than once. (w)

int * volatile volatile foo;

1305 to 1336 (compiler error)
The compiler has detected an internal error. May result from other errors reported earlier. If the problem does not appear to be a consequence of some earlier error, please report it to Wind River. (f) For users searching online: 1305, 1306, 1307, 1308, 1309, 1310, 1311, 1312, 1313, 1314, 1315, 1316, 1317, 1318, 1319, 1320, 1321, 1322, 1323, 1324, 1325, 1326, 1327, 1328, 1329, 1330, 1331, 1332, 1333, 1334, 1335, and 1336.

1337 EOF in inline function body
The end of the source file was found while parsing an inline function. (f)

1338 arguments do not match template
The actual template argument types must match the declaration exactly. (e)

template<int size>
class foo {
    // ...
};

foo<7, 7> qux;

1339 arguments do not match template template name
The arguments do not match the template.

template<class T>
class C{};

C<int, int> WrongArgs;

1340 can't recover from earlier errors
Certain earlier errors have made it impossible for the parser to continue. (f)

1341 compiler out of sync: mismatching parens in inline function
The compiler is unable to parse an inline function. Check the function to see if the parentheses are nested correctly. (f)

1344 syntax error - unexpected end of file
The parser has found an unexpected token. (e)

1347 identifier name used as template name
The identifier cannot be used as a class, struct, or union tag since it is already a template name. (e)

template<class T>
class foo {
    ...
};

struct foo {
}

1354 '0' expected in pure specifier
A value other than 0 was found in a pure specifier. (e)

class foo {
    virtual bar() = 5; // Should have been 0
}

1355 all dimensions but the first must be positive constant integral expressions
The first dimension of an array may be empty in some contexts. In a multi-dimensional array, no other dimensions may be empty (and none may be negative). (e)

int array[-4];

1360 base class expected
Base class not found after ':' or ',' in a class definition. (e)

class A : {}; // The base class is missing

1361 can't initialize ... with a list
An object of a class which has constructors, bases, or non-public members cannot be initialized as an aggregate.

struct foo {
    private:
        int i
    public:
        int j, k;
};

foo bar = { 1, 2, 3 }; // i is private

1362 can't nest function definitions
Functions cannot be defined inside other functions.

void foo()
{
    void bar() { } // No nesting
}

1367 class class-name used twice as direct base class
Cannot use the same class as a base class more than once. (e)

class A {};

class B : A, A {};

1368 class name expected after ~
Encountered '~' in a class, apparently to declare a destructor, but it was not followed by the class name. (e)

class foo {
    ~;
};

1370 class/struct/union cannot be declared specifier
A function specifier is applied to a definition of a class, struct, or union. (e)

inline class foo {    /* inline is invalid for a class  */
    ...
};

1371 conflicting declaration specifiers: specifier1 specifier2
Illegal mixing of auto, static, register, extern, typedef and/or friend. (e)

extern static int foo;

1372 conflicting type declarations
More than one type specified in a declaration. (e)

int double foo;

1373 enumerator may not have same name as its class
Only constructors and destructors for a class may have the same name as the class. (e)

1376 function function name is not a member of class class name
A function was not declared, it was misspelled, or the parameters were not used consistently. (e)

class line{
    lint(int l); // Misspelled
};
line::line(int l){}

1378 function function name is not found
A function call referred to a function that was not found. (e)

static int fun();
main(){
    fun();
}

1379, 1380 identifier ... declared as struct or class. Use struct or class specifier
identifier ... declared as union. Use union specifier
There was a type mismatch between the declaration and the use of an identifier. (e)

union u {
    ...
};

struct u foo; // u was a union, cannot also be struct

1381 identifier name not a nested class nor a base class
Something that is not a class was used as a base class. (e)

1383 identifier identifier is not a type
What appeared to be a declaration began with an identifier that is not the name of a type.

INT I;

1384 identifier name not a direct member
Attempt to initialize a variable that is not a direct member of the class. (e)

struct B { int b; };

struct C : public B {
    int c;
    C(int i) : c(i), b(i) {} // Can't initialize b here
}

1385 identifier identifier not a static member of class class name
Invalid declaration. (e)

struct A {
    int i;
};

int A::i;

1386 identifier identifier not declared in string
An identifier is used but not declared. Check the identifier for spelling errors. (e)

1388 identifier identifier not declared
An identifier was used without being declared. (e)

1391 identifier name is not a class
An identifier that is not a class was used before "::".

1394 illegal expression
A break statement is only allowed inside a for, while, do or switch statement. (e) A continue is only allowed inside a for, while or do statement. (e) A default or case label is only allowed inside a switch statement. (e)

1395 illegal function specifier for argument
A parameter cannot be declared inline or virtual.

void foo(inline int);

1397 illegal storage class for class/struct/union
A storage class other than extern is specified for a definition of a class, struct, or union. (e)

auto class foo {
    ...
};

1403 main can't be declared string
Special rules for the function main( ) are violated. (e)

1404 mem initializers only allowed for constructors
Members can only be initialized with the member initializer syntax in constructors. (e)

class A {
    int i;
    int foo() : i(4711) {} // Not a constructor
}

1405 missing argument declaration
Argument declaration omitted. (e)

class bar {
    foo(, int);
};

1410 no default arguments for overloaded operators
Overloaded operators cannot have default arguments. (e)

1411 no redefinition of default arguments
An argument can be given a default value only once in a set of overloaded functions. (e)

void foo(int = 17);
void foo(int = 4711);

1412 no return type may be specified for conversion functions
The return type of conversion function is implicit. (e)

class foo {
    double operator int(); // Cannot specify type
}

1414 non-extern object name of type type-name must be initialized
A const object must be initialized unless it is extern.

1415 non-extern reference name must be initialized
References and const objects, which are not declared extern, must be initialized. So must objects of classes that have constructors but no default constructors. (e)

const struct S &structure;

int pascal i;

1417 only functions can have pascal calling conventions

1418 only static constant member of integral type may have initializer
A member that is a static integral type can be initialized; others cannot. (e) 

struct {
    const int *p =0x3333;
}s;

1419 operator ... can not be overloaded
It is invalid to overload any of the operators '.' or '.*' or '? :' .

1420 parenthesized expression-list expected after type typename

1423 redeclaration of symbol ...
A symbol in an enumerated type clashes with an earlier declaration. (e)

1427 static function declared in a function
There is no use declaring a static function inside another function. (e)

void foo()
{
    static void bar();

    bar(); // Call to bar, but where can it be defined?
}

1428 static member ... can't be initialized
A static class member cannot be initialized in a member initializer. (e)

class A {
    static int si;
    A(int ii) : si(ii) {}
};

1429 string literal expected in asm definition
String missing in an asm statement.

asm();    // the parentheses should contain an instruction

1430 subsequent argument without default argument
Only the trailing parameters may have default arguments. (e)

void foo(int = 4711, double);

1431 syntax error - catch handler expected after try
The parser has found an unexpected token. (e)

1432 syntax error - catch without matching try
The parser has found an unexpected token. (e)

1433 syntax error - class key seen after type. Missing ;?
The parser has found an unexpected token. (e)

1434 syntax error - class name expected after ::
The parser has found an unexpected token. (e)

1435 syntax error - colon expected after access specifier
The parser has found an unexpected token. (e)

1436 syntax error - declarator expected after ...
The parser has found an unexpected token. (e)

1437 syntax error - declarator expected after type
The parser has found an unexpected token. (e)

1438 syntax error - declarator or semicolon expected after class definition
The parser has found an unexpected token. (e)

1439 syntax error - else without matching if
The parser has found an unexpected token. (e)

1441 syntax error - identifier expected after ...
The parser has found an unexpected token. (e)

1442 syntax error - initializer expected after =
The parser has found an unexpected token. (e)

1444 syntax error - keyword operator must be followed by an operator or a type specifier
The parser has found an unexpected token. (e)

1446 syntax error - type tag expected after keyword enum
The parser has found an unexpected token. (e)

1454 type defined in return type (forgotten ';'?)
It is illegal to define a type in the function return type. (e)

struct foo {} bar()
{
}

1455 type definition in bad context
A type was defined where it was not allowed. (e)

1456 type definition in condition
Types cannot be defined in conditions. (e)

if (struct foo { int i } bar) {
    // ...
}

1457 type definition not allowed in argument list
Types cannot be defined in argument lists. (e)

int foo( struct bar int a; } barptr);

1460 type expected after new
A new expression requires a type. (e)

p = new;

1461 type expected for ...
No type found in declaration of a variable. (e)

1462 type expected in template parameter
This could indicate a misspelling of a template parameter. (e)

template<classT> ...;

1463 type expected in arg-declaration-clause
An argument type is missing in a function declaration. (e)

class bar {
    foo(imt);
};

1464 type expected in cast
Found something that was not a type in a cast expression. (e)

1465 type expected
Found an expression that was not a type where a type was expected. (e)

1466 type in new expression can't be string
A type in a new expression cannot be pascal or asm.

1467 type in new expression may not contain class/struct/enum declarations
Cannot declare types in a new expression. Nor can the types used in a new expression be const, volatile, pascal or asm. The type used must be completely specified and cannot have pure virtual functions. (e)

void *p = new enum foo { bar };

1469 unknown language string in linkage specifier: ...
Only "C" and "C++" allowed in linkage specifiers. (e)

extern "F77 { // Don't know anything about F77 linkage}

1477 already const
A variable was declared const more than once. (w)

int * const const foo;

1479 comma at end of enumerator list ignored
A superfluous comma at the end of a list of enumerators was ignored. (w)

enum foo { bar, };

1480 enumerators can't have external linkage
extern cannot be specified for enum declarations. (e)

extern enum foo { bar };

1481 function function-name not declared
If the -Xforce-declarations option is used, the compiler will generate this error message when a function is used before it has been declared. (w)

1484 missing declarator in typedef
No declarator was given in a typedef statement. (e)

typedef class foo {
    // ...
};

1485 old style function definition
A function was defined using the older K & R C syntax. This is invalid in C++. (w)

int foo(a, b)
int a, b
{
    ...
}

1486 initializer that is a brace-enclosed list may contain only constant expressions
A variable was initialized using a brace-enclosed list containing an expression (such as a variable) that cannot be evaluated during compilation.

int i = 12;
...
int x[] = { 1, 2, 3 , i };
This is allowed in C++ but not in C.

1488 redeclaration of parameter identifier
One of a function's parameters is shadowed by a declaration within the function, (w) if -Xpcc or -Xk-and-r, (e) otherwise.

f1(int a) { int a; ... }

1489 redundant semicolon ignored
Found an extra semicolon among the members of a function. (w)

class A {
    int a;
    ;
};

1492 virtual specified both before and after access specifier
Syntax error. (w)

class A {};
class B : virtual public virtual A {};

1493 redeclaration of ...
A function has been redeclared to something else. (e)

int i(int);
double i(int);
double i( int i) {...}

1494 non-extern object identifier of type type-designator must be initialized
This message may indicate that a const member of a class/structure/union was not initialized. (e)

class C {
    const int ci;
} c;

1495 non-extern const object name must be initialized
A const object must be initialized unless it is extern.

const char c;

1497 too many declaration levels
An internal stack overflowed. This is unlikely to happen in the absence of other errors. (f)

1498 internal table-overflow
Internal stack overflowed. May occur with extremely complex, deeply nested code. To work-around, simplify or modularize the code. If the problem does not appear to be a consequence of some earlier error, please report it to Wind River. (f)

1504 arglist in declaration
An old style function declaration is found in the wrong context. (w)

f1() { int f2(a,b,c); ... }

1507 end of memory
Ran out of virtual memory during compilation. The compiler first attempts to skip some optimizations in order to use less memory, however this error can occur for large functions on machines with limited memory. Note: initialized arrays require the compiler to hold all initial data and can contribute to this error. If the problem does not appear to be a consequence of some earlier error, please report it to Wind River. (f)

1509 expression involving packed member too complicated
This indicates that the processor does not support "compound assignment" for volatile members of packed structures.

struct1.a |=3; // May have to use struct1.a = struct1.a|3

1511 can't access short or int bitfields in packed structures unless the architecture supports atomic unaligned accesses (-Xmin-align=1)
Packed structures cannot contain bit-fields unless the architecture support atomic unaligned access. To see if the architecture supports atomic unaligned access, compile a file with the -S option and then examine the .s assembly file. Look for the -X93 option in the header. If X93=1, the architecture supports atomic unaligned access. (e)

#pragma pack(1)
struct S {
    int j:3;
};

1513 byte swapped structures can't contain bitfields
Bit-fields are not allowed in byte-swapped structures. (e)

#pragma pack (,,1)  // Byte swap
struct s {
    int j:3;
}

1515 profile information out of date
The file given with the -Xfeedback option is out of date or has an old format. Re-compile with the -Xblock-count option and create a new profiling file. (e)

1516 parameter parameter name is never used
A parameter to a function is not used. This message appears if the -Xlint option is used. (w)

fun(int i){};

1517 function function name is never used
A function was declared but not used. This message appears if the -Xlint option is used. In the example, the file consists of one line. (w)

static fun();

1518 variable identifier is never used
A variable is never used. This message appears if the -Xlint option is used. (w)

fun(){
    int i;
}

1519 expression not used
The compiler has detected all or part of an expression which will never be used. (w)

a+b;            /* statement with no side effects */
a=(10,b+c);     /* 10 is not used */
*s++;           /* the '*' is not needed: s++; /

Note: the compiler will not issue this warning for an expression consisting solely of a reference to a volatile variable.

1521 missing return expression
A function is defined with a return type, but does not return a value. This message appears if the -Xlint option is used. (w)

float fun(){
    return;
}

1522 statement not reached
A statement can never be executed. This message appears if the -Xlint option is used. (w)

main(){
    int never;
    return 0;
    never=6;
}

1523 can't recognize storage mode unknown
The storage mode specified in an asm macro is unknown. See Embedding assembly code, p.149 for more details. (e)

1524 too many enhanced asm parameters
There can be a maximum of 20 parameters and labels used in an asm macro. See Embedding assembly code, p.149 for details.

1525 Identifier identifier not declared
An identifier was not declared. (e)

fun(){
return i;  
}

1526 asm macro line too long
A very long line was given in an asm macro. See Embedding assembly code, p.149 for more details. (e)

1528 can't initialize variable of type type_designator
Some types do not allow initialization. (e)

void a = 1;

1534 only first array size may be omitted
The size of the first dimension of an array can be omitted; all others must be specified. (e)

int x[3][];

1535 illegal width of bitfield
A bit-field width is greater than the underlying type used for the bit-field. (e)

Example for a target with 32 bit integers:

struct { int i:33; }

1536 bitfields must be int or unsigned
The compiler detected an unsupported bit-field type. (e)

struct { float a:4; };

1541 redeclaration of struct/union/enum ...
A struct, union, or enum tag name was used more than once: (e)

struct t1 { ... }; struct t1 { ... };

1542 redeclaration of member variable name
A member has been declared more than once. (e)

struct{
    int i;
    int i;
};

1543 negative subscript not allowed
The size if an array cannot be negative. (e)

int ar[-10];

1544 zero subscript not allowed
An array of zero size cannot be declared when compiling for strict ANSI C (-X7=2, or -Xdialect-strict-ansi). (w)

int x[0];

1546 dangerous to take address of member of packed or swapped structure
Using the address of a packed or byte-swapped structure is not recommended. (w)

#pragma pack (2,2,1)
. . .
ptr = &(struct1.i);

1547 can't take address of object
Trying to take the address of a function, constant, or register variable that is not stored in memory. (e)

register int r; fn(&r);

1548 can't do sizeof on bitfields
The sizeof function does not work on bit-fields. (e)

struct {
    int j:3;
} struct1;
i = sizeof(struct1.j);

1549 illegal lvalue
Only certain expressions can be on the left hand side of an assignment. (e)

a+b = 1;
(a ? b : c) = 2;    /* not valid in C modules*/

1550 can't push identifier
It is invalid to use an expression of type function or void as an argument. (e)

void *pv; int (*pf)(); fn(*pv,*pf);

1551 argument type does not match prototype
The type of an argument to a function is not compatible with its type as given in the function's prototype. (w) if -Xpcc or -Xk-and-r or -Xmismatch-warning, (e) otherwise.

int f(char *), i; ... i = f(&i);

1552 wrong type of initializer
The type of an initializer is not compatible with the type of the variable, (w) if -Xpcc or -Xmismatch-warning, (e) otherwise.

char c; int *ip = &c;

1553 too many errors, good bye
The compiler has found so many errors that it does not seem worthwhile to continue. (f)

1554 illegal type(s): type-signatures
The operators of an expression do not have the correct or compatible types, (w) if -Xpcc or -Xk-and-r or -Xmismatch-warning, (e) otherwise. This message may also indicate an attempt has been made to find the sum of two pointers.

int *pi, **ppi; ... if (pi == ppi) ... 
#illegal types: ptr-to-int '==' ptr-to-ptr-to-int

int *p, *q;
p = p + q;   // Attempt to add pointers
#illegal types: ptr-to-int '+' ptr-to-ptr-to-int

1555 not a struct/union reference
The left hand side of a '->' or '.' expression is not of struct or union type. If -Xpcc is specified the offset of the given member name in another struct or union is used. (w) if -Xpcc, -Xk-and-r, or -Xmismatch-warning, (e) otherwise.

1556 volatile packed member cannot be accessed atomically
For the selected processor, a packed member cannot be accessed atomically if it is volatile. (w)

#pragma pack(1, 1)

struct {
    volatile int v;
} s;
s.v =3;              /* generates error 1556 */

1560 unknown pragma
The pragma is not recognized. (w)

#pragma tist

1561 unknown option -Xunknown
The compiler was started with an -X option that is not recognized. (w)

1562 bad #pragma use_section: section section name not defined
A #pragma use_section command has not been correctly given. (w)

#pragma section DATA3  // Correct
#pragma use_section x  // Omitted section class name DATA3

1563 bad #pragma [ name ]
If issued without the name, the compiler did not recognize the pragma. If issued with a name, there is a problem with either the operands to the pragma or the context in which it appears. (w)

1564 bad #pragma pack
The #pragma pack statement is not correct. (w)

#pragma pack(1,2,3,4) // Takes up to three arguments

1565 illegal constant in #pragma pack
An invalid constant has been used in a pack pragma. (w)

#pragma pack(7) // Must use powers of 2 for alignment

1566 to 1572 obsolete messages
Messages numbered 1566 to 1572 should not appear because they refer to obsolete features.

1573 user's error string
Error number 1573 can be used to display any string the user chooses when:

  • the compiler compiles this file, by use of #pragma error string

#pragma error Now compiling test.c; // compilation continues

  • the compiler stops because of an error, by use of error string:

#error        // This terminates the compilation process

1574 can't open file for input
The given file cannot be opened. (f)

1575 can't open file for output
The given file cannot be opened. (f)

1577 can't open profiling file file
The file given with the -Xfeedback=file option cannot be opened. (w)

1578 profile file is of wrong version (file)
The file given with the -Xfeedback option is out of date or has an old format. Re-compile with the -Xblock-count option and create a new profiling file. (e)

1579 profile file file is corrupted
The file given with the -Xfeedback option is corrupted. Re-compile with the -Xblock-count option and create a new profiling file. (e)

1580 can't find current module in profile file ...
No data about the current source file is available in the profiling file. (w)

Possible causes:

  • No function in the current file was actually executed during profiling.

  • The profiling file belongs to another executable program.

1584 illegal declaration-attribute
A declaration contains an invalid combination of declaration specifiers. (w)

unsigned double foo;

1585 global register register name is already used
The global register has already been reserved. (w)

#pragma global_register counter = r14
#pragma global_register kounter = r14

1586 cannot use scratch registers for global register variables
Scratch registers cannot be used for global register variables. (w)

#pragma global_register counter=scratch-register-name

1587 global register register-name is invalid
Found an unrecognized register name in a global_register pragma. (w)

1588 no .cd file specified!
The target description (.cd) file was not specified. The compiler reads a target description file during initialization (see "Targets," Table 2-2, Version_path subdirectories and important files, p.13). Normally, when the dcc command is given, the .cd file is automatically specified. To find out the .cd file name for your selected target configuration, run dcc with the -# option to display all of the commands generated, and look at the -M option for the ctoa program. (f)

Likely causes:

  • The compiler is not installed properly.

  • One of the compiler files has been deleted, hidden, or protected.

  • The dtools.conf or other configuration file is incorrect.

1589 can't open .cd file!
See error 1588 for a description of the .cd file and likely causes.

1590 .cd file is of wrong type!
See error 1588 for a description of the .cd file and likely causes.

1591 .cd file is of wrong version!
See error 1588 for a description of the .cd file and likely causes.

1592 .cd file file too small?!
See error 1588 for a description of the .cd file and likely causes.

1593 write error
Write to output file failed. (f)

1595 illegal arg to function name
The compiler has detected an internal error. May result from other errors reported earlier. If the problem does not appear to be a consequence of some earlier error, please report it to Wind River. (f)

1596 test version of compiler: File is too big!
This error is generated when certain limits in an evaluation copy of the compiler are exceeded. (f)

1597 test version of compiler: Can't continue!
This error is generated when certain limits in an evaluation copy of the compiler are exceeded. (f)

1598 no matching asm pattern exists
While scanning an asm macro, no storage-mode-line matching the given parameters was found. See Embedding assembly code, p.149 for details.

1599 expression too complex. Try to simplify
Can occur if an expression is too complex to compile. Should not happen on most modern processors. Can occur on a processor with few registers and no built-in stack support. (f)

1600 no table entry found!
The compiler has detected an internal error. May result from other errors reported earlier. If the problem does not appear to be a consequence of some earlier error, please report it to Wind River. (f)

1601 address taken in initializer (PIC)
Position-independent code. A static initializer containing the address of a variable or string has been found when generating position-independent code. Such address values cannot be position-independent. (w) or (e) depending on whether -Xstatic-addr-warning or -Xstatic-addr-error is used.

1602 variable ... is incomplete
A variable is defined with a type that is incomplete. (e)

struct a;
struct a b;

1603 logic error in internal-identification
The compiler has detected an internal error. May result from other errors reported earlier. If the problem does not appear to be a consequence of some earlier error, please report it to Wind River. (f)

1604 useless assignment to variable identifier. Assigned value not used
The variable assignment has no effect, since the assigned value is not used. This message appears if the -Xlint option is used. (w)

fun(){
    int i=1;
}

1605 not enough memory for reaching analysis
Certain optimizations, called "reaching analysis", will be skipped if the host machine cannot provide enough memory to execute them. The compiler continues, but produces less than optimal code. (w)

1606 conditional expression or part of it is always true/false
A conditional test is made, but the results will always be the same. This message appears if the -Xlint option is used. (w)

int main(){
    int i = 3;
    if (i < 6)
        return 4;
}

1607 variable name is used before set
During optimization, the compiler discovers a variable that is used before it is set. (w)

func() { int a; if (a == 0) ... }

1608 variable identifier might be used before set
A variable may have been used before it was given a value. (w)

fun(){
    int i,j;
    i = j;    // j is used before set
}

1609 illegal option -Dinvalid_name
The preprocessor was invoked with the -D option and an invalid name. Names must start with a letter or underscore. (w)

1611 argument list not terminated
The end of the source file was found in a macro argument list. (w) if -Xpcc, (e) otherwise.

1612 EOF inside #if
The source file ended before a terminating #endif was found to match an earlier #if or #ifdef. If not caused by a missing #endif, then it is frequently caused by an unclosed comment or unclosed string. (w) if -Xpcc, (e) otherwise.

1617 syntax error in #if
The expression in an #if directive is incorrect, (w) if -Xpcc, (e) otherwise.

#if a *

1618 too complex #if expression
The expression in an #if directive overflowed an internal stack. This is unlikely to happen in the absence of other errors, (w) if -Xpcc, (e) otherwise.

1619 include nesting too deep
The preprocessor cannot nest header files deeper than 100 levels, (w) if -Xpcc, (e) otherwise.

1621 can't find header file unknown
The preprocessor cannot find a file named in an #include directive. (w) if -Xpcc, (e) otherwise.

1622 found #elif, #else, or endif without #if
Found an #elif, #else, or #endif directive without a matching #if or #ifdef. (w) if -Xpcc, (e) otherwise.

1623 bad include syntax
The #include directive is not followed by '<' or '"' or the file name is too long. (w) if -Xpcc, (e) otherwise.

1624, 1625 illegal macro name
illegal macro definition
Macro names and arguments must start with a letter or underscore, (w) if -Xpcc, (e) otherwise.

1626 illegal redefinition of macro_name
__LINE__, __FILE__, __DATE__, __TIME__, defined, and __STDC__ cannot be redefined, (w) if -Xpcc, (e) otherwise.

1627 macro macro name redefined
The macro was previously defined. (w)

#define PI 3.14
#define PI 3.1416

1629 undefined control
Undefined or unsupported directive found after #, (w) if -Xpcc, (e) otherwise.

#pragmo

1630 illegal assert name
An #assert name must be an identifier and must be preceded by a '#' character, (w) if -Xpcc, (e) otherwise.

1631 macro identifier: argument mismatch
Either too few or too many arguments supplied when using a macro, (w) if -Xpcc, (e) otherwise.

#define M(a,b) (a+b)
i = M(1,2,3);  

1632 recursive macro macro name
A recursive macro has been detected. The error occurs when the macro substitution occurs, line 4 in this case: (e)

#define max(A,B) A>B ? A : max(A,B)
main(){
    int i=1,j=2,k;
    k = max(i,j); // Reports error for this line.
}

1633 parse error
The complier was not able to parse the expression. (e)

x = multiply(y, ); // Comma, but no second argument
main(}             // Typed } instead of )

1635 license error: error message
An error occurred when checking the license for Wind River software tools. The error message describes the problem (no server for this feature, etc.). Please refer to the Diab C/C++ Getting Started manual or contact Wind River technical support. (f)

1638 illegal error level error level in option option name
The -exn option was used with an invalid error level. The -e option is used for increasing the severity of error messages for a particular error. (w)

dcc -e99 test.c // 99 is invalid error level

1640 illegal error message number message number
The -exn option was used with an invalid error message number. The -e option is used for increasing the severity of error messages for a particular error. (w)

dcc -ew10000 test.c // There is no message number 10000

1641 cannot reduce severity of error message number below error level
For some messages, the -e option cannot be used to decrease the severity level below a fixed minimum. (w)

dcc -ew1614 test.c
warning (dcc:1641): Cannot reduce severity
of message 1641 below "error"

1643 narrowing or signed-to-unsigned type conversion found: type to type
A type conversion from signed to unsigned, or a narrowing type conversion has been found. This message appears if the -Xlint option is used. (w)

main(){
    int i;
    char c;
    c = i;
}

1647 non-string method invocation expression on string object expression
This error indicates a mismatch between an invocation and the declaration of a method. For example, non-const method invocation in const object. Methods of const objects must be const.

class C {
    int i;
public:
    f() { i = 12; }
    C() {}
};  

const C c;

main() {
    c.f();
}

"x.cpp", line 11: error (1647): non-const method
invocation f() on const object c

1650 no profiling information found in database database name
This applies to programs compiled and run in the RTA (Wind River's suite of Run-time Analysis tools). (w) A program was compiled with the option -Xprof-feedback=database directory, and the profiling information was not found in the database directory. The normal sequence of events is:

    1. A program is compiled with an -Xprof-type option that adds profiling code to the program.

    2. The program is run and profiling information is collected using the RTA.

    3. The program is compiled with the -Xprof-feedback option, and the compiler uses the profiling information to optimize the code.
Possible causes of the error:

    • The wrong database directory was specified.

    • The database does not contain profiling data.

1651 can't find profiling information for function in database
A program was compiled with the option -Xprof-feedback=database directory, and the profiling information was not found for the function. See error 1650, above, for a brief explanation of the situations where this error occurs. (w)

Possible causes of the error:

  • The module was not compiled with an -Xprof-type option that would add code for instrumentation.

  • The program was not run, and so profiling data was not collected.

1657 initializer method name initializes neither a direct base nor a member
Only classes that are direct bases or virtual bases can be used in a member initializer. (e)

struct A { A(int); };
struct B : public A { B(int); };

struct C : public B {
    C(int i) : A(i) {} // Can't initialize A here
};

1663 inline of function does not occur in routine function - try increasing value of -Xinline
This warning is generated whenever the inline keyword is specified but the compiler does not inline the function. Increasing the value of -Xinline or -Xparse-size can help, but there are other reasons for not inlining a function.

1665 long long bitfields are not supported
long long cannot be used with bit-fields. (w)

struct {
    long long story:3;
}

1671 non-portable behavior: operands of type are promoted to unsigned type only in non-ANSI mode
When a non-ANSI compilation mode is used, for example, -Xpcc, this warning appears when the compiler selects an unsigned integral type for an expression which would have been signed under ANSI mode. This message appears if the -Xlint option is used. Use -Xlint=0x200 to suppress this message. (w)

1672 scope of tag tag is only this declaration/definition
The tag referred to in a parameter list does not have a prior definition. (w)

/* struct bar does not have a definition before this point */
foo(struct bar a);

1674 template argument argument should be pointer/reference to object with external linkage
Arguments for template functions need to be pointers or references to objects with external linkage. (e)

template <class T, int& Size>
class Base {
....
};

class A {
...
} ;

static int local_linkage_int;

Base<A, local_linkage_int> ob;

1675 sizeof expression assumed to contain type-id type-id (use `typename')
When a type-id is used in a sizeof expression, the compiler assumes that this is intened; otherwise a typename should be used instead. (w)

template <class T, int& Size>
class Base {
...
    void incr()
    {
        Size = Size + sizeof(A);
    }
...
};

1676 class class is abstract because it doesn't override pure virtual function
A class that has unoverridden pure virtual functions is an "abstract class" and cannot be instantiated. (i)

1677 executable executable name not found in profiling database database name
This applies to programs compiled and run in the RTA (Wind River's suite of Run-time Analysis tools). (w) The specified executable was not found.

1678 snapshot snapshot name not found in profiling database database name
This applies to programs compiled and run in the RTA (Wind River's suite of Run-time Analysis tools). (w) The snapshot containing profiling information was not found.

1679 no definition found for inline function function
The template member function referred to has no definition. (w)

1680 delete called on incomplete type type
The delete operator is called on a pointer to a type whose full declaration has been deferred. (w)

1682 `(unsigned) long long' type is not supported by the ANSI standard
The ANSI standard does not support the long long type. (w; future error)

long long x;

1683 non-int bitfields are not supported by the ANSI standard
The ANSI standard allows bit-fields of integer type only. (w; future error)

struct foo {
    char x:2;
};

1684 vector must occur before any other type specifiers
This message is specific to the AltiVec target. The vector keyword should occur before any other type specifier. (e)

int vector b;

1685 pixel can only be specified as part of a vector type
This message is specific to the AltiVec target. The pixel keyword cannot be used for declarations outside a vector type. (e)

vector b;
pixel c;

1686 long keyword for vector types is deprecated
This message is specific to the AltiVec target. The long keyword for vector types has been deprecated. (w)

vector long b;

1687 vector pixel should have no other type specifiers
This message is specific to the AltiVec target. No other types are allowed in the declaration of a vector pixel. (e)

vector unsigned short pixel a;
vector unsigned int pixel b;

1688 vector float cannot have bool specifier
This message is specific to the AltiVec target. A vector float cannot have a bool specifier. (e)

vector float bool c;

1689 vector name is an invalid vector type
This message is specific to the AltiVec target. An invalid vector type is defined. (e)

struct X
{
    int a;
};

vector struct X checking;

1691 vec_step is only valid for vector types
This message is specific to the AltiVec target. vec_step can be called only with vector types. (e)

int j = vec_step(char const);

1692 vector initialization may only contain constants
This message is specific to the AltiVec target. A vector initialization should contain constants only. (e)

int c;
vector int A = (vector int)(1, c, 3, 4);

1693 vector initialization - not enough initializer constants
This message is specific to the AltiVec target. Too few initializer constants are specified for a vector. (e)

vector int A = (vector int)(1, 2, 3);

1694 vector initialization - too many initializer constants
This message is specific to the AltiVec target. Too many initializer constants are specified for a vector. (e)

vector int A = (vector int)(1, 2, 3, 4, 5, 6);

1695 vector arguments can only be passed to vector intrinsics or functions with prototypes
This message is specific to the AltiVec target. Vector arguments can be sent only to intrinsic functions or functions that have already been defined or declared. (e)

vector int A;

/* foo has no definition or prototype till this point
   and is not an intrinsic function */
foo(A);

1696 intrinsic function name must have n argument(s)
The number of arguments passed to an intrinsic function is incorrect. (e)

int a, b;
...
a = __ff1(a, b);

1697 invalid types on arguments to intrinsic function name
An argument of an invalid type is passed to an intrinsic function. (e)

char *ptr;
int a;
...
a = __ff1(ptr);

1698 the number i argument to intrinsic function name must be an unsigned constant less than n
This message is specific to the AltiVec target. The argument passed to the intrinsic function should be less than the specified value. (e)

int a;
vector unsigned long B, C;
...
C = vec_splat(B, a);

1699 the number i argument to intrinsic function name must be a signed constant between n and m
This message is specific to the AltiVec target. The argument passed to the intrinsic function should be within the specified range of values. (e)

1700 implicit intrinsic function name must have n argument(s) - when the intrinsic is enabled, optional user prototype must match
When an enabled intrinsic function is redefined, the number of arguments must be the same. (e)

unsigned int __ff1(unsigned int x, unsigned int y)
{
    ...
}

1701 invalid types on prototype to intrinsic function name - when the intrinsic is enabled, optional user prototype must match
When an enabled intrinsic function is redefined, the prototypes must match. (e)

unsigned int __ff1(int a)
{
    ...
}

1702 prototype return type of intrinsic function name should be type - when the intrinsic is enabled, optional user prototype must match
When an enabled intrinsic function is redefined, the return type must match. (e)

void __ff1(unsigned int a)
{
    ...
}

1703 function name matches intrinsic function name - rename function or disable the intrinsic with -Xintrinsic-mask
A function with the same name as an intrinsic function has been defined. The function should be renamed or intrinsic functions should be disabled. (w)

unsigned int __ff1(unsigned int x)
{
    ...
}

1704 structure or union cannot contain a member with an incomplete type
Structures or unions should not contain fields of incomplete type. (w; future error)

struct x
{
    void a;
};

1707 invalid pointer cast/assignment from/to __X mem/__Y mem
The pointer assignment is invalid because it is between locations in two different memory banks. (e)

1708 cannot take address of an intrinsic function
An intrinsic function, which represents a specific CPU instruction, has no location in memory.

1709 Unsupported GNU Extension : inline assembler code
The compiler does not translate extended GNU inline assembler syntax (such as register usage specification). (e)

1710 macro macroname: vararg argument count does not match. expected n or more but given m
Too few arguments are passed to a vararg macro. (w)

#define TEST_INFO_1(fmt, val, ...) printf(fmt, val, __VA_ARGS__)
...
TEST_INFO_1("val1 = %d, val2 = %d", 12);

1711 undefined identifier identifier used in constant expression
An undefined macro name occurs in a #if preprocessor directive. To disable this warning, use -Xmacro-undefined-warn. (w)

#if (FooDef1 == FooDef2)
# ...
#endif

1712 only vector literals may be used in vector initializations
Vectors can be initialized only with vector constants. (e)

vector int a[2] = {1, 2};

1713 invalid assert name name

1714 invalid macro name name

1715 no input file given

1716 memory unavailable

1717 unterminated comment

1718 unterminated character or string constant

1719 duplicate parameter name param in macro macro

1720 implict include file "file" not found

1721 missing `>' in `#include <filename> syntax'

1722 junk after `#include <filename>'

1723 junk after `#include \"filename\"'

1724 `#include' exptects <filename> or \"filename\"

1725 #if nesting too deep

1726 #include file nesting too deep. possible recursion

1727 unmatched condition. block starts on line n

1728 unmatched condition

1729 unbalanced condition

1730 undefined control after expr

1731 EOF inside #... conditional

1732, 1733 illformed macro parameter list in macro macro

1734 invalid macro name name

1735 invalid argument to macro

1736 illformed macro invocation

1737 invalid assert name name

1738 `##' at start of macro definition

1739 `#' precedes non macro argument name or empty argument

1740 macro macro: argument count does not match. expected n but given m

1741 redefinition of macro macro. previously defined here

1742 predefined macro macro redefined

1743 empty token-sequence in `#assert'

1744 no closing `)' in `#assert'

1745 garbage at the end of `#assert'

1746 invalid number in #line

1747 only a string is allowed after #line <num>

1748 string expected after #error

1749 string expected after #ident

1750 # directive not understood

1751 `defined' with out an identifier

1752 no closing `)' in `defined'

1753 bad digit in number

1754 bad number in #if...

1755 floating point number not allowed in #if...

1756 wide character constant value undefined

1757 undefined escape sequence in character constant

1758 empty character constant

1759 multi-character character constant

1760 octal character constant does not fit in a byte

1761 hex character constant does not fit in a byte

1762 character constant taken as unsigned

1763 garbage at the end of condition argument

1764 illegal identifier identifier in condition

 Additional C++ messages  

The C++ compiler generates additional messages and diagnostics that are not documented here.

Assembler messages

Assembler messages have the format:

"file", line #: severity: message

Three kinds of messages are generated. The severity values for each as they appear in messages are as follows.

Table I-2   Assembler message severity codes 

warning  

Warning: a message will be printed, assembly will continue, and an output file will be produced.  

error  

Error: a message will be printed, assembly will continue, but no output will be generated.  

fatal  

Fatal: a message will be printed and assembly aborted.  

Assembler messages are intended to be clear in the context of the error and are not listed here. Please report unclear assembler error messages to Customer Support.

Linker messages

Linker messages have the format:

DLD.EXE: message

Where relevant, the file and line are included in the message.

 

support@windriver.com
Copyright © 2002, Wind River Systems, Inc. All rights reserved.