-Wincompatible-pointer-types和enum

Question

Implicit cast from short* to int* prints the warning about incompatible pointer type (and I understand why).

Implicit cast from enum* to int* prints same warnig.

There's a tool snacc that generates the following code:

typedef enum
    {
        CHARGINGCALLING = 0,
        CHARGINGCALLED = 1,
        NONECHARGING = 2
    } ChargedParty; /* ENUMERATED { CHARGINGCALLING (0), CHARGINGCALLED (1), NONECHARGING (2) }  */

typedef struct MSOriginatingSMSinSMS_IWMSC /* SET */
{
    ChargedParty* chargedParty; /* [6] IMPLICIT ChargedParty OPTIONAL */
} MSOriginatingSMSinSMS_IWMSC;

#define BEncChargedPartyContent BEncAsnEnumContent

int BEncMSOriginatingSMSinSMS_IWMSCContent (BUF_TYPE b, MSOriginatingSMSinSMS_IWMSC *v) {
    BEncChargedPartyContent (b, (v->chargedParty));
    ...
}

A header file shipped with this tool:

int BEncAsnIntContent (BUF_TYPE b, int *data);
#define BEncAsnEnumContent BEncAsnIntContent

The call to BEncChargedPartyContent prints the warning.

Can I modify the declaration of BEncAsnEnumContent so it accepts without a warning pointers to any enum, but not void* or short* ?

Of course using sed I could replace the macro BEncChargedPartyContent with a static function:

static AsnLen BEncChargedPartyContent (BUF_TYPE b, ChargedParty *data)
{
    return BEncAsnEnumContent(b, (int*)data);
}

But there're too many of them.

Answer 1

Your own proposal with a static function sounds not so bad.

Can I modify the declaration of BEncAsnEnumContent so it accepts without a warning pointers to any enum, but not void* or short* ?

If you want, you can use a static assertion as John Zwinck hinted at.

#define BEncAsnEnumContent(b, d)        ({\
    _Static_assert(sizeof(int) == sizeof *(d), "wrong data size");\
        BEncAsnIntContent(b, (int *)d); })

---

What you think of in your comment below is a viable alternative with the advantage that it allows enumerations of different sizes; this is how I understand what you mean:

#define BEncAsnEnumContent(b, d)    MyEncAsnEnumContent(b, *(d))
static int MyEncAsnEnumContent(BUF_TYPE b, int val)
{
    return BEncAsnIntContent(b, &val);
}

Answer 2

The enumeration constants , that is the list of values in your enum declaration, are guaranteed to be of type int . However, this does not apply to the enum variable itself. An enum need not be compatible with int nor with another, different enum type variable. The size can vary from case to case and from compiler to compiler.

This is the root of the problem. If you mix enum and int , or two different enums with each other, all is fine if they have the same size. They are then compatible and you can convert pointers from one of the types to the other without problems.

However, if they are not of the same size, you cannot do this. It would give incompatible types: you would violate the strict aliasing rule and there might also be alignment issues. Plus the obvious: if you try to read a large chunk of data from a location where only a small chunk of data is stored, there's no telling what you will end up with.

The reliable solution is to change your function to simply use an integer type instead of a pointer:

int BEncAsnIntContent (BUF_TYPE b, int data);

There doesn't seem to be a reason why they pass the parameter through a pointer in the first place. Keep it simple.