Grammaire de C

   

Chaque règle de la grammaire commence par un non-terminal, qui désigne l'une des catégories syntaxiques du langage (par exemple declaration, expression, statement), suivie d'un << : >> ; chacune des lignes suivantes, en retrait, indique une expansion de ce non-terminal. Par exemple la première règle dit qu'un translation-unit est soit un external-declaration, soit un translation-unit suivi d'un external-declaration.

L'annotation $_{\mathsf{opt}}$, placée en indice d'un non-terminal, indique que ce non-terminal est optionnel ; par exemple, argument-expression-list$_{\mathsf{opt}}$ indique que la liste d'arguments d'un appel de fonction est optionnelle.

Les terminaux (mots-clés ou symboles) du langage sont désignés dans une fonte << typewriter >> : par exemple, void, struct, ==.

<< one of >> doit être remplacé par chacun des terminaux figurant sur la ligne suivante.

Les symboles integer-constant, etc, figurant dans la règle d'expansion de constant sont des terminaux qui ne sont pas spécifiés.

translation-unit:
		   external-declaration
		   translation-unit external-declaration   
 
external-declaration:
		   function-definition
		   declaration   
 
function-definition:
		   declaration-specifiers$_{\mathsf{opt}}$ declarator declaration-list$_{\mathsf{opt}}$ compound-statement   
 
declaration:
		   declaration-specifiers init-declarator-list$_{\mathsf{opt}}$ ;  
 
declaration-list:
		   declaration
		   declaration-list declaration   
 
declaration-specifiers:
		   storage-class-specifier declaration-specifiers$_{\mathsf{opt}}$ 
		   type-specifier declaration-specifiers$_{\mathsf{opt}}$ 
		   type-qualifier declaration-specifiers$_{\mathsf{opt}}$ 
 
   storage-class-specifier: one of
		   auto register static extern typedef   
 
type-specifier: one of
		   void char short int long float double signed
		   unsigned struct-or-union-specifier enum-specifier typedef-name   
 
type-qualifier: one of
		   const volatile   
 
struct-or-union-specifier:
		   struct-or-union identifier$_{\mathsf{opt}}$      { struct-declaration-list }
		   struct-or-union identifier   
 
 struct-or-union: one of
		   struct union   
 
struct-declaration-list:
		   struct-declaration
		   struct-declaration-list struct-declaration   
 
init-declarator-list:
		   init-declarator
		   init-declarator-list , init-declarator   
 
init-declarator:
		   declarator
		   declarator = initializer   
 
struct-declaration:
		   specifier-qualifier-list struct-declarator-list ;   
 
specifier-qualifier-list:
		   type-specifier specifier-qualifier-list$_{\mathsf{opt}}$ 
		   type-qualifier specifier-qualifier-list$_{\mathsf{opt}}$ 
 
struct-declarator-list:
		   struct-declarator
		   struct-declarator-list , struct-declarator   
 
struct-declarator:
		   declarator
		   declarator$_{\mathsf{opt}}$ : constant-expression   
 
enum-specifier:
		   enum identifier$_{\mathsf{opt}}$      { enumerator-list }
		   enum identifier   
 
enumerator-list:
		   enumerator
		   enumerator-list , enumerator   
 
enumerator:
		   identifier
		   identifier = constant-expression   
 
declarator:
		   pointer$_{\mathsf{opt}}$ direct-declarator   
 
direct-declarator:
		   identifier
		   ( declarator )
		   direct-declarator [ constant-expression$_{\mathsf{opt}}$ ]
		   direct-declarator ( parameter-type-list )
		   direct-declarator ( identifier-list$_{\mathsf{opt}}$ )   
 
pointer:
		   * type-qualifier-list$_{\mathsf{opt}}$ 
		   * type-qualifier-list$_{\mathsf{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$_{\mathsf{opt}}$ 
 
identifier-list:
		   identifier
		   identifier-list , identifier   
 
initializer:
		   assignment-expression
		   { initializer-list }
		   { initializer-list , } 
initializer-list:
		   initializer
		   initializer-list , initializer   
 
type-name:
		   specifier-qualifier-list abstract-declarator$_{\mathsf{opt}}$ 
 
abstract-declarator:
		   pointer
		   pointer$_{\mathsf{opt}}$ direct-abstract-declarator   
 
direct-abstract-declarator:
		   ( abstract-declarator )
		   direct-abstract-declarator$_{\mathsf{opt}}$ [ constant-expression$_{\mathsf{opt}}$ ]
		   direct-abstract-declarator$_{\mathsf{opt}}$ ( parameter-type-list$_{\mathsf{opt}}$ )   
 
typedef-name:
		   identifier   
 
statement:
		   labeled-statement
		   expression-statement
		   compound-statement
		   selection-statement
		   iteration-statement
		   jump-statement   
 
labeled-statement:
		   identifier : statement
		   case constant-expression : statement
		   default : statement   
 
expression-statement:
		   expression$_{\mathsf{opt}}$ ;  
 
compound-statement:
		   {      declaration-list$_{\mathsf{opt}}$ statement-list$_{\mathsf{opt}}$      }   
 
statement-list:
		   statement
		   statement-list statement   
 
 selection-statement:
		   if ( expression ) statement
		   if ( expression ) statement else statement
		   switch ( expression ) statement   
 
  iteration-statement:
		   while ( expression ) statement
		   do statement while ( expression ) ;
		   for (      expression$_{\mathsf{opt}}$ ;      expression$_{\mathsf{opt}}$ ;     expression$_{\mathsf{opt}}$ )      statement   
 
 jump-statement:
		   goto identifier ;
		   continue ;
		   break ;
		   return expression$_{\mathsf{opt}}$ ; 
 
expression:
		   assignment-expression
		   expression , assignment-expression   
 
assignment-expression:
		   conditional-expression
		   unary-expression assignment-operator assignment-expression   
 
assignment-operator: one of
		   =  *=  /=  %=  +=  -=  < < =   =  &=  =  |=    
 
conditional-expression:
		   logical-OR-expression
		   logical-OR-expression  ? expression : conditional-expression   
 
constant-expression:
		   conditional-expression   
 
logical-OR-expression:
		   logical-AND-expression
		   logical-OR-expression || logical-AND-expression   
 
logical-AND-expression:
		   inclusive-OR-expression
		   logical-AND-expression && inclusive-OR-expression   
 
inclusive-OR-expression:
		   exclusive-OR-expression
		   inclusive-OR-expression | exclusive-OR-expression   
 
exclusive-OR-expression:
		   AND-expression
		   exclusive-OR-expression ^ AND-expression   
 
AND-expression:
		   equality-expression
		   AND-expression & equality-expression   
 
equality-expression:
		   relational-expression
		   equality-expression == relational-expression
		   equality-expression != relational-expression   
 
relational-expression:
		   shift-expression
		   relational-expression < shift-expression
		   relational-expression > shift-expression
		   relational-expression <= shift-expression
		   relational-expression >= shift-expression   
 
shift-expression:
		   additive-expression
		   shift-expression < <  additive-expression
		   shift-expression  additive-expression   
 
additive-expression:
		   multiplicative-expression
		   additive-expression + multiplicative-expression
		   additive-expression - multiplicative-expression   
 
multiplicative-expression:
		   cast-expression
		   multiplicative-expression * cast-expression
		   multiplicative-expression / cast-expression
		   multiplicative-expression % cast-expression   
 
cast-expression:
		   unary-expression
		   ( type-name ) cast-expression   
 
unary-expression:
		   postfix-expression
		   ++ unary-expression
		   - unary-expression
		   unary-operator cast-expression
		   sizeof unary-expression
		   sizeof ( type-name )   
 
unary-operator:  one of
		   &  *  +  -      !   
 
postfix-expression:
		   primary-expression
		   postfix-expression [ expression ]
		   postfix-expression ( argument-expression-list$_{\mathsf{opt}}$ )
		   postfix-expression . identifier
		   postfix-expression -> identifier
		   postfix-expression ++
		   postfix-expression -   
 
primary-expression:
		   identifier
		   constant
		   string
		   ( expression )   
 
argument-expression-list:
		   assignment-expression
		   argument-expression-list , assignment-expression   
 
constant:
		   integer-constant
		   character-constant
		   floating-constant
		   enumeration-constant