What does (*) mean in plain C? - c

Question

I can't get the meaning of the "(*)" expression in the following statement:
#define PySpam_System \
(*(PySpam_System_RETURN (*)PySpam_System_PROTO) PySpam_API[PySpam_System_NUM])
where
#define PySpam_System_NUM 0
#define PySpam_System_RETURN int
#define PySpam_System_PROTO (const char *command)
(excerpt from http://docs.python.org/2/extending/extending.html). What could that mean? (Excuse me for a dumb question). Resembles a function pointer, but with a very confusing syntax.
UPDATE: Thanks to Shahbaz and Jonathan things are getting mostly clear, but I still can't get two nuances:
Why const char *command, not just const char *. I thought that the name of the argument should be omitted in function pointer type declaration and type conversion? So it must not be omitted, but rather just can be?
Why (*(int (*)(const char *command)), not just (int (*)(const char *command)? What's the purpose of the outer (*[everything else here])? It's the optional dereferencing of function pointer to the function itself, right?

Answer 1

PySpam_System_RETURN (*)PySpam_System_PROTO
expands to:
int (*)(const char *command)
This is a function pointer type. So basically the following:
(*(PySpam_System_RETURN (*)PySpam_System_PROTO) PySpam_API[PySpam_System_NUM])
which translates to:
(*(int (*)(const char *command)) PySpam_API[0])
is calling the value of PySpam_API[0] as if it's a function with a const char* argument and an int return value (cast to function pointer). Note that this is still missing the arguments, so whoever uses the macro should give it arguments, such as:
PySpam_System("some string");
On your update:
The argument name is optional. They could have just written const char *. I believe the name was written for clarity. Right now, without looking anywhere else, I understood that the function takes a command, so it was helpful I'd say.
Again, you are right. The initial * dereferences the function pointer. In C, that's quite optional. It would be more symmetrical to put it, since you are dereferencing a pointer, but since not dereferencing a function pointer doesn't make sense, if you don't dereference it wouldn't make any difference, C would do the only sane thing for you. In fact, even if you put ****** instead of just one, it would still work.

Answer 2

Expand PySpam_System with the preprocessor, and you'd see:
(*(int (*)(const char *command)) PySpam_API[0])
The expression is (more or less) a cast to a 'pointer to function returning int and taking one argument of type const char *'. It would have to be followed by ("something") to convert the whole into a function call via the pointer to function. Thus, in the code, you might see:
PySpam_System("abc");
and the compiler would see:
(*(int (*)(const char *command)) PySpam_API[0])("abc");
and that is a call to the function stored in the array PySpam_API at index location 0. Obviously, the argument would probably not be a simple string literal, but a simple string literal is a representative const char *.
Question updates
Why const char *command, not just const char *. I thought that the name of the argument should be omitted in function pointer type declaration and type conversion? So it must not be omitted, but rather just can be?
Names for the arguments (such as command in the example) are optional in prototype declarations. There is also no rule stating that the name in the prototype declaration must match the name in the function definition. Sadly, C has not yet adopted the C++ convention that names are optional in the function definition if you are writing a function to conform to an interface but the particular implementation of the function does not need the argument. That is, in C++, you could write:
typedef int (*interface)(const char *cmd, int arg1, int arg2);
static int implementation(const char *cmd, int arg1, int) // C++, not C
{
return some_other_function(cmd, arg1, 23, 19);
}
The function implementation conforms to the interface type, but doesn't use the arg2 argument, but the compiler won't complain about the unused argument. C does not allow that convenience, so you get told about 'unused argument' even though you know perfectly well that it is unused. I believe there are compiler-specific ways around this particular problem.
Why (*(int (*)(const char *command)), not just (int (*)(const char *command)? What's the purpose of the outer (*[everything else here])? It's the optional dereferencing of function pointer to the function itself, right?
Right.
Note that there are two ways to invoke a function via a pointer to function, roughly the 'old' and the 'new' (where new means 'introduced and blessed by the C89 standard', so it is not exactly 'new').
The old notation required (give or take the prototypes which weren't available at the time):
#include <math.h>
double (*func)(double) = sin;
double x = (*func)(1.0);
with the parentheses and * around the function pointer. The idea is that if you have a pointer to a function, you need to dereference it to invoke the function. The more modern notation notes that the name of a function becomes a pointer to function (for example in the assignment), so you don't really need the (*func) notation. Hence the newer style is:
#include <math.h>
double (*func)(double) = sin;
double x = func(1.0);
Since I learned C when the old style was obligatory, I still prefer the slightly more verbose but completely unambiguous notation. The code in the PySpam_System macro uses the older notation too.
You can also play various silly games with function pointers, adding extra * and using a &, all of which are unnecessary.
double (*funca)(double) = &sin;
double (*func0)(double) = sin;
double (*func1)(double) = *sin;
double (*func2)(double) = **sin;
double (*func3)(double) = ***sin;
Only the func0 declaration is sensible; the rest are obfuscatory C.