!============================================== Abbreviations used in grammar

{Hex Digit}      = {Digit} + [abcdefABCDEF]
{Oct Digit}      = [01234567]

{Id Head}        = {Letter} + [_]
{Id Tail}        = {Id Head} + {Digit}

{String Ch}      = {Printable} - ["]
{Char Ch}        = {Printable} - ['']

DecLiteral       = [123456789]{digit}*
OctLiteral       = 0{Oct Digit}*
HexLiteral       = 0x{Hex Digit}+
FloatLiteral     = {Digit}*.{Digit}+

StringLiteral    = '"'( {String Ch} | '\'{Printable} )* '"'
CharLiteral      = '' ( {Char Ch} | '\'{Printable} )''

Id               = {Id Head}{Id Tail}*

!============================================== The grammar starts here!

<Declarations> ::= <Declaration> <Declarations>
                 |

<Declaration> ::= <Function Declare>
                | <Function Prototype>
                | <Struct Declare>
                | <Union Declare>
                | <Enum Declare>
                | <Var Declare>    
                | typedef id id ';'
                
!============================================== Functions

<Function Prototype> ::= <Type> <Var> '(' <Type List> ')' ';'
                       | <Type> <Var> '(' ')' ';'

<Type List>          ::= <Type> ',' <Id List>
                       | <Type>

<Function Declare> ::= <Type> <Var> '(' <Param List>  ')' <Block>
                     | <Type> <Var> '(' <Id List> ')' <Struct Def> <Block>
                     | <Type> <Var> '(' ')' <Block>

<Param List>       ::= <Type> <Var> ',' <Param List>
                     | <Type> <Var> 
   
<Id List>          ::= Id ',' <Id List>
                     | Id

!============================================== Enums and Structs

<Struct Declare> ::= struct Id '{' <Struct Def> '}' 

<Union Declare> ::= union Id '{' <Struct Def> '}' 


<Struct Def>     ::= <Var Declare> <Struct Def>
                   | <Var Declare>

<Enum Declare> ::= enum Id '{' <Enum Def> '}' 

<Enum Def>     ::= <Enum Val> ',' <Enum Def>
                 | <Enum Val>

<Enum Val>     ::= Id
                 | Id '=' OctLiteral
                 | Id '=' HexLiteral
                 | Id '=' DecLiteral  

!============================================== Variable Declaration
      
<Var Declare> ::= <Type> <Var List> ';'

<Type>        ::= <Storage Spec> <Type Quant> <Type Mod> <Type Base>
                | struct Id 
                | struct '{' <Struct Def> '}' 
                | union Id
                | union '{' <Struct Def> '}' 
                | enum Id  

<Storage Spec> ::= extern 
                 | static
                 | register
                 | auto
                 |

<Type Quant>   ::= volatile
                 | const
                 |

<Type Mod>     ::= signed 
                 | unsigned
                 | long
                 | short
                 | signed short
                 | unsigned short
                 | signed long
                 | unsigned long
                 |

<Type Base>    ::= char
                 | int
                 | float
                 | double
                 | void               

<Var>          ::= '*' <Var>
                 | Id

<Var List>     ::= <Var> ',' <Var List>
                 | <Var>

!============================================== Statements

<Statement>  ::= <Var Declare>
               | <Label>
               | if '(' <Expression> ')' <Statement>          
               | if '(' <Expression> ')' <Then Stm> else <Statement>         
               | while '(' <Expression> ')' <Statement> 
               | <Normal Stm>

<Then Stm>   ::= if '(' <Expression> ')' <Then Stm> else <Then Stm> 
               | while '(' <Expression> ')' <Then Stm> 
               | for '(' <For Arg> ';' <For Arg> ';' <For Arg> ')' <Then Stm>
               | <Normal Stm>

<Normal Stm> ::= do <Statement> while '(' <Expression> ')'
               | switch '(' <Expression> ')' '{' <Case Labels> '}'
               | <Block>
               | <Expression> ';'               
               | goto Id ';'
               | break ';'
               | continue ';'
               | return <Expression> ';'


<Label>     ::= Id ':'

<For Arg>   ::= <Expression> 
              | 

<Case Labels> ::= case Id ':' <Stm List> <Case Labels>
                | default ':' <Stm List>                  
                |

<Block>     ::= '{' <Stm List> '}' 

<Stm List>  ::=  <Statement> <Stm List> 
              | 


! =====================================================
! Here begins the C's 15 levels of operator precedence.
! =====================================================

<Expression> ::= <Expression> ',' <Op Assign>   
               | <Op Assign>

<Op Assign>  ::= <L Value> '='  <Op Assign>
               | <L Value> '+=' <Op Assign>
               | <L Value> '-=' <Op Assign>
               | <L Value> '*=' <Op Assign>
               | <L Value> '/=' <Op Assign>
               | <L Value> '^=' <Op Assign>
               | <L Value> '&=' <Op Assign>
               | <L Value> '|=' <Op Assign>
               | <Op If>

<Op If>      ::= <Op Or> '?' <Op If> ':' <Op If>
               | <Op Or>

<Op Or>      ::= <Op Or> '||' <Op And>
               | <Op And>

<Op And>     ::= <Op And> '&&' <Op BinOR>
               | <Op BinOR>

<Op BinOR>   ::= <Op BinOr> '|' <Op BinXOR>
               | <Op BinXOR>

<Op BinXOR>  ::= <Op BinXOR> '^' <Op BinAND>
               | <Op BinAND>

<Op BinAND>  ::= <Op BinAND> '&' <Op Equate>
               | <Op Equate>

<Op Equate>  ::= <Op Equate> '==' <Op Compare>
               | <Op Equate> '!=' <Op Compare>
               | <Op Compare>

<Op Compare> ::= <Op Compare> '<'  <Op Shift>
               | <Op Compare> '>'  <Op Shift>
               | <Op Compare> '<=' <Op Shift>
               | <Op Compare> '>=' <Op Shift>
               | <Op Shift>

<Op Shift>   ::= <Op Shift> '<<' <Op Add>
               | <Op Shift> '>>' <Op Add>
               | <Op Add>

<Op Add>     ::= <Op Add> '+' <Op Mult>
               | <Op Add> '-' <Op Mult>
               | <Op Mult>

<Op Mult>    ::= <Op Mult> '*' <Op Other>
               | <Op Mult> '/' <Op Other>
               | <Op Mult> '%' <Op Other>
               | <Op Other>

<Op Other>   ::= '!' <Op Other>
               | '~' <Op Other>
               | '++' <L Value>
               | <L Value> '++'
               | '--' <L Value>
               | <L Value> '--'
               | '-' <Op Other>
               | '(' <Type> ')' <Op Other>
               | '*' <Op Other>
               | '&' <Op Other>
               | sizeof <Op Other>
               | <R Value>

<R Value>    ::= '(' <Expression> ')'
               | Id '(' <Expression> ')'
               | Id '(' ')'            
               | OctLiteral
               | HexLiteral
               | DecLiteral  
               | StringLiteral
               | CharLiteral
               | FloatLiteral
               | <L Value>

<L Value>     ::= Id
                | Id '.' <L Value> 
                | Id '[' <Expression> ']'
                | Id '->' Id