Compiler Implementation

The following textural transformation is done before everything:

1. The input file is read into memory and broken into lines.
2. Continued lines (line ends with a backslash and newline) are merged into one long line. There's NO way to prevent a backslash at the end of a line from being interpreted as a backslash-newline.
3. All comments are replaced with single spaces. Block comments (/* */) does not nest. Line comments (//) can nest because it doesn't matter. It is safe to put line comments inside block comments, or vice versa.

After these steps, the tokenization is performed. Then the true "preprocessing" is performed.

Preprocessing directives are lines in your program that start with #. Whitespace is allowed before and after the #. The ‘#’ is followed by an identifier, the directive name. The ‘#’ which begins a directive cannot come from a macro expansion. Also, the directive name is not macro expanded.

The primary directives do:

• Inclusion of header files.
• Macro expansion.
• Conditional compilation.
• Line control.
• Diagnostics.

Macro has two kinds, object like (e.g. BUFFER) and function like (i.e. takes parameters). For function-like macros, all arguments to a macro are completely macro-expanded before they are substituted into the macro body.

https://gcc.gnu.org/onlinedocs/cpp/Stringification.html

Parameters are not replaced inside string constants.

When a macro parameter is used with a leading ‘#’, the preprocessor replaces it with the literal text of the actual argument, converted to a string constant. Unlike normal parameter replacement, the argument is not macro-expanded first. This is called stringification.

Stringification in C involves more than putting double-quote characters around the fragment. The preprocessor backslash-escapes the quotes surrounding embedded string constants, and all backslashes within string and character constants, in order to get a valid C string constant with the proper contents.

https://gcc.gnu.org/onlinedocs/cpp/Concatenation.html

token pasting or token concatenation

When a macro is expanded, the two tokens on either side of each ## operator are combined into a single token, which then replaces the ## and the two original tokens in the macro expansion.

Two tokens that don't together form a valid token cannot be pasted together. CPP will give warning.

  struct command
  {
    char *name;
    void (*function) (void);
  };
  struct command commands[] =
    {
      { "quit", quit_command },
      { "help", help_command },
      ...
    };

can be wrote as:

  #define COMMAND(NAME)  { #NAME, NAME ## _command }
  struct command commands[] =
    {
      COMMAND (quit),
      COMMAND (help),
      ...
    };

Another example:

#define paster( n ) printf_s( "token" #n " = %d", token##n )
int token9 = 9;

becomes

printf_s( "token" "9" " = %d", token9 );
// =>
printf_s( "token9 = %d", token9 );

# linenum filename flags

They mean that the following line originated in file filename at line linenum.

After the file name comes zero or more flags, which are ‘1’, ‘2’, ‘3’, or ‘4’. If there are multiple flags, spaces separate them, and must be in ascending order.

1

This indicates the start of a new file.

2

This indicates returning to a file (after having included another file).

3

This indicates that the following text comes from a system header file, so certain warnings should be suppressed.

4

This indicates that the following text should be treated as being wrapped in an implicit extern "C" block.

They are treated like the corresponding #line directive, except that trailing flags are permitted.

It can have three formats:

#line linum

a non-negative integer

#line linum filename

a string constant

#line anything else

This is just a dummy, anything else must be a macro, and expands to the above two format.

The only things that changed are __FILE__ and __LINE__.