Slightly Looser Rules For Escaped Newlines; String Literals With Embedded Newlines - Red Hat ENTERPRISE LINUX 3 - USING GCC Using Instructions

132 Chapter 6. Extensions to the C Language Family
6.15. Macros with a Variable Number of Arguments.
In the ISO C standard of 1999, a macro can be declared to accept a variable number of arguments
much as a function can. The syntax for defining the macro is similar to that of a function. Here is an
example:
#define debug(format, ...) fprintf (stderr, format, __VA_ARGS__)
Here is a variable argument. In the invocation of such a macro, it represents the zero or more
...
tokens until the closing parenthesis that ends the invocation, including any commas. This set of tokens
replaces the identifier in the macro body wherever it appears. See the CPP manual for
__VA_ARGS__
more information.
GCC has long supported variadic macros, and used a different syntax that allowed you to give a name
to the variable arguments just like any other argument. Here is an example:
#define debug(format, args...) fprintf (stderr, format, args)
This is in all ways equivalent to the ISO C example above, but arguably more readable and descriptive.
GNU CPP has two further variadic macro extensions, and permits them to be used with either of the
above forms of macro definition.
In standard C, you are not allowed to leave the variable argument out entirely; but you are allowed to
pass an empty argument. For example, this invocation is invalid in ISO C, because there is no comma
after the string:
debug ("A message")
GNU CPP permits you to completely omit the variable arguments in this way. In the above examples,
the compiler would complain, though since the expansion of the macro still has the extra comma after
the format string.
To help solve this problem, CPP behaves specially for variable arguments used with the token paste
operator, . If instead you write
##
#define debug(format, ...) fprintf (stderr, format, ## __VA_ARGS__)
and if the variable arguments are omitted or empty, the operator causes the preprocessor to remove
##
the comma before it. If you do provide some variable arguments in your macro invocation, GNU
CPP does not complain about the paste operation and instead places the variable arguments after the
comma. Just like any other pasted macro argument, these arguments are not macro expanded.

6.16. Slightly Looser Rules for Escaped Newlines

Recently, the preprocessor has relaxed its treatment of escaped newlines. Previously, the newline
had to immediately follow a backslash. The current implementation allows whitespace in the form of
spaces, horizontal and vertical tabs, and form feeds between the backslash and the subsequent newline.
The preprocessor issues a warning, but treats it as a valid escaped newline and combines the two lines
to form a single logical line. This works within comments and tokens, including multi-line strings, as
well as between tokens. Comments are not treated as whitespace for the purposes of this relaxation,
since they have not yet been replaced with spaces.