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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
|
%{
open ScTypes
open ScTypes.Result
module S = Symbols
let u = UTF8.from_utf8string
let extractColumnNameFromNum (fixed, (str, value)) = (fixed, value)
let build_call ident = function
| [] -> Expr.call0 ident
| [p1] -> Expr.call1 ident p1
| [p1;p2] -> Expr.call2 ident p1 p2
| [p1;p2;p3] -> Expr.call3 ident p1 p2 p3
| n -> Expr.callN ident n
%}
%token <string> REAL
%token <string> NUM
%token <string> STR
%token <string> LETTERS
%token DOLLAR
%token LPAREN
%token RPAREN
%token PLUS
%token TIMES
%token DIVIDE
%token MINUS
%token EQ NEQ
%token LT LE GT GE
%token EOF
%token SEMICOLON
%token COLON
%token POW
%nonassoc EQ NEQ LT LE GT GE
%left PLUS MINUS
%left TIMES DIVIDE
%left POW
%start<ScTypes.Expr.t> value
%start<ScTypes.Result.t> content
%%
value:
| EQ expr EOF {$2}
content:
| basic EOF {$1}
basic:
| PLUS num {Ok (Type.number $2)}
| MINUS num {Ok (Type.number (DataType.Num.neg $2))}
| num {Ok (Type.number $1)}
| NUM DIVIDE NUM DIVIDE NUM {Ok (
Type.date (
DataType.Date.get_julian_day
(int_of_string $1)
(int_of_string $3)
(int_of_string $5)
))}
| NUM COLON NUM COLON NUM {Ok (
Type.date (
let nhour = DataType.Num.div (DataType.Num.of_int @@ int_of_string $1) (DataType.Num.of_int 24)
and nmin = DataType.Num.div (DataType.Num.of_int @@ int_of_string $3) (DataType.Num.of_int 1440)
and nsec = DataType.Num.div (DataType.Num.of_int @@ int_of_string $5) (DataType.Num.of_int 86400)
in DataType.Num.add (DataType.Num.add nhour nmin) nsec
)
)}
expr:
| num {Expr.value (Type.number ($1))}
| MINUS expr {Expr.call1 S.sub $2}
| PLUS expr {Expr.call1 S.add $2}
| LETTERS ident LPAREN separated_list(SEMICOLON, expr) RPAREN { build_call (u($1 ^ $2)) $4 }
| cell {Expr.ref (Refs.cell $1)}
| cell COLON cell {Expr.ref (Refs.range $1 $3)}
| LPAREN expr RPAREN {Expr.expression $2}
| STR {Expr.value (Type.string (u $1))}
(* Mathematical operators *)
| expr MINUS expr {Expr.call2 S.sub $1 $3}
| expr DIVIDE expr {Expr.call2 S.div $1 $3}
| expr TIMES expr {Expr.call2 S.mul $1 $3}
| expr PLUS expr {Expr.call2 S.add $1 $3}
| expr POW expr {Expr.call2 S.pow $1 $3}
(* Comparaison *)
| expr EQ expr {Expr.call2 S.eq $1 $3}
| expr NEQ expr {Expr.call2 S.neq $1 $3}
| expr LT expr {Expr.call2 S.lt $1 $3}
| expr GT expr {Expr.call2 S.gt $1 $3}
| expr LE expr {Expr.call2 S.le $1 $3}
| expr GE expr {Expr.call2 S.ge $1 $3}
%inline cell:
| LETTERS NUM { Cell.from_string (false, $1) (false, int_of_string $2) }
| DOLLAR LETTERS NUM { Cell.from_string (true, $2) (false, int_of_string $3) }
| LETTERS DOLLAR NUM { Cell.from_string (false, $1) (true, int_of_string $3) }
| DOLLAR LETTERS DOLLAR NUM { Cell.from_string (true, $2) (true, int_of_string $4) }
num:
| REAL {DataType.Num.of_float @@ float_of_string $1}
| NUM {DataType.Num.of_int @@ int_of_string $1}
ident:
| text* { String.concat "" $1 }
text:
| LETTERS { $1 }
| NUM { $1 }
|
