<translation-unit> ::= {<external-declaration>}*

<external-declaration> ::= <function-definition>

| <declaration>

<function-definition> ::= {<declaration-specifier>}* <declarator> {<declaration>}* <compound-statement>

****************************************************************************************

<declaration> ::= {<declaration-specifier>}+ {<declarator> (= <initializer>)?}* ;

<declaration-specifier> ::= auto | register | static | extern | typedef

| <type-specifier>

| <type-qualifier>

<declarator> ::= {<pointer>}? <direct-declarator>

/* declaration= typeSpec declarator ("=" initializer)? ";"?

/* declarator = "*"* (ident | declarator) ( # 変数定義

/* typeSpec = "int" | "char"

/* | ("struct" | "union") (ident? "{" (typeSpec* declarator+) "}" | ident)

# 定義

<direct-declarator> ::= <identifier> # 変数定義

| ( <declarator> ) #

| <direct-declarator> [ {<constant-expression>}? ] # 配列定義

| <direct-declarator> ( <parameter-type-list> ) # プロトタイプ宣言

| <direct-declarator> ( {<identifier>}* ) # プロトタイプ宣言

**************************************************************************************

<type-specifier> ::= void | char | short | int | long | float | double | signed | unsigned

| <struct-or-union-specifier>

| <enum-specifier>

| <typedef-name>

<struct-or-union-specifier> ::= (struct | union) <identifier>? { {{<specifier-qualifier>}* <struct-declarator-list>}+ }

| (struct | union) <identifier>

<specifier-qualifier> ::= <type-specifier> | <type-qualifier>

<struct-declarator-list> ::= <struct-declarator>

| <struct-declarator-list> , <struct-declarator>

# 上記の文を変換可能？ <struct-declarator-list> ::= <struct-declarator> , <struct-declarator>*

<struct-declarator> ::= <declarator>

| <declarator> : <constant-expression>

| : <constant-expression>

<pointer> ::= * {<type-qualifier>}* {<pointer>}?

<type-qualifier> ::= const

| volatile

<constant-expression> ::= <conditional-expression>

<constant> ::= <integer-constant>

| <character-constant>

| <floating-constant>

| <enumeration-constant>

<type-name> ::= {<specifier-qualifier>}+ {<abstract-declarator>}?

<parameter-type-list> ::= <parameter-list>

| <parameter-list> , ...

<parameter-list> ::= <parameter-declaration>

| <parameter-list> , <parameter-declaration>

<parameter-declaration> ::= {<declaration-specifier>}+ <declarator>

| {<declaration-specifier>}+ <abstract-declarator>

| {<declaration-specifier>}+

<abstract-declarator> ::= <pointer>

| <pointer> <direct-abstract-declarator>

| <direct-abstract-declarator>

<direct-abstract-declarator> ::= ( <abstract-declarator> )

| {<direct-abstract-declarator>}? [ {<constant-expression>}? ]

| {<direct-abstract-declarator>}? ( {<parameter-type-list>}? )

<enum-specifier> ::= enum <identifier> { <enumerator-list> }

| enum { <enumerator-list> }

| enum <identifier>

<enumerator-list> ::= <enumerator>

| <enumerator-list> , <enumerator>

<enumerator> ::= <identifier>

| <identifier> = <constant-expression>

<typedef-name> ::= <identifier>

<initializer> ::= <assignment-expression>

| { <initializer-list> }

| { <initializer-list> , } # 配列の初期化時には最後がカンマで終了してもよい

<initializer-list> ::= <initializer>

| <initializer-list> , <initializer>

***********************************************************************************************************

comment

assignmentで大きく異なっている

unaryで使用されいてる記号一覧

= | *= | /= | %= | += | -= | <<= | >>= | &= | ^= | |=

++ -- & * + - ~ !

. -> ++ --

conditional-expressionで使用されいてる記号一覧

(? :) || && | ^ & == != < > <= >= << >> + - * / %

共通するもの

&(アドレス参照とAND演算子) +(単行演算子と四則演算) - *(ポインタと四則演算)

conditional-expr はunaryに持っていかなければいけない。なぜならassigmentのunaryにconditional-exprに置き換えているから

<conditional-expression> ::= <logical-or-expression>

| <logical-or-expression> ? <expression> : <conditional-expression>

これは以下のように簡略して記述可能

<conditional-expression> = <logical-or-expression> ( "?" <expression> ":" <conditional-expression> )?

* equality_expr = relational_expr | equality_expr ("==" | "!=") relational_expr

これは以下のように簡略して記述可能

* equality_expr = relational_expr (("==" | "!=") relational_expr)*

***********************************************************************************************************

<expression> ::= <assignment-expression>

| <expression> , <assignment-expression>

<assignment-expression> ::= <conditional-expression>

| <unary-expression> < = | *= | /= | %= | += | -= | <<= | >>= | &= | ^= | |= > <assignment-expression>

<unary-expression> ::= <postfix-expression>

| ++ <unary-expression>

| -- <unary-expression>

| < & | * | + | - | ~ | ! > <<cast-expression>>

| sizeof <unary-expression>

| sizeof <type-name>

<postfix-expression> ::= <primary-expression>

| <postfix-expression> [ <expression> ]

| <postfix-expression> ( {<assignment-expression>}* )

| <postfix-expression> . <identifier>

| <postfix-expression> -> <identifier>

| <postfix-expression> ++

| <postfix-expression> --

<primary-expression> ::= <identifier>

| <constant>

| <string>

| ( <expression> )

<conditional-expression> ::= <logical-or-expression>

| <logical-or-expression> ? <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>

<relational-expression> ::= <shift-expression>

| <relational-expression> < < | > | <= | >= > <shift-expression>

<shift-expression> ::= <additive-expression>

| <shift-expression> < << | >> > <additive-expression>

<additive-expression> ::= <multiplicative-expression>

| <additive-expression> < + | - > <multiplicative-expression>

<multiplicative-expression> ::= <cast-expression>

| <multiplicative-expression> < * | / | % > <cast-expression>

<cast-expression> ::= <unary-expression>

| ( <type-name> ) <cast-expression>

***********************************************************************************************************

<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>}? ;

<compound-statement> ::= { {<declaration>}* {<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>}? ; {<expression>}? ; {<expression>}? ) <statement>

<jump-statement> ::= goto <identifier> ;

| continue ;

| break ;

| return {<expression>}? ;

This grammar was adapted from Section A13 of The C programming language, 2nd edition, by Brian W. Kernighan and Dennis M. Ritchie,Prentice Hall, 1988.

identifier

/aɪˈdɛntʌˌfaɪɝ/

operatorはそのまま代入したものを記述したほうがわかりやすい

statement系

expression系

その他の簡略系にわけれるのでは？