How to generate a newline in a cpp macro?

Question

How do I write a cpp macro which expands to include newlines?

Solution 1

I am working on a large project that involves a lot of preprocessor macro functions to synthesize any code that cannot be replaced by templates. Believe me, I am familiar with all sorts of template tricks, but as long as there is no standardized, type safe metaprogramming language that can directly create code, we will have to stick with good old preprocessor and its cumbersome macros to solve some problems that would require to write ten times more code without. Some of the macros span many lines and they are very hard to read in preprocessed code. Therefore, I thought of a solution to that problem and what I came up with is the following:

Let's say we have a C/C++ macro that spans multiple lines, e.g. in a file named MyMacro.hpp

// Content of MyMacro.hpp

#include "MultilineMacroDebugging.hpp"

#define PRINT_VARIABLE(S) \
__NL__  std::cout << #S << ": " << S << std::endl; \
__NL__  /* more lines if necessary */ \
__NL__  /* even more lines */

In every file where I defined such a macro, I include another file MultilineMacroDebugging.hpp that contains the following:

// Content of MultilineMacroDebugging.hpp

#ifndef HAVE_MULTILINE_DEBUGGING
#define __NL__
#endif

This defines an empty macro __NL__, which makes the __NL__ definitions disappear during preprocessing. The macro can then be used somewhere, e.g. in a file named MyImplementation.cpp.

// Content of MyImplementation.cpp

// Uncomment the following line to enable macro debugging
//#define HAVE_MULTILINE_DEBUGGING

#include "MyMacro.hpp"

int a = 10;
PRINT_VARIABLE(a)

If I need to debug the PRINT_VARIABLE macro, I just uncomment the line that defines the macro HAVE_MULTILINE_DEBUGGING in MyImplementation.cpp. The resulting code does of course not compile, as the __NL__ macro results undefined, which causes it to remain in the compiled code, but it can, however, be preprocessed.

The crucial step is now to replace the __NL__ string in the preprocessor output by newlines using your favorite text editor and, voila, you end up with a readable representation of the result of the replaced macro after preprocessing which resembles exactly what the compiler would see, except for the artificially introduced newlines.

Solution 2

It is not possible. It would only be relevant if you were looking at listing files or pre-processor output.

A common technique in writing macros so that they are easier to read is to use the \ character to continue the macro onto a following line.

I (believe I) have seen compilers that include new lines in the expanded macros in listing output - for your benefit. This is only of use to us poor humans reading the expanded macros to try to understand what we really asked the compiler to do. it makes no difference to the compiler.

The C & C++ languages treat all whitespace outside of strings in the same way. Just as a separator.

Solution 3

C & C++ compilers ignore unquoted whitespace (except for the > > template issue), so getting a macro to emit newlines doesn't really make sense. You can make a macro span several lines by ending each line of the macro with a backslash, but this doesn't output newlines.

Solution 4

The C compiler is aware of white space, but it doesn't distinguish between spaces, tabs or new lines.

If you mean how do I have a new line inside a string in a macro, then:

#define SOME_STRING "Some string\n with a new line."

will work.

View more solutions

Comments

[SirDarius]

can you explain why you want to do this?

[Erel Segal-Halevi]

@LouFranco probably to make it more readable?

[Slipp D. Thompson]

Looking at the answers below it seems pretty clear that you can't. Taking this into regard, the issue may be “Ur doin' it rong”. A better solution for you (and a common one when using C macros) might be to have the macro simply do the minimal work only it can, then hand off most of the work to a helper function. The power of macros + functional nicely-formatted C code in non-optimized builds = win win.

[Kuba hasn't forgotten Monica]

This is a possible duplicate of How to make G++ preprocessor output a newline in a macro? Although the other question is more specific, it has good answers that cover all that's asked here.

[jberryman]

It's not uncommon for languages which have meaningful whitespace (like haskell with GHC) to use the C pre-processor for constants and macro expansion. It's also used by gcc when processing assembly files (when the extension is .S). So that's three use cases fwiw

[NoahR]

This would be very useful for macros that should produce #pragmas in the expanded body. ( case at hand OpenMP )

[Jean-Bernard Jansen]

I'm piping the result of cpp into clang-format. Now I get a readable result.

[jww]

Maybe relevant: Pre-Processing using m4 and Replacements for the C preprocessor. (I really need something to add some newlines so I can untangle the macros).

[Steve Jessop]

This expands to "if(a) { b += c }", with no newlines. Try it with gcc -E.

[Trent]

The macro definition should not include the trailing semicolon. This makes the macro call look and act like more like a function call.

[Branan]

It does. But it lets you edit the newline in a multi-line fashion, shich is what I think the OP wanted

[monkeydom]

It actually makes sense if you like to check the preprocessed code. Then the newlines would help to assess it's correctness for debugging purposes.

[David Baird]

Why does this answer get upvotes? It doesn't answer the question.

[bddicken]

@DavidBaird Ditto. The answer doesn't really address the question.

[David Baird]

@bddicken- My situation is what monkeydom said, which actually does make sense!

[Slipp D. Thompson]

@DavidBaird @​​​bddicken: I think it's pretty easily implied from the answer that “you can't”, even if the author didn't say it directly. And looking at the other answers, it seems that is the truth— there is no way to do this, sorry nope. Given that, this answer is one of the shortest and most-concise in giving validation to the design of the system, the next best thing to “you can't”.

[Kuba hasn't forgotten Monica]

"It would only be relevant if you were looking at listing files or pre-processor output." That was, um, like the whole point of the question :)

[Scott Smith]

I think you meant to type "lets you edit the MACRO in a multi-line fashion"

[Peter Mortensen]

It is (somewhat) possible. See Potatoswatter's answer to How to make G++ preprocessor output a newline in a macro?. For debugging, filtering solutions can be used.

[Henrik]

google always brings me here. So for me, and everyone else, here is an online tool I found that helps restructuring the macro output: codebeautify.org/c-formatter-beautifier

[rew]

FYI: I'm trying to generate a few lines of assembly in a .S file from a macro.... Alas, the assembler does NOT allow multiple statements on a line.