Is #include a token of type keyword?

问题

While learning C I got my first topic which was tokens. When I look at this code is pretty easy to get the picture.

int main()
{
  int x, y, total;
  x = 10, y = 20;
  total = x + y;
  printf ("Total = %d \n", total);
}

so far so good... Now when I look at this one here:

#include <stdio.h>

int main()
{
    /* code */
    printf("Hello C world! \n");

    return 0;
}

I wonder if the #include in #include <stdio.h> is a token. If yes, it should be a keyword right?

回答1:

In the line

#include <stdio.h>

#include is a pre-processor directive. <stdio.h> is additional information for the pre-processor. In this case, it specifies a file name, stdio.h, whose contents are to be included at exactly that location of the file being processed for compilation.

The lines that contain pro-processor directives are processed by the pre-processor and are never seen by the compiler when creating object code from source code.

回答2:

Here's the list of C keywords, per the latest online draft standard, section 6.4.1:

auto                 if                    unsigned
break                inline                void 
case                 int                   volatile
char                 long                  while
const                register              _Alignas
continue             restrict              _Alignof
default              return                _Atomic
do                   short                 _Bool
double               signed                _Complex
else                 sizeof                _Generic
enum                 static                _Imaginary
extern               struct                _Noreturn
float                switch                _Static_assert
for                  typedef               _Thread_local
goto                 union

The #include directive is not part of the C language grammar the way the keywords above are; it's a preprocessing directive that's removed from the source text before it's fed to the compiler.

Here are the phases of translating C code from source text to machine code (section 5.1.1.2), with some added emphasis regarding preprocessor directives:

Physical source file multibyte characters are mapped, in an implementation-defined manner, to the source character set (introducing new-line characters for end-of-line indicators) if necessary. Trigraph sequences are replaced by corresponding single-character internal representations.
Each instance of a backslash character (\) immediately followed by a new-line character is deleted, splicing physical source lines to form logical source lines. Only the last backslash on any physical source line shall be eligible for being part of such a splice. A source file that is not empty shall end in a new-line character, which shall not be immediately preceded by a backslash character before any such splicing takes place.
The source file is decomposed into preprocessing tokens⁷⁾ and sequences of white-space characters (including comments). A source file shall not end in a partial preprocessing token or in a partial comment. Each comment is replaced by one space character. New-line characters are retained. Whether each nonempty sequence of white-space characters other than new-line is retained or replaced by one space character is implementation-defined.
Preprocessing directives are executed, macro invocations are expanded, and _Pragma unary operator expressions are executed. If a character sequence that matches the syntax of a universal character name is produced by token concatenation (6.10.3.3), the behavior is undefined. A #include preprocessing directive causes the named header or source file to be processed from phase 1 through phase 4, recursively. All preprocessing directives are then deleted.
Each source character set member and escape sequence in character constants and string literals is converted to the corresponding member of the execution character set; if there is no corresponding member, it is converted to an implementation-defined member other than the null (wide) character.⁸⁾
Adjacent string literal tokens are concatenated.
White-space characters separating tokens are no longer significant. Each preprocessing token is converted into a token. The resulting tokens are syntactically and semantically analyzed and translated as a translation unit.
All external object and function references are resolved. Library components are linked to satisfy external references to functions and objects not defined in the current translation. All such translator output is collected into a program image which contains information needed for execution in its execution environment.

Basically, stages 1 through 4 describe the actions of the preprocessor. which basically massages the source text before it's translated by the compiler.

You'll want to read section 6.4 to understand the differences between preprocessor tokens and regular tokens.

来源：https://stackoverflow.com/questions/30106975/is-include-a-token-of-type-keyword

标签

include

token