Ignore "initialization from incompatible pointer type" warnings?

Question

Is there a compiler directive in order to ignore the "initialization from incompatible pointer type" warnings in Hardware_MouseDrivers_GPM_Methods and Hardware_MouseDrivers_DevInput_Methods? Turning off warnings globally is not an option though.

#include <stdio.h>

/* Mouse driver interface */

typedef struct _Hardware_MouseDriver {
        int (*open)(void*, char *);
        int (*close)(void*);
        int (*poll)(void*);
} Hardware_MouseDriver;

/* GPM */

typedef struct _Hardware_MouseDrivers_GPM {
        char *path;
} Hardware_MouseDrivers_GPM;

static int Hardware_MouseDrivers_GPM_Open(Hardware_MouseDrivers_GPM *this, char *path);
static int Hardware_MouseDrivers_GPM_Close(Hardware_MouseDrivers_GPM *this);
static int Hardware_MouseDrivers_GPM_Poll(Hardware_MouseDrivers_GPM *this);

static int Hardware_MouseDrivers_GPM_Open(Hardware_MouseDrivers_GPM *this, char *path) {
        printf("GPM: Opening %s...\n", path);
        this->path = path;
}

static int Hardware_MouseDrivers_GPM_Close(Hardware_MouseDrivers_GPM *this) {
        printf("GPM: Closing %s...\n", this->path);
}

static int Hardware_MouseDrivers_GPM_Poll(Hardware_MouseDrivers_GPM *this) {
        printf("GPM: Polling %s...\n", this->path);
}

Hardware_MouseDriver Hardware_MouseDrivers_GPM_Methods = {
        .open  = Hardware_MouseDrivers_GPM_Open,
        .close = Hardware_MouseDrivers_GPM_Close,
        .poll  = Hardware_MouseDrivers_GPM_Poll
};

/* DevInput */

typedef struct _Hardware_MouseDrivers_DevInput {
        char *path;
} Hardware_MouseDrivers_DevInput;

static int Hardware_MouseDrivers_DevInput_Open(Hardware_MouseDrivers_DevInput *this, char *path);
static int Hardware_MouseDrivers_DevInput_Close(Hardware_MouseDrivers_DevInput *this);
static int Hardware_MouseDrivers_DevInput_Poll(Hardware_MouseDrivers_DevInput *this);

static int Hardware_MouseDrivers_DevInput_Open(Hardware_MouseDrivers_DevInput *this, char *path) {
        printf("DevInput: Opening %s...\n", path);
        this->path = path;
}

static int Hardware_MouseDrivers_DevInput_Close(Hardware_MouseDrivers_DevInput *this) {
        printf("DevInput: Closing %s...\n", this->path);
}

static int Hardware_MouseDrivers_DevInput_Poll(Hardware_MouseDrivers_DevInput *this) {
        printf("DevInput: Polling %s...\n", this->path);
}

Hardware_MouseDriver Hardware_MouseDrivers_DevInput_Methods = {
        .open  = Hardware_MouseDrivers_DevInput_Open,
        .close = Hardware_MouseDrivers_DevInput_Close,
        .poll  = Hardware_MouseDrivers_DevInput_Poll
};

/* Test drivers */

void TestDriver(Hardware_MouseDriver driver, void *data) {
        /* Access the driver using a generic interface
         * (Hardware_MouseDriver) */
        driver.poll(data);
}

void main() {
        Hardware_MouseDrivers_GPM gpm;
        Hardware_MouseDrivers_DevInput devinput;

        Hardware_MouseDrivers_GPM_Open(&gpm, "/dev/gpmctl");
        Hardware_MouseDrivers_DevInput_Open(&devinput, "/dev/input/mice");

        TestDriver(Hardware_MouseDrivers_GPM_Methods, &gpm);
        TestDriver(Hardware_MouseDrivers_DevInput_Methods, &devinput);

        Hardware_MouseDrivers_GPM_Close(&gpm);
        Hardware_MouseDrivers_DevInput_Close(&devinput);
}

Answer 1

I guess the obvious answer to this is the question "why not fix the code to use the right pointer type"?

EDIT:

OK, I can understand that you don't want to complicate the code unnecessarily, but I don't think it's that much of a complication, or even an unneccessary one.

Let's look at the field open in the struct Hardware_MouseDriver, which is supposed to be a pointer to a function that takes a pointer to void as its first argument.

To initialize this field, you use a pointer to the function Hardware_MouseDrivers_GPM_Open, and at another place a pointer to the function Hardware_MouseDrivers_DevInput_Open. None of these take a pointer to void as their first argument, and this is of course what the compiler warns about.

Now, if a void pointer is the same size as these pointers, and there are no other surprising differences between how they are stored and handled, calls to these functions through the open pointer will work as expected. It is likely that it will, and I guess that with this type of low-level code it is unlikely that someone will port it to TOPS-20 or something. But there is no guarantee that it will work, and it looks (to me) strange. (And to the compiler, obviously!)

So my suggestion would be to change code like this:

static int Hardware_MouseDrivers_GPM_Open(Hardware_MouseDrivers_GPM *this, char *path) {
    printf("GPM: Opening %s...\n", path);
    this->path = path;
}

to the just slightly more complicated:

static int Hardware_MouseDrivers_GPM_Open(void *arg1, char *path) {
    Hardware_MouseDrivers_GPM *this = arg1;
    printf("GPM: Opening %s...\n", path);
    this->path = path;
}

I think this change would be easier and less complicated than (1) turning off the warnings, (2) documenting it so readers can understand why that warning isn't supposed to be important here, (3) documenting it some more so your readers actually believe that you know what you are doing, and (4) handling the problems that will occur if someone actually does port your code to TOPS-20.

Answer 2

Cast the assignments to the proper types (function pointers with void * rather than your instance pointer):

 .open= (int (*)(void*, char *))Hardware_MouseDrivers_GPM_Open;

Or make a type and use it in the definition and initialization of the struct:

typedef int (*openfcnt_t)(void*, char *);

typedef struct _Hardware_MouseDriver {
        openfnct_t open;
} Hardware_MouseDriver;

and then

 .open= (openfnct_t)Hardware_MouseDrivers_GPM_Open;

---

EDIT:

Upon further thought the easiest and least fiddly way for a C program will be:

 .open= (void *)Hardware_MouseDrivers_GPM_Open;