bnf.txt

<program>                   := <program-item>*
<program-item>              := <declaration>
                                | <func-def>
                                | <inline-asm> ";"
<inline-asm>                := "__asm__" "(" <string-literal> ")" 
<func-def>                  := <declaration-specifiers> <declarator> <blockstmt>

<declaration>               := <declaration-specifiers> <init-declarator>* ";"
<declaration-specifiers>    := <type-specifiers> <declaration-specifiers>?
                                | <storage-class-specifier> <declaration-specifiers>?
<type-specifiers>           := "int"
                                | "char"
                                | <struct-or-union-specifier>
                                | <enum-specifier>
                                | <typedef-name>
<storage-class-specifier>   := "typedef"

<struct-or-union-specifier> := "struct" <ident>? "{" <struct-declaration-list> "}"
                                | "struct" <ident>
<struct-declaration-list>   := <struct-declaration-list> <specifier-qualifier-list> <declarator>
<specifier-qualifier-list>  := (<type-specifier> | <type-qualifier>)*

<enum-specifier>            := "enum" <ident>? { <enumerator-list> ","? }
                            := "enum" <ident>
<enumerator-list>           := <enumerator>
                                | <enumerator-list> "," <enumerator>
<enumerator>                := <enumeration-constant>
<enumeration-constant>      := <ident>

<init-declarator>           := <declarator> ("=" <initializer>)?
<declarator>                := "*"* <direct-declarator>
<direct-declarator>         := <ident>
                                | "(" <declarator> ")"
                                | <direct-declarator> "[" <assign>? "]"                                 # array
                                | <direct-declarator> "(" (<declaration> ("," <declaration>) )? ")"     # function
<initializer>               := <assign>
                                | "{" <initializer-list> "}"
                                | "{" <initializer-list> "," "}"
<initializer-list>          := <initializer>
                                <initializer-list> "," <initializer>

<type-name>                 := <specifier-qualifier-list> <abstract-declarator>?
<specifier-qualifier-list>  := <type-specifiers>
<abstract-declarator>       := "*"* <direct-abstract-declarator>?
<direct-abstract-declarator>:= <direct-abstract-declarator>? [ <assign> ]
                                | <direct-abstract-declarator>? ( <parameter-type-list>? )
<parameter-type-list>       := <parameter-list>
<parameter-list>            := <parameter-declaration>
                                | <parameter-list> "," <parameter-declaration> "," "..."
<parameter-declaration>     := <declaration-specifiers> <declarator>
                                | <declaration-specifiers> <abstract-declarator>


<stmt>                      := <expr> ";"
                                | <blockstmt>
                                | "return" <expr> ";"
                                | "return" ";"
                                | "if" "(" <expr> ")" <stmt> ("else" stmt)?
                                | "for" "(" <expr>? ";" <expr>? ";" <expr>? ")" <stmt>
                                | "for" "(" <declaration> ";" <expr>? ";" <expr>? ")" <stmt>
                                | switch "(" <expr> ")" <stmt>
                                | <labeled-stmt>
                                | <jump-statement>
<blockstmt>                 := "{" ( <stmt> | <declaration> ";" )* "}"
<labeled-stmt>              := <ident> ":" <stmt>
                                | "case" <expr> : <stmt>
                                | "default" ":" <stmt>
<jump-statement>            := "continue" ";"
                                | "break" ";"



<expr>                      := <assign>
                                | <expr> "," <assign>
<assign>                    := <conditional> ("=" <assign>)?
<assign-operator>           := "=" | "*=" | "/=" | "+=" | "-=" | "<<=" | ">>=" | "&=" | "^=" | "|="
<conditional>               := <logical-or> 
                                | <logical-or> "?" <expr> : <conditional>
<logical-or>                := <logical-or>
                                | <logical-or> || <logical-and>
<logical-and>               := <bit-wise-and>
                                | <logical-and> && <bit-wise-and>
<bit-wise-and>              := <equality> ("&" <equality>)*
<equality>                  := <relational> ("==" <relational> | "!=" <relational>)*
<relational>                := <shift> ("<" <shift> | "<=" <shift> | ">" <shift> | ">=" <shift>)*
<shift>                     := <add> ("<<" <add> | ">>" <add>)*
<add>                       := <mul> ("+" <mul> | "-" <mul>)*
<mul>                       := <unary> ("*" <unary> | "/" <unary> | "%" <unary>)*
<unary>                     := <postfix>
                                | "+" <unary>
                                | "-" <unary>
                                | "~" <unary>
                                | "!" <unary>
                                | "*" <unary>
                                | "&" <unary>
                                | "sizeof" <unary>
                                | "sizeof" "(" <type-name> ")"
                                | "++" <unary>
                                | "--" <unary>
<postfix>                   := <primary>
                                | <postfix> "[" <expr> "]"
                                | <postfix> "." <ident>
                                | <postfix> "->" <ident>
                                | <postfix> "++"
                                | <postfix> "--"
<primary>                   := <num> 
                                | <string-literal> 
                                | <ident> "(" (<expr> ("," <expr>)*)? ")"
                                | <ident> 
                                | "(" <expr> ")"  
                                | <inline-asm>
<string-literal>            :=  ( """ <letters> """ )*