token: keyword identifier constant string-literal punctuator preprocessing-token: header-name identifier pp-number character-constant string-literal punctuator each non-white-space character that cannot be one of the above [#2] Each preprocessing token that is converted to a token shall have the lexical form of a keyword, an identifier, a constant, a string literal, or a punctuator. keyword: one of auto enum restrict unsigned break extern return void case float short volatile char for signed while const goto sizeof _Bool continue if static _Complex default inline struct _Imaginary do int switch double long typedef else register union identifier: identifier-nondigit identifier identifier-nondigit identifier digit identifier-nondigit: nondigit universal-character-name other implementation-defined characters nondigit: one of _ a b c d e f g h i j k l m n o p q r s t u v w x y z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z digit: one of 0 1 2 3 4 5 6 7 8 9 Semantics [#4] When preprocessing tokens are converted to tokens during translation phase 7, if a preprocessing token could be converted to either a keyword or an identifier, it is converted to a keyword. universal-character-name: \u hex-quad \U hex-quad hex-quad hex-quad: hexadecimal-digit hexadecimal-digit hexadecimal-digit hexadecimal-digit constant: integer-constant floating-constant enumeration-constant character-constant integer-constant: decimal-constant integer-suffix-opt octal-constant integer-suffix-opt hexadecimal-constant integer-suffix-opt decimal-constant: nonzero-digit decimal-constant digit octal-constant: 0 octal-constant octal-digit hexadecimal-constant: hexadecimal-prefix hexadecimal-digit hexadecimal-constant hexadecimal-digit hexadecimal-prefix: one of 0x 0X nonzero-digit: one of 1 2 3 4 5 6 7 8 9 octal-digit: one of 0 1 2 3 4 5 6 7 hexadecimal-digit: one of 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F integer-suffix: unsigned-suffix long-suffix-opt unsigned-suffix long-long-suffix long-suffix unsigned-suffix-opt long-long-suffix unsigned-suffix-opt unsigned-suffix: one of u U long-suffix: one of l L long-long-suffix: one of ll LL [#5] The type of an integer constant is the first of the corresponding list in which its value can be represented. | | Octal or Hexadecimal Suffix | Decimal Constant | Constant -------------+-----------------------+----------------------- none |int |int |long int |unsigned int |long long int |long int | |unsigned long int | |long long int | |unsigned long long int -------------+-----------------------+----------------------- u or U |unsigned int |unsigned int |unsigned long int |unsigned long int |unsigned long long int |unsigned long long int -------------+-----------------------+----------------------- l or L |long int |long int |long long int |unsigned long int | |long long int | |unsigned long long int -------------+-----------------------+----------------------- Both u or U |unsigned long int |unsigned long int and l or L |unsigned long long int |unsigned long long int -------------+-----------------------+----------------------- ll or LL |long long int |long long int | |unsigned long long int -------------+-----------------------+----------------------- Both u or U |unsigned long long int |unsigned long long int and ll or LL | | floating-constant: decimal-floating-constant hexadecimal-floating-constant decimal-floating-constant: fractional-constant exponent-part-opt floating-suffix-opt digit-sequence exponent-part floating-suffix-opt hexadecimal-floating-constant: hexadecimal-prefix hexadecimal-fractional-constant binary-exponent-part floating-suffix-opt hexadecimal-prefix hexadecimal-digit-sequence binary-exponent-part floating-suffix-opt fractional-constant: digit-sequence-opt . digit-sequence digit-sequence . exponent-part: e sign-opt digit-sequence E sign-opt digit-sequence sign: one of + - digit-sequence: digit digit-sequence digit hexadecimal-fractional-constant: hexadecimal-digit-sequence-opt . hexadecimal-digit-sequence hexadecimal-digit-sequence . binary-exponent-part: p sign-opt digit-sequence P sign-opt digit-sequence hexadecimal-digit-sequence: hexadecimal-digit hexadecimal-digit-sequence hexadecimal-digit floating-suffix: one of f l F L enumeration-constant: identifier character-constant: ' c-char-sequence ' L' c-char-sequence ' c-char-sequence: c-char c-char-sequence c-char c-char: any member of the source character set except the single-quote ', backslash \, or new-line character escape-sequence escape-sequence: simple-escape-sequence octal-escape-sequence hexadecimal-escape-sequence universal-character-name simple-escape-sequence: one of \' \" \? \\ \a \b \f \n \r \t \v octal-escape-sequence: \ octal-digit \ octal-digit octal-digit \ octal-digit octal-digit octal-digit hexadecimal-escape-sequence: \x hexadecimal-digit hexadecimal-escape-sequence hexadecimal-digit string-literal: " s-char-sequence-opt " L" s-char-sequence-opt " s-char-sequence: s-char s-char-sequence s-char s-char: any member of the source character set except the double-quote ", backslash \, or new-line character escape-sequence punctuator: one of [ ] ( ) { } . -> ++ -- & * + - ~ ! / % << >> < > <= >= == != ^ | && || ? : ; ... = *= /= %= += -= <<= >>= &= ^= |= , # ## <: :> <% %> %: %:%: [#3] In all aspects of the language, the six tokens66) <: :> <% %> %: %:%: behave, respectively, the same as the six tokens [ ] { } # ## except for their spelling.67) header-name: < h-char-sequence > " q-char-sequence " h-char-sequence: h-char h-char-sequence h-char h-char: any member of the source character set except the new-line character and > q-char-sequence: q-char q-char-sequence q-char q-char: any member of the source character set except the new-line character and " pp-number: digit . digit pp-number digit pp-number identifier-nondigit pp-number e sign pp-number E sign pp-number p sign pp-number P sign pp-number . primary-expr: identifier constant string-literal ( expression ) postfix-expr: primary-expr postfix-expr [ expression ] postfix-expr ( argument-expr-list-opt ) postfix-expr . identifier postfix-expr -> identifier postfix-expr ++ postfix-expr -- ( type-name ) { initializer-list } ( type-name ) { initializer-list , } argument-expr-list: assignment-expr argument-expr-list , assignment-expr unary-expr: postfix-expr ++ unary-expr -- unary-expr unary-operator cast-expr sizeof unary-expr sizeof ( type-name ) unary-operator: one of & * + - ~ ! cast-expr: unary-expr ( type-name ) cast-expr multiplicative-expr: cast-expr multiplicative-expr * cast-expr multiplicative-expr / cast-expr multiplicative-expr % cast-expr additive-expr: multiplicative-expr additive-expr + multiplicative-expr additive-expr - multiplicative-expr shift-expr: additive-expr shift-expr << additive-expr shift-expr >> additive-expr relational-expr: shift-expr relational-expr < shift-expr relational-expr > shift-expr relational-expr <= shift-expr relational-expr >= shift-expr equality-expr: relational-expr equality-expr == relational-expr equality-expr != relational-expr AND-expr: equality-expr AND-expr & equality-expr exclusive-OR-expr: AND-expr exclusive-OR-expr ^ AND-expr inclusive-OR-expr: exclusive-OR-expr inclusive-OR-expr | exclusive-OR-expr logical-AND-expr: inclusive-OR-expr logical-AND-expr && inclusive-OR-expr logical-OR-expr: logical-AND-expr logical-OR-expr || logical-AND-expr conditional-expr: logical-OR-expr logical-OR-expr ? expression : conditional-expr assignment-expr: conditional-expr unary-expr assignment-operator assignment-expr assignment-operator: one of = *= /= %= += -= <<= >>= &= ^= |= expression: assignment-expr expression , assignment-expr constant-expr: conditional-expr declaration: declaration-specifiers init-declarator-list-opt ; declaration-specifiers: storage-class-specifier declaration-specifiers-opt type-specifier declaration-specifiers-opt type-qualifier declaration-specifiers-opt function-specifier declaration-specifiers-opt init-declarator-list: init-declarator init-declarator-list , init-declarator init-declarator: declarator declarator = initializer storage-class-specifier: typedef extern static auto register type-specifier: void char short int long float double signed unsigned _Bool _Complex _Imaginary struct-or-union-specifier enum-specifier typedef-name struct-or-union-specifier: struct-or-union identifier-opt { struct-declaration-list } struct-or-union identifier struct-or-union: struct union struct-declaration-list: struct-declaration struct-declaration-list struct-declaration struct-declaration: specifier-qualifier-list struct-declarator-list ; specifier-qualifier-list: type-specifier specifier-qualifier-list-opt type-qualifier specifier-qualifier-list-opt struct-declarator-list: struct-declarator struct-declarator-list , struct-declarator struct-declarator: declarator declarator-opt : constant-expr enum-specifier: enum identifier-opt { enumerator-list } enum identifier-opt { enumerator-list , } enum identifier enumerator-list: enumerator enumerator-list , enumerator enumerator: enumeration-constant enumeration-constant = constant-expr type-qualifier: const restrict volatile function-specifier: inline declarator: pointer-opt direct-declarator direct-declarator: identifier ( declarator ) direct-declarator [ type-qualifier-list-opt assignment-expr-opt ] direct-declarator [ static type-qualifier-list-opt assignment-expr ] direct-declarator [ type-qualifier-list static assignment-expr ] direct-declarator [ type-qualifier-list-opt * ] direct-declarator ( parameter-type-list ) direct-declarator ( identifier-list-opt ) pointer: * type-qualifier-list-opt * type-qualifier-list-opt pointer type-qualifier-list: type-qualifier type-qualifier-list type-qualifier parameter-type-list: parameter-list parameter-list , ... parameter-list: parameter-declaration parameter-list , parameter-declaration parameter-declaration: declaration-specifiers declarator declaration-specifiers abstract-declarator-opt identifier-list: identifier identifier-list , identifier type-name: specifier-qualifier-list abstract-declarator-opt abstract-declarator: pointer pointer-opt direct-abstract-declarator direct-abstract-declarator: ( abstract-declarator ) direct-abstract-declarator-opt [ assignment-expr-opt ] direct-abstract-declarator-opt [ * ] direct-abstract-declarator-opt ( parameter-type-list-opt ) typedef-name: identifier initializer: assignment-expr { initializer-list } { initializer-list , } initializer-list: designation-opt initializer initializer-list , designation-opt initializer designation: designator-list = designator-list: designator designator-list designator designator: [ constant-expr ] . identifier statement: labeled-statement compound-statement expression-statement selection-statement iteration-statement jump-statement labeled-statement: identifier : statement case constant-expr : statement default : statement compound-statement: { block-item-list-opt } block-item-list: block-item block-item-list block-item block-item: declaration statement expression-statement: expression-opt ; selection-statement: if ( expression ) statement if ( expression ) statement else statement switch ( expression ) statement iteration-statement: while ( expression ) statement do statement while ( expression ) ; for ( expr-opt ; expr-opt ; expr-opt ) statement for ( declaration expr-opt ; expr-opt ) statement jump-statement: goto identifier ; continue ; break ; return expression-opt ; translation-unit: external-declaration translation-unit external-declaration external-declaration: function-definition declaration function-definition: declaration-specifiers declarator declaration-list-opt compound-statement declaration-list: declaration declaration-list declaration preprocessing-file: group-opt group: group-part group group-part group-part: if-section control-line text-line # non-directive if-section: if-group elif-groups-opt else-group-opt endif-line if-group: # if constant-expr new-line group-opt # ifdef identifier new-line group-opt # ifndef identifier new-line group-opt elif-groups: elif-group elif-groups elif-group elif-group: # elif constant-expr new-line group-opt else-group: # else new-line group-opt endif-line: # endif new-line control-line: # include pp-tokens new-line # define identifier replacement-list new-line # define identifier lparen identifier-list-opt ) replacement-list new-line # define identifier lparen ... ) replacement-list new-line # define identifier lparen identifier-list , ... ) replacement-list new-line # undef identifier new-line # line pp-tokens new-line # error pp-tokens-opt new-line # pragma pp-tokens-opt new-line # new-line text-line: pp-tokens-opt new-line non-directive: pp-tokens new-line lparen: a ( character not immediately preceded by white-space replacement-list: pp-tokens-opt pp-tokens: preprocessing-token pp-tokens preprocessing-token new-line: the new-line character