AssignmentParser.fsp

// MADE BY: Kevin Moore s204462, Aryan Mirzazadeh s204489, Jakob Jacobsen s204502, Bjørn Laursen s204451
// Open the file that defines the type "expr" we shall use as AST
%{
open AssignmentTypesAST 
%}

// Declare the tokens (terminal symbols)
%token <float> NUM
%token <string> VAR
%token TIMES DIV PLUS MINUS POW LPAR RPAR EOF
%token ASSIGN SEMICOLON SKIP LBRACKET RBRACKET IF FI DO OD ASSERTS OR AND EQ LE GR NOT TRUE FALSE
// NOTE: the actual formats of these tokens are defined in the lexer file
//       as regular expressions

// Specify precedence and associativity of operators
// Precedence is given by the order (from low to high)
// COMMENTED OUT

// %left PLUS MINUS 
// %left TIMES DIV 
// %right POW


// We declare the initial non-terminal symbol
%start start

// We specify the return type of each of then non-terminal symbols
%type <command> start
%type <command> command
%type <guardedCommand> guardedCommand
%type <aExpr> aExpr0
%type <aExpr> aExpr1
%type <aExpr> aExpr2
%type <aExpr> aExpr3
%type <bExpr> bExpr0
%type <bExpr> bExpr1
%type <bExpr> bExpr2
%type <bExpr> bExpr3

// Grammar productions
%%

// The first production in "formal" notation is
// start -> expression
// here written:
start: command EOF             { $1 }

// Note that we need to insert an End-Of-File (EOF)
// The code annotation { $1 } specifies that parsing with this production
// returns whatever parsing the expression returns: $1 is the result of parsing
// the first component of the production (i.e. expression)

// The productions for expressions are like in the grammar we saw in class
// written in the yacc format:

// C ::= x := a | A[a] := a | skip | C ; C | if GC fi | do GC od
// GC ::= b -> C | GC [] GC
// a ::= n | x | A[a] | a + a | a - a | a * a | a / a | - a | a ^ a | (a)
// b ::= true | false | b & b | b | b | b && b | b || b | !b
// | a = a | a != a | a > a | a >= a | a < a | a <= a | (b)

command:
  | VAR ASSIGN aExpr0 SEMICOLON command                                      { CommandSeq(AssignVarExpr($1, $3), $5) }
  | VAR ASSIGN aExpr0                                                        { AssignVarExpr($1, $3) }
  | SKIP SEMICOLON command                                                   { CommandSeq(Skip, $3)}
  | SKIP                                                                     { Skip }
  | VAR LBRACKET aExpr0 RBRACKET ASSIGN aExpr0 SEMICOLON command            { CommandSeq(AssignArray($1, $3, $6), $8) }
  | VAR LBRACKET aExpr0 RBRACKET ASSIGN aExpr0                              { AssignArray($1, $3, $6) } // A[a] := a  
  | IF guardedCommand FI SEMICOLON command                                   { CommandSeq(IfExpr($2), $5) }
  | IF guardedCommand FI                                                     { IfExpr($2) }
  | DO guardedCommand OD SEMICOLON command                                   { CommandSeq(DoExpr($2), $5) }
  | DO guardedCommand OD                                                     { DoExpr($2) }

guardedCommand:
  | bExpr0 ASSERTS command LBRACKET RBRACKET guardedCommand                   { GCSequence(BoolGC($1, $3), $6) }
  | bExpr0 ASSERTS command                                                    { BoolGC($1, $3) } 

// Arithmetic Expressions (Priority 0 to 3 highest)
aExpr0:
  | aExpr0 PLUS aExpr1                                                        { PlusExpr($1,$3) }
  | aExpr0 MINUS aExpr1                                                       { MinusExpr($1,$3) }
  | aExpr1                                                                    { $1 }

aExpr1:
  | aExpr1 TIMES aExpr2                                                        { TimesExpr($1,$3) }
  | aExpr1 DIV aExpr2         { DivExpr($1,$3) }
  | aExpr2                    { $1 }

aExpr2:
  | aExpr3 POW aExpr2     { PowExpr($1,$3) }
  | aExpr3                { $1 }

aExpr3:
  | PLUS aExpr3                           { UPlusExpr($2) }
  | MINUS aExpr3                          { UMinusExpr($2) }
  | NUM                                   { Num($1) }
  | VAR                                   { Var($1) }
  | VAR LBRACKET aExpr0 RBRACKET          { ListAExpr($1,$3) }
  | LPAR aExpr0 RPAR                      { $2 }
  
// Boolean Expressions (Priority 0 to 3 highest)
bExpr0:
  | bExpr0 OR OR bExpr1                   { SCOrExpr($1, $4) }
  | bExpr0 OR bExpr1                      { OrExpr($1, $3) }
  | bExpr1                                { $1 }

bExpr1:
  | bExpr1 AND AND bExpr2                 { SCAndExpr($1, $4) }
  | bExpr1 AND bExpr2                     { AndExpr($1, $3) }
  | bExpr2                                { $1 }

bExpr2:
  | aExpr0 EQ aExpr0                      { EqExpr($1, $3) }
  | aExpr0 LE EQ aExpr0                   { LeEqExpr($1, $4) }
  | aExpr0 LE aExpr0                      { LeExpr($1, $3) }
  | aExpr0 GR EQ aExpr0                   { GrEqExpr($1, $4) }
  | aExpr0 GR aExpr0                      { GrExpr($1, $3) }
  | aExpr0 NOT EQ aExpr0                  { NotEqExpr($1, $4) }
  | bExpr3                                { $1 }

bExpr3:
  | NOT bExpr3                            { NotExpr($2) }
  | TRUE                                  { BoolExpr(true) }
  | FALSE                                 { BoolExpr(false) }
  | LPAR bExpr0 RPAR                      { $2 }

// Again, the code annotation specifies the result of parsing
// For example { TimesExpr($1,$3) } specifies that parsing with the production
// returns the value TimesExpr($1,$3), where $i is the result of parsing
// component i in the production (in this case the lhs and rhs operands)

%%