{This is a BNF for the language of the compiler project.
 This grammar was designed to facilitate the syntax-directed
 translation phase and code generation. 
 In that respect, it is a bit unnatural.                       }

 <StartSymbol>   ->      <Program> .

 <Program>       ->      program IDENTIFIER ; <Declarations> <Block>
                 !       program IDENTIFIER ; <Block> .

 <Declarations>  ->      var <Decl-list>
                 !       const <Const-list>
                 !       const <Const-list> var <Decl-list> .

 <Decl-list>     ->      <Decl-list> <Ident-list> ;
                 !       <Ident-list> ; .

 <Const-list>    ->      <Const-list> <Const-dec> ;
                 !       <Const-dec> ; .

 <Ident-list>    ->      IDENTIFIER , <Ident-list>
                 !       IDENTIFIER : <Type> .

 <Const-dec>     ->      IDENTIFIER = CONSTANT .

 <Type>          ->      integer
                 !       real .

 <Block>         ->      begin <Stat-list> end .

 <Stat-list>     ->      <Stat-list;> <Statement>
                 !       <Statement> .

 <Stat-list;>     ->      <Stat-list> ; .

 <Statement>     ->      <Assign-Ident> := <Expression>
                 !       read  ( IDENTIFIER )
                 !       write ( IDENTIFIER )
                 !       writeln ( IDENTIFIER )
                 !       write ( CONSTANT )
                 !       writeln ( CONSTANT )
                 !       <If-head> <Stat-list> endif
                 !       <If-cond> <Stat-list> endif
                 !       <Repeat-Head> <Repeat-Body> <Condition> endrepeat
                 !       <For-head> <Stat-list> endfor
                 !       <While-head> <Stat-list> endwhile .
 <Assign-Ident>  ->      IDENTIFIER .
 <If-head>       ->      <If-cond> <Stat-list> else .
 <If-cond>       ->      if <Condition> then .
 <Repeat-Head>   ->      repeat .
 <Repeat-Body>   ->      <Stat-list> until .
 <For-head>      ->     <For>  := <Expression> to <Expression> do .
 <While-head>    ->      <While> <Condition> do .
 <While>         ->      while .
 <For>           ->       for <Assign-Ident> .

 <Condition>     ->      <Condition-or> <Condition1>
                 !       <Condition1> .
 <Condition1>    ->      <Condition1-&> <Condition2>
                 !       <Condition2> .
 <Condition2>    ->      <Expression> RELOP <Expression>
                 !       <Expression> = <Expression>
                 !       ( <Condition> )
                 !       not <Condition2> .
 <Condition-or>  ->      <Condition> or .
 <Condition1-&>  ->      <Condition1> and .

 <Expression>    ->      <Expression> ADDOP <Term>
                 !       <Term> .
 <Term>          ->      <Term> MULOP <Factor>
                 !       <Factor> .
 <Factor>        ->      ADDOP <Factor>
                 !       CONSTANT
                 !       IDENTIFIER
                 !       ( <Expression> )