FPLI/Parser.fsy at main · frederiklyngsoee/FPLI · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
%{
%}

// The start symbol (or non-terminal):
%start start

// Tokens (or terminals):
%token <int>    INT
%token <string> NAME
%token ELSE FALSE FUNC IF IN LET READ THEN TRUE WRITE
%token LPAR RPAR COMMA EQ SEMICOLON
%token PLUS MINUS MULT DIV MOD EQEQ BANGEQ LT LE GT GE ANDAND  OROR
%token EOF

// Associativity and precedence:

%nonassoc IN ELSE
%left     OROR
%left     ANDAND
%left     EQEQ BANGEQ
%left     LT LE GT GE
%left     PLUS MINUS
%left     MULT DIV MOD

// Declaring the types of the values produced by the different
// symbols:
%type <Syntax.prog>      start
%type <Syntax.prog>      program
%type <Syntax.def>       definition
%type <Syntax.def list>  definitions
%type <Syntax.exp>       expression
%type <Syntax.exp list>  expressions
%type <Syntax.exp list>  expression_list
%type <Syntax.name list> names
%type <Syntax.name list> name_list

%%

// Grammar rules along with the F# code to execute when they are
// reduced.

start
  : program EOF                       { $1 }

program
  : definitions expression            { Syntax.PROG ($1, $2) }

definition
  : FUNC NAME LPAR NAME RPAR EQ expression SEMICOLON { Syntax.FUNC ($2, ($4, $7)) }

definitions
  :                                   { [] }
  | definition definitions            { $1 :: $2 }

expression
  : INT                                  { Syntax.INT $1 }
  | TRUE                                 { Syntax.TRUE  }
  | NAME                                 { Syntax.VAR $1 }
  | LPAR expression RPAR                 { $2 }
  | expression PLUS expression           { Syntax.ADD($1, $3) }
  | expression MULT expression           { Syntax.MULT($1, $3) }
  | LET NAME EQ expression IN expression { Syntax.LET($2, $4, $6) }
  | expression OROR expression           { Syntax.OROR($1,$3) }
  | expression ANDAND expression         { Syntax.ANDAND($1,$3) }
  | expression EQEQ expression           { Syntax.EQEQ($1,$3) }
  | expression LT expression             { Syntax.LT($1,$3) }
  | expression LE expression             { Syntax.LE($1,$3) }
  | expression GT expression             { Syntax.GT($1,$3) }
  | expression GE expression             { Syntax.GE($1,$3) }
  | READ                                 { Syntax.READ }
  | WRITE LPAR expression RPAR           { Syntax.WRITE $3 }

expression_list
  : expression                        { [$1] }
  | expression COMMA expression_list  { $1 :: $3 }

expressions
  :                                   { [] }
  | expression_list                   { $1 }

name_list
  : NAME                              { [$1] }
  | NAME COMMA name_list              { $1 :: $3 }

names
  :                                   { [] }
  | name_list                         { $1 }