use of self-referential macro

[password636]

Hi

I'm reading <The C Preprocessor - GUN version> and cannot understand this piece :

One common, useful use of self-reference is to create a macro which expands to itself. If
you write
#define EPERM EPERM
then the macro EPERM expands to EPERM. Effectively, it is left alone by the preprocessor
whenever it’s used in running text. You can tell that it’s a macro with ‘#ifdef’. You might
do this if you want to define numeric constants with an enum, but have ‘#ifdef’ be true for
each constant.

Can anybody make an example to illustrate this use?

Thanks!

[Ronix]

Sometimes you define constants by using an enumeration type, like this:

enum {
   FOO = 1
};

However, enumerations aren't available at preprocessing time, so you can't test their existance with an #ifdef:

#include <stdio.h>

enum {
   FOO = 1
};

int main()
{
#ifdef FOO
   puts("FOO is defined");
#endif
}

That's where a self-referencing macro comes handy: You define a macro to evaluate to that same enum so that you can effectively test whether it exists or not:

#include <stdio.h>

enum {
   FOO = 1
};

#define FOO FOO

int main()
{
#ifdef FOO
   puts("FOO is defined");
#endif
}

[cpjust]

What does that have to do with an enum and how is that different than just using:

#define FOO

[Ronix]

You can't do this for example:

#define FOO

int main()
{
   int x = FOO;
}

glibc for instance has a tendency to define macros that use the same names as enums with error codes (errno) and locale items for nl_langinfo, among others.

[cpjust]

Well that's completely different than your previous example.
This would have the same effect as your other example:

#include <stdio.h>

enum {
   FOO = 1
};

#define FOO

int main()
{
#ifdef FOO
   puts("FOO is defined");
#endif
}

as would this:

#include <stdio.h>

enum {
   BLAH = 1
};

#define FOO

int main()
{
#ifdef FOO
   puts("FOO is defined");
#endif
}

So I don't see an example of where the code only does what you want if you define a macro with the same value as its name...

[Ronix]

This would have the same effect as your other example

Well, yes. The point is that a library designer may utilize the above trick so that a user can verify the existance of an enumeration constant (As in the glibc case). Defining the macro to something completely different, while possible, is of little use.