What's the point of a PROTOTYPE macro that merely expands to its arguments?

Question

I have a header file which contains

#define PROTOTYPE(s) s 

What is the point of that? Seems like it would just replace the input with itself.

There are TONS of other directives around it, but the only one that appears to have any bearing just checked if it's defined: #ifndef PROTOTYPE. I found some places in HDF4 header files that do this: #define PROTOTYPE. So, none of that really clear up my question. Still seems pretty useless.

Here's how it's used:

CS_RETCODE clientmsg_callback PROTOTYPE(( CS_CONTEXT * context, CS_CONNECTION *connection, CS_CLIENTMSG *clientmsg)); 

This is part of a project which uses Sybase Open Client. clientmsg_callback is later used here:

ct_callback(context, NULL, CS_SET, CS_CLIENTMSG_CB,                   (CS_VOID *)clientmsg_callback); 

I'm going off of a sample program from here:

http://infocenter.sybase.com/help/index.jsp?topic=/com.sybase.infocenter.dc35570.1570/html/clcprgde/clcprgde10.htm

clientmsg_callback is implemented later. I think the sample was originally written with C in mind, instead of C++. Perhaps that has something to do with it?

Answer 1

Back in the olden days of really, really early C, there was no such thing as a prototype. Function argument lists came after the function's parentheses, like this:

square(x) int x; { int y = x * x; return y; } 

These days, of course, the arguments go inside the parentheses:

square(int x) { int y = x * x; return y; } 

Note the "missing" return type; C functions used to implicitly return int, and it was only if you needed a different return type that you had to say what it was.

Function declarations had yet another set of rules. A function declaration in K&R C (the ancient version) had no arguments:

int square(); 

And function prototypes in ANSI C have a list of arguments:

int square(int x); 

During the transition, people used wacky macros so they could compile both ways:

int square(PROTOTYPE(int x)); 

With

#define PROTOTYPE(s) 

that would expand to the first version.

With

#define PROTOTYPE(s) s 

it would expand to the second.

With regard to the "extra" parentheses in the code in the question, they're needed when there is more than one argument in the argument list. Without them, the macro invocation has more than one argument, so won't match a macro defined with just one argument:

PROTOTYPE(int x, int y)   // error: too many arguments PROTOTYPE((int x, int y)) // ok: only one argument (enclosed in parentheses)