How do I show the value of a #define at compile-time?

by

I know that this is a long time after the original query, but this may still be useful.

This can be done in GCC using the stringify operator “#”, but it requires two stages.

#define XSTR(x) STR(x)
#define STR(x) #x

The value of a macro can then be displayed with:

#pragma message "The value of ABC: " XSTR(ABC)

See: 3.4 Stringification in the gcc online documentation.

How it works:

The preprocessor understands quoted strings and handles them differently from normal text. String concatenation is an example of this special treatment. The message pragma requires an argument that is a quoted string. When there is more than one component to the argument then they must all be strings so that string concatenation can be applied. The preprocessor can never assume that an unquoted string should be treated as if it were quoted. If it did then:

#define ABC 123
int n = ABC;

would not compile.

Now consider:

#define ABC abc
#pragma message "The value of ABC is: " ABC

which is equivalent to

#pragma message "The value of ABC is: " abc

This causes a preprocessor warning because abc (unquoted) cannot be concatenated with the preceding string.

Now consider the preprocessor stringize (Which was once called stringification, the links in the documentation have been changed to reflect the revised terminology. (Both terms, incidentally, are equally detestable. The correct term is, of course, stringifaction. Be ready to update your links.)) operator. This acts only on the arguments of a macro and replaces the unexpanded argument with the argument enclosed in double quotes. Thus:

#define STR(x) #x
char *s1 = "abc";
char *s2 = STR(abc);

will assign identical values to s1 and s2. If you run gcc -E you can see this in the output. Perhaps STR would be better named something like ENQUOTE.

This solves the problem of putting quotes around an unquoted item, the problem now is that, if the argument is a macro, the macro will not be expanded. This is why the second macro is needed. XSTR expands its argument, then calls STR to put the expanded value into quotes.

More Related Contents:

  1. How can I generate unique values in the C preprocessor?
  2. Variadic recursive preprocessor macros – is it possible?
  3. The need for parentheses in macros in C [duplicate]
  4. Real-world use of X-Macros
  5. Macro definition to determine big endian or little endian machine?
  6. Are typedef and #define the same in c?
  7. Comma in C/C++ macro
  8. What exactly do C include guards do?
  9. Array-size macro that rejects pointers
  10. Preprocessor output
  11. Can a Rust macro create new identifiers?
  12. Generating documentation in macros
  13. Is the C99 preprocessor Turing complete?
  14. What makes Lisp macros so special?
  15. Macros in Swift?
  16. Construct path for #include directive with macro
  17. Escaping a # symbol in a #define macro?
  18. How do I match the type of an expression in a Rust macro?
  19. macro definition containing #include directive
  20. C Macros to create strings
  21. Macro and function with same name
  22. Can I redefine a C++ macro then define it back?
  23. Is there a way to count with macros?
  24. Can macros match against constant arguments instead of literals?
  25. How to tame the Windows headers (useful defines)?
  26. How to auto execute a macro when opening a Powerpoint presentation?
  27. Expand macro inside string literal
  28. How to enforce that a type implements a trait at compile time?
  29. How to view C preprocessor output?
  30. Macros to create strings in C

Leave a Comment