Delayed stringification without macro expansion - c

Question

Is it possible to modify the following code fragment to prevent the diagnostic printed by #pragma GCC warning from changing if any of the identifier tokens in deprecation_message are defined as object-like macros at the point where dmacro is expanded, while preserving the ability to substitute symbol into the message? Ugliness no object, GCC extensions are fair game as long as clang also implements them, but the contents of the diagnostic may not be modified.
#define deprecation_message(symbol) \
#symbol will be removed from <header.h> in the next release\n\
of $LIBRARY. To use #symbol, include <moved/header.h> instead.
#define make_pw(...) make_pw_(__VA_ARGS__)
#define make_pw_(...) make_pw__(GCC warning #__VA_ARGS__)
#define make_pw__(...) _Pragma(#__VA_ARGS_)
#define dmacro(a,b,c) make_pw(deprecation_message(dmacro)) xmacro(a,b,c)
// Uncommenting any of the following #define lines should *not*
// change the text of the diagnostic in any way.
//#define header
//#define n f
//#define will won't'
dmacro(x,y,z)
(You might be tempted to reach for string-literal concatenation, but that won't work; both _Pragma itself and #pragma GCC warning accept only a single string literal. _Pragma("this" "that") is a syntax error.)

Answer 1

Maybe I misunderstood the question, but the following code is working and compiling on both clang and gcc, and tested with -std=c99 and -std=c11:
#include <stdio.h>
#include <stdlib.h>
#define deprecation_message(symbol) \
#symbol " will be removed from <header.h> in the next release\n" \
"of $LIBRARY. To use " #symbol ", include <moved/header.h> instead."
#define make_pw__(...) _Pragma(#__VA_ARGS__)
#define make_pw_(...) make_pw__(GCC warning #__VA_ARGS__)
#define make_pw(...) make_pw_(__VA_ARGS__)
#define xmacro(a, b, c) puts("I'm working: " #a #b #c "!")
#define dmacro(a, b, c) make_pw(deprecation_message(dmacro)) xmacro(a, b, c)
int
main(void)
{
dmacro(x, y, z);
return EXIT_SUCCESS;
}
Now, the above code will expand this with clang:
int
main(void)
{
#pragma GCC warning "\042dmacro\042 \042 will be removed from <header.h> in the next release\134n\042 \042of $LIBRARY. To use \042 \042dmacro\042 \042, include <moved/header.h> instead.\042"
puts("I'm working: " "x" "y" "z" "!");
return 0 /* Successful exit status. */;
}
and will produce the following warnings on clang:
src/main.c:18:5: warning: "dmacro" " will be removed from <header.h> in the next release\n" "of $LIBRARY. To use " "dmacro" ", include <moved/header.h> instead." [-W#pragma-messages]
dmacro(x, y, z);
^
and this on gcc:
src/main.c:18:13: warning: "dmacro" " will be removed from <header.h> in the next release\n" "of $LIBRARY. To use " "dmacro" ", include <moved/header.h> instead."
dmacro(x, y, z);
^~~~~~~~
Basically all I did was, to put the deprecation message into quotes...
UPDATE1:
Now, the funny thing is, if you remove the stringification from make_pw_, that is:
#define make_pw_(...) make_pw__(GCC warning __VA_ARGS__)
then clang will give you this:
src/main.c:18:5: warning: dmacro will be removed from <header.h> in the next releaseof $LIBRARY. To use dmacro, include <moved/header.h> instead. [-W#pragma-messages]
dmacro(x, y, z);
^
Which is nice, as it does not have the unwanted quotes, however GCC will only give you this:
src/main.c:18:13: warning: dmacro
dmacro(x, y, z);
^~~~~~~~
What is even more strange, is that if you change the deprecation_message to this:
#define deprecation_message(symbol) "" #symbol "..."
then it will give you an empty warning, like it was only using the first non-white-space token from the macro argument.
To be honest with you, I don't know if this is a bug from GCC, or this is the well-defined behavior and clang is doing some extra work to make sense out of this, none the less, this is happening with the latest versions of the two compilers. (If I have to bet, I would say, this is a bug :P)
UPDATE2:
Here is a slightly modified version, which works on both compilers as you described in your comment. The trick is, that the macro DEPRECATED has two stages, instead of one.
#include <stdio.h>
#include <stdlib.h>
#define DEPRECATED_(...) #__VA_ARGS__
#define DEPRECATED(symbol) \
DEPRECATED_(#symbol will be removed from <header.h> in the next release\n \
of $LIBRARY. To use #symbol, include <moved/header.h> instead.)
#define PRAGMA_WARN_(message) _Pragma(#message)
#define PRAGMA_WARN(message) PRAGMA_WARN_(GCC warning message)
#define dmacro(a, b, c) \
PRAGMA_WARN(DEPRECATED(dmacro)) \
puts("I'm working: " #a #b #c "!")
int
main(void)
{
dmacro(x, y, z);
return EXIT_SUCCESS;
}
So this will produce the following output in clang:
src/main.c:19:5: warning: "dmacro" will be removed from <header.h> in the next release of $LIBRARY. To use "dmacro", include <moved/header.h> instead. [-W#pragma-messages]
dmacro(x, y, z);
^
And the following one in GCC:
src/main.c:19:13: warning: "dmacro" will be removed from <header.h> in the next release
of $LIBRARY. To use "dmacro", include <moved/header.h> instead.
dmacro(x, y, z);
^~~~~~~~
NOTE: I would highly recommend you, to remove the \n character from your message!