Mode: ANSI 3.5.2.1

Error 1582

An identifier appears more than once in a function's parameter list. For example,

void func (parm1, parm2, parm2)
  int  parm1, parm2, parm3;
{ }

Mode: ANSI 3.5

Error 1584

This error occurs when the types of a variable or function definition and a variable or function declaration do not match. For example,

main() {
    char func();
    printf("%s\n",func());
}
char *
func() {
  return("absH");
}

Mode: ANSI 3.1.2.6

Error 1586

This error occurs when a function has been defined more than once. For example,

func() { }
main() {
    int func();
}
func() { }

Mode: ANSI 3.7

Error 1587

A structure or union tag is redeclared with members. For example,

struct x {
    int a;
};
struct x {
    int b;
};

Mode: ANSI 3.5.2.3

Error 1588

Your program uses an identifier before it has been declared. For example,

main() {
  i = 3;
  j = i;
}

main() {
  int i, j;
  i = 3;
  j = i;
}

Error 1589

An identifier is used as a function designator when it was not declared as a function. For example,

extern int f;
main() {
    printf( "%d\n", f() );
}

extern int f();
main() {
  printf( "%d\n", f() );
}

Error 1590

This error is caused by using an identifier as if it were a type name when it was never defined as a type. For example,

int i;
typedef i;
i x;

typedef float i;
i x;

Error 1592

A label is declared more than once in a function. For example,

main() {
  int j;
  goto LABEL;
LABEL: j = 100;
LABEL: j = 101;
}

main() {
    int j;
    goto LABEL;
 LABEL_1: j = 100;
 LABEL:   j = 101;
}

Error 1594

The operand of the sizeof operator is unknown to the compiler. For example:

i = sizeof (struct x);

Mode: ANSI 3.3.3.4

Error 1595

A structure or union tag is redeclared with members. For example,

struct x { int member_a; }
struct x { int member_b; }

Mode: ANSI 3.5.2.3

Error 1596

Your program attempts to define a type to be a function definition or attempts to define a function definition to be a type. For example,

typedef f(){return 7;} F7;
typedef int func() { }

typedef int (*PG8)();

Mode: ANSI 3.5

Error 1597

You attempted to initialize a long pointer.

If you really want a long pointer, make the assignment in a separate statement. Otherwise, change the ^ to *.

Mode: ANSI Long pointers are an extension to ANSI C.

Error 1599

The type of an initializer for a function pointer is not integer, pointer, or function. For example,

struct {
   int (*q)();
   int g;
}func;
int (*f)() = func;

int (*f)() = func.q;

Error 1600

The type of an initializer is not compatible with the type of the object it is initializing. For example,

char f = 'a';
char * title = f;

char * title = (char *)f;

Error 1601

An object with integral type is being initialized with a pointer. For example,

int p;
int x = <esc|&p|;

int p;
int x = (int)<esc|&p|;

int x = p;

Error 1602

A structure of unknown size is being initialized. For example, struct y below has not been defined:

struct y z = {0,1,2};

struct y {
   int a,b,c;
} z = {0,1,2};

Error 1603

The types of the operands are illegal in combination with the indicated operator. For example,

float f = 3.44;
char * title1 = f;
struct { int i; char *cptr; } w, arr[4];
char *y;
w = y;
w = arr;

float f = 3.44;
char * title2 = (char *)f;
struct { int i; char *cptr; } w, arr[4];
char *y
w.cptr = y;
w = arr[2];

Error 1608

An argument to a function call has been cast to type void. Since the cast to void effectively discards the value, you are actually passing nothing.

Remove the void cast.

Mode: ANSI 3.2.2.2

Error 1610

A function whose return type is void has a return statement with an expression. For example,

void f()
{ return 23; }

f()
{ return 23; }

void f()
{ return; }

Error 1612

The declaration for a structure field specifies more bits than the field type will allow. For example:

struct S {
  int   af : 10; /* OK. int is 32 bits long*/
  char  bf : 10; /* Not OK; char type = 8 bits. */
  char  bf :  4; /* OK. */
  short cf : 20; /* Not OK; short type = 16 bits. */
} st;

Mode: ANSI 3.5.2.1, A.6.5.8

Error 1613

Your program defines a structure that fails to specify at least one member with a nonzero size. For example:

struct s {
  struct {
    int i;
    int j;
  };
  struct {
    int b: 0;
  } st;
} SS;

Mode: ANSI 3.5.2.1

Error 1614

Your program defines a union without at least one member of nonzero size. For example,

union {
  struct {
    int b;
    char c;
  };


  struct {
    int b : 0;
  } s;
} un;

Mode: ANSI 3.5.2.1

Error 1615

For example:

printf("This is a string\n" , );

Do not omit an argument in a function call.

Mode: ANSI 3.3.2

Error 1616

The compiler cannot open the file file_name to read information about intrinsics appearing in the #pragma intrinsic directive. This error is issued when an intrinsic pragma is seen. If no intrinsics are declared in a file, the existence of the intrinsic file is not checked. For example, assuming /no_root/no_file does not exist,

#pragma intrinsic FOPEN
  /*The default file /usr/lib/sysintr is used  */
#pragma intrinsic_file "/no_root/no_file"
#pragma intrinsic MYINTRINSIC
  /* The error is issued here.  If this  */
  /* declaration was not here, no attempt would  */
  /* be made to access "/no_root/no_file"  */

Error 1617

Information about func_name is not contained in the current intrinsic file file_name that the compiler is using.

Check the spelling of the intrinsic in the intrinsic pragma. Make sure the correct intrinsic file is current. For example,

#pragma intrinsic_file "myfile"
#pragma intrinsic myfunc1, myfunc2, myfunc3
#pragma FOPEN, FCLOSE, FWRITE

#pragma intrinsic_file ""

Error 1619

More arguments appear in a call to an intrinsic than are correct for that intrinsic.

Remove the unnecessary arguments from the argument list on the call.

Error 1620

An argument to an intrinsic function, argument number, is not the proper type and cannot be converted to the proper type.

Pass the proper type argument in the number position. It is unlikely that a simple cast can be used to convert the argument to the correct type, as the compiler will first attempt to convert the argument to the proper type when an intrinsic function is called.

Error 1621

Fewer actual arguments appear in a call to an intrinsic than are correct for that intrinsic.

Insert the necessary arguments into the argument list in the call.

Error 1622

A parameter to an intrinsic function, parameter number, requires an alignment that cannot be specified by HP C. This error occurs on the line of the intrinsic pragma, not the line of a call.

The specified intrinsic cannot be called from HP C as an intrinsic. Remove the intrinsic pragma. If you defined the parameter alignment in an intrinsic file (using Pascal/HP-UX), relax the alignment requirement of the parameter, if feasible. It is still possible to call the function, but not as an intrinsic.

Error 1623

The intrinsic function func_name returns a type that cannot be specified by HP C. This error occurs on the line of the intrinsic pragma, not the line of a call.

The specified intrinsic cannot be called from HP C as an intrinsic. Remove the intrinsic pragma. If you defined the return type in an intrinsic file (using Pascal/HP-UX), modify the return type to one that maps into HP C, if feasible. It is still possible to call the function as an external, but not as an intrinsic.

Error 1624

A parameter to an intrinsic function, parameter number, requires a type that cannot be specified by HP C. This error occurs on the line of the intrinsic pragma, not the line of a call.

The specified intrinsic cannot be called from HP C as an intrinsic. Remove the intrinsic pragma. If you defined the parameter type in an intrinsic file (using Pascal/HP-UX), modify the type to one that maps into HP C, if feasible. It is still possible to call the function, but not as an intrinsic.

Error 1625

A parameter to an intrinsic function, parameter number, requires a call method that cannot be specified by HP C. This error occurs on the line of the intrinsic pragma, not the line of a call.

The specified intrinsic cannot be called from HP C as an intrinsic. Remove the intrinsic pragma. If you defined the parameter call method in an intrinsic file (using Pascal/HP-UX), modify the call method to one that maps into HP C, if feasible. It is still possible to call the function, but not as an intrinsic.

Error 1626

The file the compiler is currently using to gather information on intrinsics exists but cannot be read properly.

If you are reading your own intrinsic file (created by the Pascal/HP-UX compiler), try rebuilding the file.

Error 1627

When switching to a new intrinsic file (via the intrinsic_file pragma), or at the end of compilation, the intrinsic file currently open cannot be closed.

Verify that the intrinsic file is valid.

Error 1628

An argument to an intrinsic function, argument number, is an address of some variable that is not the same size expected by the intrinsic. For example, a pointer to a 24-character array is passed when a pointer to a 48-character array is expected. This error can only occur when passing "generic" structures (struct, union, array) to the intrinsic by reference.

Pass an address of a correct size variable in the number position, a variable at least the size of the one expected by the required intrinsic. Casting a pointer to point to an object of the correct size will eliminate this error. However, this is unlikely to be the proper solution because the data will be stored at the address as if the size were correct.

Error 1629

A call to an intrinsic function appears in a file before the intrinsic pragma which declares the function.

Move the intrinsic pragma declaring the function before any call to the function. It is a good idea to put all intrinsic pragmas at the start of a file for this reason, to avoid other errors and warnings about problems such as mismatched return types, that arise from the mixed use of extern and intrinsic pragma declarations.

Error 1630

A parameter to an intrinsic function, parameter number, has a default value longer than the current maximum allowed by HP C--eight bytes. This error occurs on the line of the intrinsic pragma, not the line of a call.

The specified intrinsic cannot be called from HP C as an intrinsic. Remove the intrinsic pragma. If you defined the parameter default value in an intrinsic file (using Pascal/HP-UX), modify the size of the default value to be less than or equal to eight bytes, if feasible. It is still possible to call the function, but not as an intrinsic.

Error 1631

An argument to an intrinsic function, argument number, is not the proper size. This error can only occur when passing a generic structure (struct, union) to an intrinsic by value.

Pass an argument of the proper size in the number position.

Error 1632

An argument to an intrinsic function, argument number, is an address of some variable that is not the same type expected by the intrinsic. For example, a pointer to a short int is passed when a pointer to an int is expected.

Pass an address of the correct type of variable. Casting to the correct pointer type will eliminate this error. However, this is unlikely to be the proper solution because the data will be stored in the argument as if the correct type pointer was passed. For example, if the intrinsic IFUNC() expects a pointer to a short int, and assuming it sets a value at the address passed, a call such as

int *pint;


IFUNC( (short int *) pint );

Error 1633

You may be passing a pointer to an array, but the size of its elements is not known.

Define the object being pointed to, so that the compiler knows its size.

Error 1634

An actual argument was omitted in a call to a function, and that function was not declared as an intrinsic.

Add the intrinsic declaration (that is, #pragma INTRINSIC intrinsic_name) to the translation unit. If the function being called is not an intrinsic, supply the missing argument(s).

Error 1635

An argument to an intrinsic function, argument number, was omitted but does not have a default value defined.

You must supply a value for the argument.

Error 1637

The intrinsic function name you specified exceeds 31 characters in length.

Shorten the function name to 31 characters or less.

Error 1638

The storage-class specifiers auto and register may not be used in the declaration specifiers in an external declaration.

Change the storage-class specifier to extern or static.

Mode: ANSI 3.7

Error 1639

An object that has static storage duration is being initialized with an address, but the object is not long enough to contain an address. For example,

int var;
short int addr = (short int) <esc|&var|;
main () {}

int var;
int *ptr1 = <esc|&var|;
void *ptr2 = (void *) <esc|&var|;
main () {}

Error 1640

Declarations may use only one of the following storage class specifiers: auto, static, extern, register, or typedef. A declaration using two or more of these occurs in the translation unit.

Remove the extraneous storage class specifier.

Mode: ANSI 3.5.1

Error 1641

You have used the unary plus operator with a nonarithmetic operand.

Replace the nonarithmetic operand with a valid operand for the unary plus operator.

Mode: ANSI 3.3.3.3

Error 1642

Your translation unit has a declaration using the same type specifier twice, such as int int i;.

Eliminate the duplicate type specifier.

Mode: ANSI 3.5.2

Error 1643

A digit of 8 or 9 is detected inside an octal constant.

Make sure only digits 0 to 7 are used in octal constants.

Mode: ANSI 3.1.3.2

Error 1644

It is illegal to apply the sizeof operator to bit-fields.

Remove the invalid sizeof expression.

Mode: ANSI 3.3.3.4

Error 1645

It is illegal to apply the sizeof operator to function names.

Remove the invalid sizeof expression.

Mode: ANSI 3.3.3.4

Error 1646

If both arms of a conditional expression are pointers, they must point to the same type, or one must be a pointer to void.

Correct the types of the expressions (possibly by inserting a cast).

Mode: ANSI 3.3.15

Error 1647

A integer can be combined with a pointer in a conditional expression only if it is a constant integral expression with the value 0 (a null pointer constant).

Correct the types of the expressions (possibly by inserting a cast).

Mode: ANSI 3.3.15

Error 1648

If both operands of a relational operator are pointers, they must point to compatible types.

Correct the types of the operands (possibly by inserting a cast).

Mode: ANSI 3.3.8

Error 1649

An integer cannot be combined with a pointer in a relational expression.

Correct the types of the operands (possibly by inserting a cast).

Mode: ANSI 3.3.8

Error 1650

A sub-expression with type void cannot be used in an expression.

Correct the expression.

Mode: ANSI 3.2.2.2

Error 1653

You've specified a 64-bit integral constant for a case label but the type of the switch expression is a 32-bit integer; example:

int i
switch (i) {
case 0x7FFFFFFFFFFFFFFF:

Error 1654

The switch expression contains the long long type, which is too large. For example:

long long foo;
switch (foo) {

Error 1675

Your translation unit has a declaration using the same type qualifier twice, such as const const int i;.

Eliminate the duplicate type qualifier.

Mode: ANSI 3.5.3

Error 1676

A function definition is a mixture of prototype and old-style formats, such as int func (char *) char *b;.

Function definitions must be in either prototype or old-style forms; change the definition to one or the other.

Mode: ANSI 3.7.1

Error 1677

Parameters may have no storage class other than register.

Remove the offending specifier.

Mode: ANSI 3.7.1

Error 1678

Your translation unit contains an ill-formed function definition, such as int func {} (no parentheses are present).

Change the function definition to be syntactically correct.

Mode: ANSI 3.7.1

Error 1679

You have initialized an array with a single expression without braces.

Surround the initializer with braces.

Mode: ANSI 3.5.7

Error 1681

You've specified -Aa without the +e option for the long long data type.

Either add the +e option or use -Ae.

Error 1700

You have attempted to use the unary plus operator in Compatibility mode.

Either take out the unary plus operator or compile with the -Aa option.

Error 1701

You have attempted to use the U suffix on an integer literal in Compatibility mode.

Either take out the unsigned suffix U or compile with the -Aa option.

Error 1702

You have attempted to use the F or L suffix on a real literal in Compatibility mode.

Either take out the float suffix F or the long suffix L, or compile with the -Aa option.

Error 1703

You have attempted to use wide character constants in Compatibility mode.

Either take out the wide character constants or compile with the -Aa option.

Error 1704

You have attempted to use wide string literals in Compatibility mode.

Either take out the wide string literals or compile with the -Aa option.

Error 1705

You have attempted to use function prototypes in Compatibility mode.

Either take out the function prototypes or compile with the -Aa option.

Error 1707

The type specifier void is permitted in a prototype function declaration only when it is the only parameter in the list. It signifies that the function takes no arguments.

Remove the extra declarators from the parameter list in the function declaration, or remove the void type specifier.

Mode: ANSI 3.5.4.3

Error 1708

The use of an ellipsis signifies that the remaining arguments are optional. It may only appear as the last element in a parameter list.

Reorder the parameters so that the ellipsis appears last in the list.

Mode: ANSI 3.5.4.3

Error 1709

You have attempted to use the long double type specifier in Compatibility mode.

Either take out the long double type specifier, or compile with the -Aa option.

Error 1710

An abstract declarator is used in a function definition. Abstract declarators in a parameter list may only appear in a function declaration.

Mode: ANSI 3.7.1

Error 1711

A function has been redeclared (or defined after a declaration) with a parameter list that is not the same as the one on the prior declaration.

Correct the parameter lists so that they are both the same.

Mode: ANSI 3.5.4.3, 3.1.2.6

Error 1712

You have specified a type with unknown size as the return type of a function. This typically occurs when a function is declared as returning a struct or union, and the struct or union body is never defined.

Ensure that the struct or union body is defined before the function definition.

Mode: ANSI 3.7.1

Error 1713

An object or function has been illegally redeclared.

Remove the second illegal declaration.

Mode: ANSI 3.5

Error 1714

An object may be initialized no more than once.

Remove the duplicate initialization.

Mode: ANSI 3.7

Error 1715

You have attempted to initialize a union in Compatibility mode.

Either remove the union initializer, or compile with the -Aa option.

Error 1716

You have attempted to initialize an automatic aggregate in Compatibility mode.

Either remove the auto aggregate initializer, or compile with the -Aa option.

Error 1717

You have attempted to specify a union bit-field in Compatibility mode.

Either remove the specify a union bit-field or compile with the -Aa option.

Error 1718

The types of the LHS and RHS of an assignment are incompatible. For example, you might have mixed a struct and a pointer in the assignment.

Correct the types of the expression in the assignment.

Mode: ANSI 3.3.16.1

Error 1720

In a subscript expression (a[b]), one operand must be an integral expression, and the other expression must be a pointer to an object of known size (that is, not an incomplete pointer or a pointer to void).

Correct the types of the operands of the subscript expression.

Mode: ANSI 3.3.2.1

Error 1721

You have violated the rules about the allowable types for the operands of a relational operator. Both operands must have arithmetic type, or both must be pointers to compatible types. For example, you cannot compare two structures.

To compare two structures, compare them one element at a time. To compare pointers that don't point to compatible types, cast one or both so that they are compatible.

Mode: ANSI 3.3.8

Error 1722

You have violated the rules about the allowable types for the operands of an equality operator. For example, you cannot compare two structures.

To compare two structures, compare them one element at a time. In other cases, you may be able to achieve the desired result using casts.

Mode: ANSI 3.3.9

Error 1723

In a prototype in a function declaration, at least one fixed parameter declaration must precede an ellipsis (that is, the following declaration is illegal):

int func(...);

int func (int parm1, ...);

Error 1724

Long float is a synonym for double in compatibility mode only.

Change the type specifier to double.

Mode: ANSI 3.5.2

Error 1726

Your program dereferences a pointer to an incomplete type. The object to which the pointer points must be an object type or a function type.

Complete the type that the pointer is pointing to.

Error 1748

A character array is initialized with an illegal initializer, such as a cast of a string literal.

Remove the cast, or change the type being initialized to a pointer rather than an array.

Error 1500

The type of an array is function. For example,

char g(void) { return('a'); }
main()
{
  char f[4]();
        f[0] = g;
        printf("%c\n",f[0]());
}

char g(void) { return 'a'; }
main()
{
  char (*f[4])();
  f[0] = &&g;
  printf("%c\n",f[0]());
}

Error 1501

Only the first dimension of an array declaration can use empty brackets ([ ]). For example,

int arr[ ][ ][4], brr[4][3][ ];

Specify the size of each subsequent dimension of the array after the first element. In the example above, specify

int arr[ ][2][4], brr[4][3][1];

Error 1502

The expression specifying the size of an array is not a constant. For example,

int i = 4;
char arr[i];

char arr[4];

char arr[2+2];

Error 1503

The expression specifying the size of an array is not an integral constant expression. For example, although 4*2/1.6 evaluates to 5, the value is converted to type float (5.000) because of the value 1.6.

However, the declaration

int arr[4*2/3];

Use a cast or change the expression so it evaluates to an integer value. For example,

int arr[(int) (4 * 2/1.6)];

int arr[4*20/16];

Error 1504

The expression specifying the size of an array evaluates to a number that is not greater than zero. For example,

int arr[2*4/-3-5];  /* evaluates to int arr[-7]; */

int arr[2*4/-(3-5)];

int arr[4];

Error 1505

The return type of a function is declared to be function or array. For example,

main()
{
  char f()[4];  /* function returning array */
  char g()();     /* function returning function */
}

main()
{
    typedef Arr[4];
    typedef Func();
    Arr  *f(); /* returns a pointer to array */
    Func *h(); /* returns a pointer to a function */
}

Error 1506

A function declarator that is not part of a function definition has an identifier list that is not empty. For example, func(a,b);.

You might have inadvertently put a semicolon after a function declarator. If not, remove the identifier list from the external declaration.

Mode: ANSI 3.5.4.3

Error 1507

The program attempts to declare a register global. For example,

register int var;
main() { }

Remove the register class specifier from the declaration.

Mode: ANSI 3.7

Error 1508

Your program uses an illegal combination of types. For example,

long short i;
unsigned void x;

unsigned short us;

Error 1509

Your program assigns a nonconstant to an enumeration constant. In the following example, blue = i is flagged as an error.

main()
{
  int i = 44;
  enum colors { red = 4, green, blue = i, yellow};
}

Mode: ANSI 3.5.2.2

Error 1510

The expression defining the value of an enumeration constant is not an integral constant expression. For example,

main()
{
  enum colors { red = 4, blue = 5.65, yellow = red,
  green = 'a'};
}

red = 4
yellow = red
green = 'a'

blue = 5.65

blue = 5

blue = 6

blue=(int) 5.65

Error 1511

Your program gives a bit-field within a structure a nonconstant size. In the following example

main()
{
  int i = 15;
  struct S {
      char c;
      int  bf : 2 * 3;
      int  df : i;
  } st;


}

int bf : 2 * 3;

int df : i;

Use an integral constant expression to specify the size of a bit-field. Change the struct-declarator above to

int df : 15;

Mode: ANSI 3.5.2.1

Error 1512

The type of a bit-field is not integral. For example,

struct S {
    float af  : 5;
    int pf[3] : 29;
    int *ptr  : 13;
} st;

Mode: ANSI 3.5.2.1

Error 1513

Your program specified a bit-field size that is greater than the size of an int (32 bits) or less than zero. For example,

struct S {
int  af : 32;  /* acceptable */
int  bf : -2;  /* not acceptable */
} st;

Mode: ANSI 3.5.2.1

Error 1514

You attempted to initialize an illegal type with a string initializer. For example:

struct SS { int i; } s = {"abc"};

struct SS { char *c; } s = {"abc"};

Error 1515

The string used to initialize an array of character type contains more characters than specified by the size of the array. (Remember that the terminating null character will not be appended to the array unless there is enough room for it.) For example,

char Str[4] = "12345";

char Str[5] = "12345";

char Str[4] = "1234";

char Str[] = "12345";

Mode: ANSI 3.5.7

Error 1516

Your program attempts to initialize a typedef name as if it were a variable. For example,

typedef char * String = "hi there";

typedef char * String;
String Str_var1 = "hi there";

Error 1517

Your program attempts to initialize an imported variable that is declared extern, and whose proper definition appears elsewhere. For example,

int global;
main()
{
   int i = 10;
   if (i  0){
           extern int global = 1;
    }  i = 0;
}

int global = 1;
main()
{
   int i = 10;
   if (i  0) {
       extern int global;
       i = 0;
   }
}

Error 1518

You have initialized a function, such as static int func() = 3;.

Remove the initialization from the function declaration.

Mode: ANSI 3.5.7

Error 1521

An initializer for an object with static storage duration is not a valid constant. Such a constant must be an arithmetic constant expression, a null pointer constant, an address constant, or an address constant plus or minus an integral constant expression. For example,

char *s = "hi there";
char * title = s;  /* not constant */
main() { }

char * title = "hi there";

char *s = "hi there";
char * title;
main()
{
  title = s;
}

Error 1522

Your program initializes a pointer to a noninteger. For example,

int *p = 'a';

int i, * ptr = 46;
char * name = "The Title";
int *p = <esc|&i|;

Error 1523

An initializer list contains more initializers than elements in the object being initialized.

int arr[3] = {0, 1, 2, 3};
main()
{
    static struct {int i; char c;} s = {4,'e',55};
}

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

int arr[3] = {0, 1, 2};

static struct {int i; char c; int j;} s = {4,'e',55};

static struct {int i; char c;} s = {4,'e'};

Error 1524

The initializer contains more levels of nested braces than is allowed. For example,

int i = <esc|3;|

Mode: ANSI 3.5.7

Error 1525

A switch statement contains more than one default label. For example,

switch (c) {
  default: fprintf(stderr, "not an option.\n");
           break;
  case 'f': do_f(); break;
  default: fprintf(stderr, "error\n"); break;
  }

Mode: ANSI 3.6.4.2

Error 1526

Two case expressions in the same switch statement have the same value. For example,

switch (c) {
  case 'f':
  case 'g': do_f_or_g(); break;


  case 'f': do_f(); break;
  default: fprintf(stderr, "not an option. \n");
  break;
}

Mode: ANSI 3.6.4.2

Error 1527

Your cast expression attempted an illegal conversion. For example:

struct SS {int i; char j;}  * s_ptr;
union UU {int a; char b;}  u, *u_ptr = &&u;
s_ptr = (struct SS) u_ptr;

st_ptr = (struct S *) un_ptr

Error 1528

In a subscript expression, one of the expressions must have pointer type and the other must have integral type. For example:

arr[4.54] = 4;

Mode: ANSI 3.3.2.1

Error 1529

The left operand of a . operator is not a struct or union. For example,

int st;
st.i = 4;

struct S {int i; char c;} st;
st.i = 4;

Error 1530

Your program uses an undefined variable as the left operand of a . operator. For example:

main()
{
 struct S *stp;
 (*stp).i = 4;
 st.i = 4;    /* st undefined because struct S
                 hasn't been specified */
}

struct S { int i; char c; } st;
st.i = 4;

Error 1531

The second operand of a . operator or a - operator does not name a member of the corresponding structure or union. For example,

main()
{
    struct { int i; char c; } st, *p = <esc|&st|;
    p-z = 4;
    st.d = 'a';
}

p-i = 4;
st.c = 'a';

Error 1532

The left operand of a reference operator (-) is not a pointer. For example,

main()
{
    int *q;
    struct S { int i; char c; } s, *p=<esc|&s|;
    s-i = 4;
}

s.i = 4;

p-i = 4;

Error 1533

Your program does not call a function correctly. For example,

void f (int y, int z);
void g (enum a {A,B} x);
main()
{
     int i = 10;
     (* (i ? F: g)) ();
}

Error 1534

The program attempts to use a function pointer in an arithmetic expression. For example:

int (*fp)();



int f(){};
main()
{ int i,j;
  fp = f;
  j = 3;
  i = j + fp;  /* this is illegal */
}

If this is really what you want, cast the function pointer to an integer.

i = j + (int) fp;

Mode: ANSI 3.3

Error 1535

Your program uses nonintegral operands with a bitwise operator. Examples of nonintegral expressions are pointers, floats, functions, arrays, structs, and unions. Bitwise operators are: |, ^, and &. For example,

float f; int i;
i = f^i; /* incorrect usage because f is a float */
i &= f;  /* incorrect usage because f is a float */

• a function name that was used instead of a function call
• an array name that was used instead of an element in an array
• a struct or union name that was used without specifying a member
• a pointer that was used without dereferencing it
• a float that was used instead of an int

Error 1536

The expression used for initializing a variable is too complex to be determined at link time. Usually this is due to using an expression involving an address minus an address or an address plus an address. For example:

int i = 0,j = 0;
int a = (int) <esc|&i - (int) &j|;


main()
{
}

int i = 0,j = 0;
int a;


main()
{
   a = <esc|(int) &i - (int) &j|;
}

Error 1537

You have not followed the rules for the operand types in a relational expression or an equality expression.

Make sure you are comparing the correct objects. You could have used an array name instead of an element in an array, or you could have used a struct or union name without accessing a member. Either compare the correct objects or cast the operand to the appropriate type.

Mode: ANSI 3.3.8, 3.3.9

Error 1538

The operands to a shift operator ( or ) are not of integral type. For example,

int *p, *q, i = 4;
q = p  i;

q = (int*) ((int) pi);

Error 1539

A pointer was declared without fully defining the object it points to; such a pointer cannot be manipulated arithmetically because the size of the object is unknown. For example,

struct s *p;
main()
{  p++; }

Fully declare the type of the object pointed to. For example,

struct s {
  int a,b,c;
} *p;
main()
{  p++; }

Mode: ANSI 3.3.6

Error 1541

One operand to an addition operator is a pointer, but the other does not have integral type. For example,

int *p, *q;
p = p + q;
p += q;

p = p + (int)q;
p = (int)p + p;
p += (int)q;

Error 1542

The first operand of a subtraction operator has integral type and the second operand is a pointer. For example,

int i, *q;
i = i - q;
i -= q;

i = i - (int)q;
i -= (int)q;

Error 1544

Your program uses a nonarithmetic type with one of the following operators: +, -, *, /, or %. Arithmetic types include floating types, integer types, character types, and enumerated types. For example,

int  *ptr, e;
e = ptr * 2;

e = (int)ptr *2;

Mode: ANSI 3.3

Error 1545

The operands to a modulus operator (%) do not both have integral type. For example,

double d = 66.666;
int i = 5;
i = d % i;
i %= d;

i = (int)d % i;
i %= (int)d;

Error 1547

Your program uses nonscalar operands with a logical operator. Scalar types include arithmetic types and pointer types. Examples of nonscalar types are structs and unions. Logical operators are: <esc|&&| and ||.

Check whether a struct or union name was used without specifying a member.

Mode: ANSI 3.3.13, 3.3.14

Error 1548

Your program initializes an object with static storage duration, using an illegal initialization expression, such as with a function call:

int i = zero();

int i = 0;

Error 1549

Your program does not use an lvalue on the left side of the assignment operator. Some non-lvalues are array names without the subscript, function names, and enumeration constants. For example,

enum color {red, green, blue};
int i=4, *p, arr[4];
int func();


green = red;  /* green is a constant */
arr = p;      /* arr is an array */
f() = i;      /* f is a function name */
<esc|&i| = p;       /* <esc|&i| cannot be assigned to */

struct {
  int arr[10];
} a,b;


a = b;

Error 1552

The first operand of a conditional expression does not have scalar type. For example,

struct SS { int i,j; }s;
s.i = (s.j  906)?s:2;

s.i = (s.j  906) ? s.j : 2;

Error 1553

This error occurs when the second and third operands in the conditional expression have mismatched types, or one is a pointer and the other is a nonzero integer. For example,

i = i ? i : ptr;

i = i ? i : (int)ptr;

Error 1554

The indirection operator (*) is being applied to a nonpointer. For example,

int i, p;
i = *p;

i = *(int *)p;

int i, *p;
i = *p;

Error 1555

The operand of the unary <esc|&| operator must be a function designator or an lvalue.

enum {red, blue, green};
int *p;
p = <esc|&4|;
p = <esc|&red|;  /* where red is a constant.  */

i = 4; p = <esc|&i|;
color = red;  p = <esc|&color|;

Error 1556

The address-of operator (&) is being applied to a register variable. For example,

register index;
int *p;
p = <esc|&index|;

int index;

Error 1557

The operand to a unary minus operator (-) does not have arithmetic type. For example,

double *ptr;
-ptr;

-(*ptr);

Error 1558

The operand to a not operator (!) does not have scalar type. For example,

struct SS { int arr[10]; int j; } s;
if ( !s );

if ( !s.j );

Error 1559

The operand to a complement operator (~) does not have integral type. For example,

struct SS { int arr[10]; int j; } s;
int *p;
if (~s);
if (~p);

if (~s.j);
if (~*p);

Error 1560

Your program uses a non-lvalue with either pre-increment (<esc|++|var), post-increment (var<esc|++|), pre-decrement (--var), or post-decrement (var--) operators. Non-lvalues include constants, functions and other expressions that cannot be assigned to or modified. For example,

int i, *p, arr[3];
i = --4;
p = arr++;

i = 3;
p = arr + 1;

Error 1561

Your program uses a nonscalar operand with the <esc|++| or -- operator. For example, this occurs when you try to use <esc|++| or -- with a struct or union name. For example,

int a;
struct { int i; char c; } st;
a = st--;

a = (st.i)--;

Error 1562

The address-of operator (&) is being applied to a bit-field.

struct { unsigned i : 4; unsigned *j; } s;
s.j = <esc|&s.i|;

 s.j = s.i;
s.j = (unsigned *)&&s.j;

Error 1563

The expression in an if statement does not have scalar type. For example,

struct { int i; char c; } s;
if ( s );

if (s.i);

Error 1564

The controlling expression in a while statement does not have scalar type. For example,

int x, y;
struct { int i; char c; } st;
while ((x == y) <esc|&&| st);

while ((x == y) <esc|&&| st.c);

Error 1565

The controlling expression in a do statement does not have scalar type. For example,

struct { int i; char c; } s;
do { ; } while (s);

do { ; } while (s.i);

Error 1566

The controlling expression in a for statement does not have scalar type. For example,

char array[12];
for (array = 0; array<= 2.0; array++) { ; }

for (array[0] = 0; array[0] <= 2.0; array[0]++) { ; }

Error 1567

The controlling expression in a switch statement does not have integral type. For example,

float f;
int arr[3];
switch(f) {
   default: break;
}
switch(arr) {
   default: break;
}

switch((int)f) {
  default: break;
}
switch(arr[1]) {
  default: break;
}

Error 1568

A case statement is not inside a switch statement. For example,

switch (x) {
  case 1: {}
}
  case 2: {}

switch (x) {
  case 1: {}
&nb