parser.mly 37.4 KB
Newer Older
1 2 3
(********************************************************************)
(*                                                                  *)
(*  The Why3 Verification Platform   /   The Why3 Development Team  *)
MARCHE Claude's avatar
MARCHE Claude committed
4
(*  Copyright 2010-2017   --   INRIA - CNRS - Paris-Sud University  *)
5 6 7 8
(*                                                                  *)
(*  This software is distributed under the terms of the GNU Lesser  *)
(*  General Public License version 2.1, with the special exception  *)
(*  on linking described in file LICENSE.                           *)
9
(*                                                                  *)
10
(********************************************************************)
Jean-Christophe Filliâtre's avatar
Jean-Christophe Filliâtre committed
11 12 13 14

%{
  open Ptree

15
  let infix  s = "infix "  ^ s
16
  let prefix s = "prefix " ^ s
17
  let mixfix s = "mixfix " ^ s
18

Andrei Paskevich's avatar
Andrei Paskevich committed
19 20 21
  let qualid_last = function Qident x | Qdot (_, x) -> x

  let use_as q = function Some x -> x | None -> qualid_last q
22

23
  let floc s e = Loc.extract (s,e)
24

25
  let model_label = Ident.create_label "model"
26
  let model_projected = Ident.create_label "model_projected"
27

28 29 30
  let is_model_label l = match l with
    | Lstr lab -> Ident.lab_equal lab model_label ||
                  Ident.lab_equal lab model_projected
31
    | Lpos _ -> false
32

33
  let model_lab_present labels = List.exists is_model_label labels
34

35 36
  let is_model_trace_label l = match l with
    | Lstr lab -> Strings.has_prefix "model_trace:" lab.Ident.lab_string
37
    | Lpos _ -> false
38 39

  let model_trace_lab_present labels = List.exists is_model_trace_label labels
40 41

  let add_model_trace name labels =
42
    if model_lab_present labels && not (model_trace_lab_present labels) then
43 44
      (Lstr (Ident.create_label ("model_trace:" ^ name)))::labels
    else
45
      labels
46

47
  let add_lab id l = { id with id_lab = add_model_trace id.id_str l }
48

49
  let id_anonymous loc = { id_str = "_"; id_lab = []; id_loc = loc }
50

51
  let mk_id id s e = { id_str = id; id_lab = []; id_loc = floc s e }
52

53 54
  let get_op s e = Qident (mk_id (mixfix "[]") s e)
  let set_op s e = Qident (mk_id (mixfix "[<-]") s e)
55 56 57
  let sub_op s e = Qident (mk_id (mixfix "[_.._]") s e)
  let above_op s e = Qident (mk_id (mixfix "[_..]") s e)
  let below_op s e = Qident (mk_id (mixfix "[.._]") s e)
58

59 60
  let mk_pat  d s e = { pat_desc  = d; pat_loc  = floc s e }
  let mk_term d s e = { term_desc = d; term_loc = floc s e }
61
  let mk_expr d s e = { expr_desc = d; expr_loc = floc s e }
62

63 64 65
  let variant_union v1 v2 = match v1, v2 with
    | _, [] -> v1
    | [], _ -> v2
66
    | _, ({term_loc = loc},_)::_ -> Loc.errorm ~loc
67 68 69 70 71 72
        "multiple `variant' clauses are not allowed"

  let empty_spec = {
    sp_pre     = [];
    sp_post    = [];
    sp_xpost   = [];
73
    sp_reads   = [];
74 75
    sp_writes  = [];
    sp_variant = [];
76 77
    sp_checkrw = false;
    sp_diverge = false;
78
  }
79

80 81 82 83
  let spec_union s1 s2 = {
    sp_pre     = s1.sp_pre @ s2.sp_pre;
    sp_post    = s1.sp_post @ s2.sp_post;
    sp_xpost   = s1.sp_xpost @ s2.sp_xpost;
84
    sp_reads   = s1.sp_reads @ s2.sp_reads;
85 86
    sp_writes  = s1.sp_writes @ s2.sp_writes;
    sp_variant = variant_union s1.sp_variant s2.sp_variant;
87 88
    sp_checkrw = s1.sp_checkrw || s2.sp_checkrw;
    sp_diverge = s1.sp_diverge || s2.sp_diverge;
89
  }
90

91
(* dead code
92
  let add_init_mark e =
93
    let init = { id_str = "Init"; id_lab = []; id_loc = e.expr_loc } in
94
    { e with expr_desc = Emark (init, e) }
95
*)
96

97
  let small_integer i =
98
    try match i with
99 100 101 102
      | Number.IConstDec s -> int_of_string s
      | Number.IConstHex s -> int_of_string ("0x"^s)
      | Number.IConstOct s -> int_of_string ("0o"^s)
      | Number.IConstBin s -> int_of_string ("0b"^s)
103
    with Failure _ -> raise Error
104

105 106
  let error_param loc =
    Loc.errorm ~loc "cannot determine the type of the parameter"
107

108 109 110 111 112
  let error_loc loc = Loc.error ~loc Error

  let () = Exn_printer.register (fun fmt exn -> match exn with
    | Error -> Format.fprintf fmt "syntax error"
    | _ -> raise exn)
Jean-Christophe Filliâtre's avatar
Jean-Christophe Filliâtre committed
113 114
%}

115
(* Tokens *)
Jean-Christophe Filliâtre's avatar
Jean-Christophe Filliâtre committed
116

Clément Fumex's avatar
Clément Fumex committed
117
%token <string> LIDENT LIDENT_QUOTE UIDENT UIDENT_QUOTE
Andrei Paskevich's avatar
Andrei Paskevich committed
118
%token <Number.integer_constant> INTEGER
119
%token <string> OP1 OP2 OP3 OP4 OPPREF
120
%token <Number.real_constant> REAL
Jean-Christophe Filliâtre's avatar
Jean-Christophe Filliâtre committed
121
%token <string> STRING
122
%token <Loc.position> POSITION
123
%token <string> QUOTE_LIDENT
124

125
(* keywords *)
126

Martin Clochard's avatar
Martin Clochard committed
127
%token AS AXIOM BY CLONE COINDUCTIVE CONSTANT
Clément Fumex's avatar
Clément Fumex committed
128
%token ELSE END EPSILON EXISTS EXPORT FALSE FLOAT FORALL FUNCTION
Andrei Paskevich's avatar
Andrei Paskevich committed
129
%token GOAL IF IMPORT IN INDUCTIVE LEMMA
130
%token LET MATCH META NOT PREDICATE RANGE SCOPE
Martin Clochard's avatar
Martin Clochard committed
131
%token SO THEN THEORY TRUE TYPE USE WITH
132

133
(* program keywords *)
134

135
%token ABSTRACT ABSURD ANY ASSERT ASSUME AT BEGIN CHECK
136
%token DIVERGES DO DONE DOWNTO ENSURES EXCEPTION FOR
137
%token FUN GHOST INVARIANT LABEL MODULE MUTABLE OLD
138 139
%token PRIVATE PURE RAISE RAISES READS REC REQUIRES
%token RETURN RETURNS TO TRY VAL VARIANT WHILE WRITES
140

141
(* symbols *)
142

Andrei Paskevich's avatar
Andrei Paskevich committed
143
%token AND ARROW
144
%token BAR
145
%token COLON COMMA
146
%token DOT DOTDOT EQUAL LT GT LTGT MINUS
147
%token LEFTPAR LEFTPAR_STAR_RIGHTPAR LEFTSQ
148
%token LARROW LRARROW OR
149
%token RIGHTPAR RIGHTSQ
Andrei Paskevich's avatar
Andrei Paskevich committed
150
%token UNDERSCORE
151 152 153

%token EOF

154
(* program symbols *)
155

156
%token AMPAMP BARBAR LEFTBRC RIGHTBRC SEMICOLON
157

158
(* Precedences *)
Jean-Christophe Filliâtre's avatar
Jean-Christophe Filliâtre committed
159

160
%nonassoc IN
161 162
%nonassoc below_SEMI
%nonassoc SEMICOLON
163
%nonassoc LET VAL EXCEPTION
164
%nonassoc prec_no_else
165
%nonassoc DOT ELSE GHOST
166
%nonassoc prec_named
167
%nonassoc COLON (* weaker than -> because of t: a -> b *)
Andrei Paskevich's avatar
Andrei Paskevich committed
168
%right ARROW LRARROW
Martin Clochard's avatar
Martin Clochard committed
169
%right BY SO
170 171
%right OR BARBAR
%right AND AMPAMP
Andrei Paskevich's avatar
Andrei Paskevich committed
172
%nonassoc NOT
173
%right EQUAL LTGT LT GT OP1
174
%nonassoc AT OLD
175
%nonassoc LARROW
176
%nonassoc RIGHTSQ    (* stronger than <- for e1[e2 <- e3] *)
177
%left OP2 MINUS
178
%left OP3
179
%left OP4
180
%nonassoc prec_prefix_op
181
%nonassoc INTEGER REAL
182 183
%nonassoc LEFTSQ
%nonassoc OPPREF
184

185
(* Entry points *)
Jean-Christophe Filliâtre's avatar
Jean-Christophe Filliâtre committed
186

187
%start <Pmodule.pmodule Stdlib.Mstr.t> mlw_file
Jean-Christophe Filliâtre's avatar
Jean-Christophe Filliâtre committed
188 189
%%

190
(* Modules and scopes *)
191

192
mlw_file:
193 194 195 196 197
| mlw_module* EOF
    { Typing.close_file () }
| module_decl+ EOF
    { let loc = floc $startpos($2) $endpos($2) in
      Typing.close_module loc; Typing.close_file () }
198

199
mlw_module:
200 201
| module_head module_decl* END
    { Typing.close_module (floc $startpos($3) $endpos($3)) }
202

203
module_head:
204 205
| THEORY labels(uident_nq)  { Typing.open_module $2 }
| MODULE labels(uident_nq)  { Typing.open_module $2 }
206

Andrei Paskevich's avatar
Andrei Paskevich committed
207 208
scope_head:
| SCOPE boption(IMPORT) uident
209
    { Typing.open_scope (floc $startpos $endpos) $3; $2 }
Andrei Paskevich's avatar
Andrei Paskevich committed
210

211
module_decl:
Andrei Paskevich's avatar
Andrei Paskevich committed
212
| scope_head module_decl* END
213
    { Typing.close_scope (floc $startpos($1) $endpos($1)) ~import:$1 }
Andrei Paskevich's avatar
Andrei Paskevich committed
214 215 216
| d = pure_decl | d = prog_decl | d = meta_decl
    { Typing.add_decl (floc $startpos $endpos) d }
| use_clone { () }
217

218
(* Use and clone *)
219

220
use_clone:
Andrei Paskevich's avatar
Andrei Paskevich committed
221 222 223 224 225 226
| USE EXPORT tqualid
    { Typing.add_decl (floc $startpos $endpos) (Duse $3) }
| CLONE EXPORT tqualid clone_subst
    { Typing.add_decl (floc $startpos $endpos) (Dclone ($3, $4)) }
| USE boption(IMPORT) tqualid option(preceded(AS, uident))
    { let loc = floc $startpos $endpos in
227
      Typing.open_scope loc (use_as $3 $4);
Andrei Paskevich's avatar
Andrei Paskevich committed
228
      Typing.add_decl loc (Duse $3);
229
      Typing.close_scope loc ~import:$2 }
Andrei Paskevich's avatar
Andrei Paskevich committed
230 231
| CLONE boption(IMPORT) tqualid option(preceded(AS, uident)) clone_subst
    { let loc = floc $startpos $endpos in
232
      Typing.open_scope loc (use_as $3 $4);
Andrei Paskevich's avatar
Andrei Paskevich committed
233
      Typing.add_decl loc (Dclone ($3, $5));
234
      Typing.close_scope loc ~import:$2 }
235

236
clone_subst:
Andrei Paskevich's avatar
Andrei Paskevich committed
237 238 239 240
| (* epsilon *)                         { [] }
| WITH comma_list1(single_clone_subst)  { $2 }

single_clone_subst:
Andrei Paskevich's avatar
Andrei Paskevich committed
241
| TYPE qualid ty_var* EQUAL ty  { CStsym  ($2,$3,$5) }
242
| TYPE qualid                   { CStsym  ($2, [], PTtyapp ($2, [])) }
Andrei Paskevich's avatar
Andrei Paskevich committed
243
| CONSTANT  qualid EQUAL qualid { CSfsym  ($2,$4) }
244
| CONSTANT  qualid              { CSfsym  ($2,$2) }
Andrei Paskevich's avatar
Andrei Paskevich committed
245
| FUNCTION  qualid EQUAL qualid { CSfsym  ($2,$4) }
246
| FUNCTION  qualid              { CSfsym  ($2,$2) }
Andrei Paskevich's avatar
Andrei Paskevich committed
247
| PREDICATE qualid EQUAL qualid { CSpsym  ($2,$4) }
248
| PREDICATE qualid              { CSpsym  ($2,$2) }
Andrei Paskevich's avatar
Andrei Paskevich committed
249
| VAL       qualid EQUAL qualid { CSvsym  ($2,$4) }
250
| VAL       qualid              { CSvsym  ($2,$2) }
251 252
| EXCEPTION qualid EQUAL qualid { CSxsym  ($2,$4) }
| EXCEPTION qualid              { CSxsym  ($2,$2) }
253
| AXIOM     qualid              { CSaxiom ($2) }
Andrei Paskevich's avatar
Andrei Paskevich committed
254 255
| LEMMA     qualid              { CSlemma ($2) }
| GOAL      qualid              { CSgoal  ($2) }
256

Andrei Paskevich's avatar
Andrei Paskevich committed
257
(* Meta declarations *)
258

Andrei Paskevich's avatar
Andrei Paskevich committed
259 260
meta_decl:
| META sident comma_list1(meta_arg)  { Dmeta ($2, $3) }
261 262

meta_arg:
263 264 265 266
| TYPE      ty      { Mty $2 }
| CONSTANT  qualid  { Mfs $2 }
| FUNCTION  qualid  { Mfs $2 }
| PREDICATE qualid  { Mps $2 }
267 268 269
| AXIOM     qualid  { Max $2 }
| LEMMA     qualid  { Mlm $2 }
| GOAL      qualid  { Mgl $2 }
270 271
| STRING            { Mstr $1 }
| INTEGER           { Mint (small_integer $1) }
272

Andrei Paskevich's avatar
Andrei Paskevich committed
273 274 275 276 277 278 279 280 281
(* Theory declarations *)

pure_decl:
| TYPE with_list1(type_decl)                { Dtype $2 }
| CONSTANT  constant_decl                   { Dlogic [$2] }
| FUNCTION  function_decl  with_logic_decl* { Dlogic ($2::$3) }
| PREDICATE predicate_decl with_logic_decl* { Dlogic ($2::$3) }
| INDUCTIVE   with_list1(inductive_decl)    { Dind (Decl.Ind, $2) }
| COINDUCTIVE with_list1(inductive_decl)    { Dind (Decl.Coind, $2) }
Clément Fumex's avatar
Clément Fumex committed
282 283 284
| AXIOM labels(ident_nq) COLON term         { Dprop (Decl.Paxiom, $2, $4) }
| LEMMA labels(ident_nq) COLON term         { Dprop (Decl.Plemma, $2, $4) }
| GOAL  labels(ident_nq) COLON term         { Dprop (Decl.Pgoal, $2, $4) }
Andrei Paskevich's avatar
Andrei Paskevich committed
285

286
(* Type declarations *)
287 288

type_decl:
289
| labels(lident_nq) ty_var* typedefn invariant*
290
  { let (vis, mut), def = $3 in
291
    { td_ident = $1; td_params = $2;
292 293 294
      td_vis = vis; td_mut = mut;
      td_inv = $4; td_def = def;
      td_loc = floc $startpos $endpos } }
295

296
ty_var:
297
| labels(quote_lident) { $1 }
Jean-Christophe Filliâtre's avatar
Jean-Christophe Filliâtre committed
298 299

typedefn:
300
| (* epsilon *)
301
    { (Abstract, false), TDrecord [] }
302 303
| EQUAL vis_mut bar_list1(type_case)
    { $2, TDalgebraic $3 }
304
| EQUAL vis_mut LEFTBRC loption(semicolon_list1(type_field)) RIGHTBRC
305 306 307
    { $2, TDrecord $4 }
| EQUAL vis_mut ty
    { $2, TDalias $3 }
Clément Fumex's avatar
Clément Fumex committed
308 309
(* FIXME: allow negative bounds *)
| EQUAL LT RANGE INTEGER INTEGER GT
310 311
    { (Public, false),
      TDrange (Number.compute_int $4, Number.compute_int $5) }
Clément Fumex's avatar
Clément Fumex committed
312
| EQUAL LT FLOAT INTEGER INTEGER GT
313 314
    { (Public, false),
      TDfloat (small_integer $4, small_integer $5) }
315 316 317 318 319 320 321

vis_mut:
| (* epsilon *)     { Public, false }
| MUTABLE           { Public, true  }
| abstract          { $1, false }
| abstract MUTABLE  { $1, true }
| MUTABLE abstract  { $2, true }
322 323

abstract:
324 325
| PRIVATE           { Private }
| ABSTRACT          { Abstract }
326

327
type_field:
328
| labels(lident_nq) cast
Andrei Paskevich's avatar
Andrei Paskevich committed
329 330
  { { f_ident = $1; f_mutable = false; f_ghost = false;
      f_pty = $2; f_loc = floc $startpos $endpos } }
Clément Fumex's avatar
Clément Fumex committed
331
| field_modifiers labels(lident_nq) cast
332 333
  { { f_ident = $2; f_mutable = fst $1; f_ghost = snd $1;
      f_pty = $3; f_loc = floc $startpos $endpos } }
334

335 336 337 338 339 340
field_modifiers:
| MUTABLE       { true,  false }
| GHOST         { false, true  }
| GHOST MUTABLE { true,  true  }
| MUTABLE GHOST { true,  true  }

341
type_case:
Clément Fumex's avatar
Clément Fumex committed
342
| labels(uident_nq) params { floc $startpos $endpos, $1, $2 }
343

344
(* Logic declarations *)
345

346 347
constant_decl:
| labels(lident_rich) cast preceded(EQUAL,term)?
348 349
  { { ld_ident = $1; ld_params = []; ld_type = Some $2;
      ld_def = $3; ld_loc = floc $startpos $endpos } }
350

351 352
function_decl:
| labels(lident_rich) params cast preceded(EQUAL,term)?
353 354
  { { ld_ident = $1; ld_params = $2; ld_type = Some $3;
      ld_def = $4; ld_loc = floc $startpos $endpos } }
Andrei Paskevich's avatar
Andrei Paskevich committed
355

356 357
predicate_decl:
| labels(lident_rich) params preceded(EQUAL,term)?
358 359
  { { ld_ident = $1; ld_params = $2; ld_type = None;
      ld_def = $3; ld_loc = floc $startpos $endpos } }
360

361
with_logic_decl:
362
| WITH labels(lident_rich) params cast? preceded(EQUAL,term)?
363 364
  { { ld_ident = $2; ld_params = $3; ld_type = $4;
      ld_def = $5; ld_loc = floc $startpos $endpos } }
Jean-Christophe Filliâtre's avatar
Jean-Christophe Filliâtre committed
365

366
(* Inductive declarations *)
367 368

inductive_decl:
369
| labels(lident_rich) params ind_defn
370 371
  { { in_ident = $1; in_params = $2;
      in_def = $3; in_loc = floc $startpos $endpos } }
372

373 374 375
ind_defn:
| (* epsilon *)             { [] }
| EQUAL bar_list1(ind_case) { $2 }
Jean-Christophe Filliâtre's avatar
Jean-Christophe Filliâtre committed
376

377
ind_case:
Clément Fumex's avatar
Clément Fumex committed
378
| labels(ident_nq) COLON term  { floc $startpos $endpos, $1, $3 }
Jean-Christophe Filliâtre's avatar
Jean-Christophe Filliâtre committed
379

380
(* Type expressions *)
381

382 383 384 385
ty:
| ty_arg          { $1 }
| lqualid ty_arg+ { PTtyapp ($1, $2) }
| ty ARROW ty     { PTarrow ($1, $3) }
Jean-Christophe Filliâtre's avatar
Jean-Christophe Filliâtre committed
386

387 388
ty_arg:
| lqualid                           { PTtyapp ($1, []) }
389
| quote_lident                      { PTtyvar $1 }
390 391 392
| LEFTPAR comma_list2(ty) RIGHTPAR  { PTtuple $2 }
| LEFTPAR RIGHTPAR                  { PTtuple [] }
| LEFTPAR ty RIGHTPAR               { PTparen $2 }
Andrei Paskevich's avatar
Andrei Paskevich committed
393
| LEFTBRC ty RIGHTBRC               { PTpure $2 }
394

395 396
cast:
| COLON ty  { $2 }
397

398
(* Parameters and binders *)
399

400 401
(* [param] and [binder] below must have the same grammar
   and raise [Error] in the same cases. Interpretaion of
402 403
   single-standing untyped [Qident]'s is different: [param]
   treats them as type expressions, [binder], as parameter
404 405
   names, whose type must be inferred. *)

406
params:  param*  { List.concat $1 }
407

408
binders: binder+ { List.concat $1 }
409 410 411

param:
| anon_binder
412 413 414 415 416 417 418 419
    { error_param (floc $startpos $endpos) }
| ty_arg
    { [floc $startpos $endpos, None, false, $1] }
| LEFTPAR GHOST ty RIGHTPAR
    { [floc $startpos $endpos, None, true, $3] }
| ty_arg label label*
    { match $1 with
      | PTtyapp (Qident _, []) ->
420 421
             error_param (floc $startpos $endpos)
      | _ -> error_loc (floc $startpos($2) $endpos($2)) }
422
| LEFTPAR binder_vars_rest RIGHTPAR
423
    { match $2 with [l,_] -> error_param l
424
      | _ -> error_loc (floc $startpos($3) $endpos($3)) }
425
| LEFTPAR GHOST binder_vars_rest RIGHTPAR
426
    { match $3 with [l,_] -> error_param l
427 428
      | _ -> error_loc (floc $startpos($4) $endpos($4)) }
| LEFTPAR binder_vars cast RIGHTPAR
429
    { List.map (fun (l,i) -> l, i, false, $3) $2 }
430
| LEFTPAR GHOST binder_vars cast RIGHTPAR
431
    { List.map (fun (l,i) -> l, i, true, $4) $3 }
Jean-Christophe Filliâtre's avatar
Jean-Christophe Filliâtre committed
432

433 434
binder:
| anon_binder
435
    { let l,i = $1 in [l, i, false, None] }
436 437 438 439
| ty_arg
    { match $1 with
      | PTtyapp (Qident id, [])
      | PTparen (PTtyapp (Qident id, [])) ->
440 441
             [floc $startpos $endpos, Some id, false, None]
      | _ -> [floc $startpos $endpos, None, false, Some $1] }
442 443 444
| LEFTPAR GHOST ty RIGHTPAR
    { match $3 with
      | PTtyapp (Qident id, []) ->
445 446
             [floc $startpos $endpos, Some id, true, None]
      | _ -> [floc $startpos $endpos, None, true, Some $3] }
447 448 449
| ty_arg label label*
    { match $1 with
      | PTtyapp (Qident id, []) ->
450 451 452
             let id = add_lab id ($2::$3) in
             [floc $startpos $endpos, Some id, false, None]
      | _ -> error_loc (floc $startpos($2) $endpos($2)) }
453
| LEFTPAR binder_vars_rest RIGHTPAR
454
    { match $2 with [l,i] -> [l, i, false, None]
455
      | _ -> error_loc (floc $startpos($3) $endpos($3)) }
456
| LEFTPAR GHOST binder_vars_rest RIGHTPAR
457
    { match $3 with [l,i] -> [l, i, true, None]
458 459
      | _ -> error_loc (floc $startpos($4) $endpos($4)) }
| LEFTPAR binder_vars cast RIGHTPAR
460
    { List.map (fun (l,i) -> l, i, false, Some $3) $2 }
461
| LEFTPAR GHOST binder_vars cast RIGHTPAR
462
    { List.map (fun (l,i) -> l, i, true, Some $4) $3 }
463

464 465 466
binder_vars:
| binder_vars_head  { List.rev $1 }
| binder_vars_rest  { $1 }
467

468
binder_vars_rest:
469 470 471 472 473 474 475
| binder_vars_head label label* binder_var*
    { List.rev_append (match $1 with
        | (l, Some id) :: bl ->
            let l3 = floc $startpos($3) $endpos($3) in
            (Loc.join l l3, Some (add_lab id ($2::$3))) :: bl
        | _ -> assert false) $4 }
| binder_vars_head anon_binder binder_var*
476
    { List.rev_append $1 ($2 :: $3) }
477
| anon_binder binder_var*
478
    { $1 :: $2 }
Jean-Christophe Filliâtre's avatar
Jean-Christophe Filliâtre committed
479

480
binder_vars_head:
481
| ty {
482 483
    let of_id id = id.id_loc, Some id in
    let push acc = function
484
      | PTtyapp (Qident id, []) -> of_id id :: acc
485
      | _ -> Loc.error ~loc:(floc $startpos $endpos) Error in
486
    match $1 with
487
      | PTtyapp (Qident id, l) -> List.fold_left push [of_id id] l
488
      | _ -> Loc.error ~loc:(floc $startpos $endpos) Error }
489

490
binder_var:
Clément Fumex's avatar
Clément Fumex committed
491 492
| labels(lident_nq) { floc $startpos $endpos, Some $1 }
| anon_binder       { $1 }
493 494

anon_binder:
Clément Fumex's avatar
Clément Fumex committed
495
| UNDERSCORE        { floc $startpos $endpos, None }
496

497 498 499 500 501 502 503 504 505
(* Logical terms *)

mk_term(X): d = X { mk_term d $startpos $endpos }

term: t = mk_term(term_) { t }

term_:
| term_arg_
    { match $1 with (* break the infix relation chain *)
506 507 508
      | Tinfix (l,o,r) -> Tinnfix (l,o,r)
      | Tbinop (l,o,r) -> Tbinnop (l,o,r)
      | d -> d }
509
| NOT term
510
    { Tnot $2 }
511
| OLD term
512
    { Tat ($2, mk_id Dexpr.old_mark $startpos($1) $endpos($1)) }
513 514
| term AT uident
    { Tat ($1, $3) }
515 516
| prefix_op term %prec prec_prefix_op
    { Tidapp (Qident $1, [$2]) }
517 518 519 520 521 522
| MINUS INTEGER
    { Tidapp (Qident (mk_id (prefix "-") $startpos($1) $endpos($1)),
        [mk_term (Tconst (Number.ConstInt $2)) $startpos($2) $endpos($2)]) }
| MINUS REAL
    { Tidapp (Qident (mk_id (prefix "-") $startpos($1) $endpos($1)),
        [mk_term (Tconst (Number.ConstReal $2)) $startpos($2) $endpos($2)]) }
523 524
| l = term ; o = bin_op ; r = term
    { Tbinop (l, o, r) }
525
| l = term ; o = infix_op_1 ; r = term
526
    { Tinfix (l, o, r) }
527 528
| l = term ; o = infix_op_234 ; r = term
    { Tidapp (Qident o, [l; r]) }
529 530 531 532 533 534
| term_arg located(term_arg)+ (* FIXME/TODO: "term term_arg" *)
    { let join f (a,_,e) = mk_term (Tapply (f,a)) $startpos e in
      (List.fold_left join $1 $2).term_desc }
| IF term THEN term ELSE term
    { Tif ($2, $4, $6) }
| LET pattern EQUAL term IN term
535 536 537 538 539 540 541 542 543
    { let cast ty = { $4 with term_desc = Tcast ($4, ty) } in
      let pat, def = match $2.pat_desc with
        | Ptuple [] -> { $2 with pat_desc = Pwild }, cast (PTtuple [])
        | Pcast ({pat_desc = (Pvar (_,false)|Pwild)} as p, ty) -> p, cast ty
        | _ -> $2, $4 in
      match pat.pat_desc with
      | Pvar (id,false) -> Tlet (id, def, $6)
      | Pwild -> Tlet (id_anonymous pat.pat_loc, def, $6)
      | _ -> Tmatch (def, [pat, $6]) }
544 545
| LET labels(lident_op_id) EQUAL term IN term
    { Tlet ($2, $4, $6) }
546
| LET labels(lident_nq) mk_term(lam_defn) IN term
547 548 549
    { Tlet ($2, $3, $5) }
| LET labels(lident_op_id) mk_term(lam_defn) IN term
    { Tlet ($2, $3, $5) }
550 551 552 553 554 555
| MATCH term WITH match_cases(term) END
    { Tmatch ($2, $4) }
| MATCH comma_list2(term) WITH match_cases(term) END
    { Tmatch (mk_term (Ttuple $2) $startpos($2) $endpos($2), $4) }
| quant comma_list1(quant_vars) triggers DOT term
    { Tquant ($1, List.concat $2, $3, $5) }
556
| FUN binders ARROW term
557
    { Tquant (Dterm.DTlambda, $2, [], $4) }
558 559 560 561 562 563 564
| EPSILON
    { Loc.errorm "Epsilon terms are currently not supported in WhyML" }
| label term %prec prec_named
    { Tnamed ($1, $2) }
| term cast
    { Tcast ($1, $2) }

565
lam_defn:
566
| binders EQUAL term  { Tquant (Dterm.DTlambda, $1, [], $3) }
567

568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583
term_arg: mk_term(term_arg_) { $1 }
term_dot: mk_term(term_dot_) { $1 }

term_arg_:
| qualid                    { Tident $1 }
| numeral                   { Tconst $1 }
| TRUE                      { Ttrue }
| FALSE                     { Tfalse }
| o = oppref ; a = term_arg { Tidapp (Qident o, [a]) }
| term_sub_                 { $1 }

term_dot_:
| lqualid                   { Tident $1 }
| o = oppref ; a = term_dot { Tidapp (Qident o, [a]) }
| term_sub_                 { $1 }

Andrei Paskevich's avatar
M.()  
Andrei Paskevich committed
584
term_block:
585 586 587 588 589
| LEFTPAR term RIGHTPAR                             { $2.term_desc }
| LEFTPAR RIGHTPAR                                  { Ttuple [] }
| LEFTPAR comma_list2(term) RIGHTPAR                { Ttuple $2 }
| LEFTBRC field_list1(term) RIGHTBRC                { Trecord $2 }
| LEFTBRC term_arg WITH field_list1(term) RIGHTBRC  { Tupdate ($2,$4) }
Andrei Paskevich's avatar
M.()  
Andrei Paskevich committed
590 591 592 593 594

term_sub_:
| term_block                                        { $1 }
| uqualid DOT mk_term(term_block)                   { Tscope ($1, $3) }
| term_dot DOT lqualid_rich                         { Tidapp ($3,[$1]) }
595 596 597 598
| term_arg LEFTSQ term RIGHTSQ
    { Tidapp (get_op $startpos($2) $endpos($2), [$1;$3]) }
| term_arg LEFTSQ term LARROW term RIGHTSQ
    { Tidapp (set_op $startpos($2) $endpos($2), [$1;$3;$5]) }
599 600 601 602 603 604
| term_arg LEFTSQ term DOTDOT term RIGHTSQ
    { Tidapp (sub_op $startpos($2) $endpos($2), [$1;$3;$5]) }
| term_arg LEFTSQ term DOTDOT RIGHTSQ
    { Tidapp (above_op $startpos($2) $endpos($2), [$1;$3]) }
| term_arg LEFTSQ DOTDOT term RIGHTSQ
    { Tidapp (below_op $startpos($2) $endpos($2), [$1;$4]) }
605

606 607
field_list1(X):
| fl = semicolon_list1(separated_pair(lqualid, EQUAL, X)) { fl }
608

609 610
match_cases(X):
| cl = bar_list1(separated_pair(pattern, ARROW, X)) { cl }
611

612 613
quant_vars:
| binder_var+ cast? { List.map (fun (l,i) -> l, i, false, $2) $1 }
614

615 616 617
triggers:
| (* epsilon *)                                                 { [] }
| LEFTSQ separated_nonempty_list(BAR,comma_list1(term)) RIGHTSQ { $2 }
618

619
%inline bin_op:
620 621 622 623 624 625
| ARROW   { Dterm.DTimplies }
| LRARROW { Dterm.DTiff }
| OR      { Dterm.DTor }
| BARBAR  { Dterm.DTor_asym }
| AND     { Dterm.DTand }
| AMPAMP  { Dterm.DTand_asym }
626 627
| BY      { Dterm.DTby }
| SO      { Dterm.DTso }
628

629
quant:
630 631
| FORALL  { Dterm.DTforall }
| EXISTS  { Dterm.DTexists }
632

633 634
numeral:
| INTEGER { Number.ConstInt $1 }
Clément Fumex's avatar
Clément Fumex committed
635
| REAL    { Number.ConstReal $1 }
636

637
(* Program declarations *)
638

Andrei Paskevich's avatar
Andrei Paskevich committed
639
prog_decl:
640 641
| VAL ghost kind labels(lident_rich) mk_expr(val_defn) { Dlet ($4, $2, $3, $5) }
| LET ghost kind labels(lident_rich) mk_expr(fun_defn) { Dlet ($4, $2, $3, $5) }
642
| LET ghost kind labels(lident_rich) const_defn        { Dlet ($4, $2, $3, $5) }
643
| LET REC with_list1(rec_defn)                         { Drec $3 }
644 645
| EXCEPTION labels(uident_nq)         { Dexn ($2, PTtuple [], Ity.MaskVisible) }
| EXCEPTION labels(uident_nq) return  { Dexn ($2, fst $3, snd $3) }
646 647 648 649 650 651 652 653 654 655 656

ghost:
| (* epsilon *) { false }
| GHOST         { true }

kind:
| (* epsilon *) { Expr.RKnone }
| FUNCTION      { Expr.RKfunc }
| CONSTANT      { Expr.RKfunc }
| PREDICATE     { Expr.RKpred }
| LEMMA         { Expr.RKlemma }
657 658

(* Function definitions *)
659

660
rec_defn:
661 662
| ghost kind labels(lident_rich) binders ret_opt spec EQUAL spec seq_expr
    { $3, $1, $2, $4, fst $5, snd $5, spec_union $6 $8, $9 }
663

664
fun_defn:
665 666
| binders ret_opt spec EQUAL spec seq_expr
    { Efun ($1, fst $2, snd $2, spec_union $3 $5, $6) }
667

668
val_defn:
669 670
| params ret_opt spec
    { Eany ($1, Expr.RKnone, fst $2, snd $2, $3) }
671

672 673 674 675
const_defn:
| cast EQUAL seq_expr   { { $3 with expr_desc = Ecast ($3, $1) } }
| EQUAL seq_expr        { $2 }

676 677 678 679 680 681 682 683
(* Program expressions *)

mk_expr(X): d = X { mk_expr d $startpos $endpos }

seq_expr:
| expr %prec below_SEMI   { $1 }
| expr SEMICOLON          { $1 }
| expr SEMICOLON seq_expr { mk_expr (Esequence ($1, $3)) $startpos $endpos }
684

685
expr: e = mk_expr(expr_) { e }
686 687 688

expr_:
| expr_arg_
689 690
    { match $1 with (* break the infix relation chain *)
      | Einfix (l,o,r) -> Einnfix (l,o,r) | d -> d }
691 692 693 694
| expr AMPAMP expr
    { Eand ($1, $3) }
| expr BARBAR expr
    { Eor ($1, $3) }
695
| NOT expr
696
    { Enot $2 }
697
| prefix_op expr %prec prec_prefix_op
698
    { Eidapp (Qident $1, [$2]) }
699 700 701 702 703 704
| MINUS INTEGER
    { Eidapp (Qident (mk_id (prefix "-") $startpos($1) $endpos($1)),
        [mk_expr (Econst (Number.ConstInt $2)) $startpos($2) $endpos($2)]) }
| MINUS REAL
    { Eidapp (Qident (mk_id (prefix "-") $startpos($1) $endpos($1)),
        [mk_expr (Econst (Number.ConstReal $2)) $startpos($2) $endpos($2)]) }
705
| l = expr ; o = infix_op_1 ; r = expr
706
    { Einfix (l,o,r) }
707 708
| l = expr ; o = infix_op_234 ; r = expr
    { Eidapp (Qident o, [l;r]) }
709 710 711
| expr_arg located(expr_arg)+ (* FIXME/TODO: "expr expr_arg" *)
    { let join f (a,_,e) = mk_expr (Eapply (f,a)) $startpos e in
      (List.fold_left join $1 $2).expr_desc }
712
| IF seq_expr THEN expr ELSE expr
713
    { Eif ($2, $4, $6) }
714
| IF seq_expr THEN expr %prec prec_no_else
715 716
    { Eif ($2, $4, mk_expr (Etuple []) $startpos $endpos) }
| expr LARROW expr
717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732
    { let loc = floc $startpos $endpos in
      let rec down ll rl = match ll, rl with
        | {expr_desc = Eidapp (q, [e1])}::ll, e2::rl -> (e1,q,e2) :: down ll rl
        | {expr_desc = Eidapp (Qident id, [_;_]); expr_loc = loc}::_, _::_
          when id.id_str = mixfix "[]" -> Loc.errorm ~loc
            "Parallel array assignments are not allowed"
        | {expr_loc = loc}::_, _::_ -> Loc.errorm ~loc
            "Invalid left expression in an assignment"
        | [], [] -> []
        | _ -> Loc.errorm ~loc "Invalid parallel assignment" in
      match $1.expr_desc, $3.expr_desc with
        | Eidapp (Qident id, [e1;e2]), _ when id.id_str = mixfix "[]" ->
            Eidapp (Qident {id with id_str = mixfix "[]<-"}, [e1;e2;$3])
        | Etuple ll, Etuple rl -> Eassign (down ll rl)
        | Etuple _, _ -> Loc.errorm ~loc "Invalid parallel assignment"
        | _, _ -> Eassign (down [$1] [$3]) }
733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759
| LET ghost kind let_pattern EQUAL seq_expr IN seq_expr
    { let re_pat pat d = { pat with pat_desc = d } in
      let rec ghostify pat = match pat.pat_desc with
        (* let_pattern marks the opening variable with Ptuple [_] *)
        | Ptuple [{pat_desc = Pvar (id,_)}] -> re_pat pat (Pvar (id,$2))
        | Ptuple (p::pl) -> re_pat pat (Ptuple (ghostify p :: pl))
        | Pas (p,id,gh) -> re_pat pat (Pas (ghostify p, id, gh))
        | Por (p1,p2) -> re_pat pat (Por (ghostify p1, p2))
        | Pcast (p,t) -> re_pat pat (Pcast (ghostify p, t))
        | _ when $2 -> Loc.errorm ~loc:(floc $startpos($2) $endpos($2))
            "illegal ghost qualifier" (* $4 does not start with a Pvar *)
        | _ -> pat in
      let pat = ghostify $4 in
      let kind = match pat.pat_desc with
        | _ when $3 = Expr.RKnone -> $3
        | Pvar (_,_) | Pcast ({pat_desc = Pvar (_,_)},_) -> $3
        | _ -> Loc.errorm ~loc:(floc $startpos($3) $endpos($3))
            "illegal kind qualifier" in
      let cast ty = { $6 with expr_desc = Ecast ($6, ty) } in
      let pat, def = match pat.pat_desc with
        | Ptuple [] -> re_pat pat Pwild, cast (PTtuple [])
        | Pcast ({pat_desc = (Pvar _|Pwild)} as pat, ty) -> pat, cast ty
        | _ -> pat, $6 in
      match pat.pat_desc with
      | Pvar (id, gh) -> Elet (id, gh, kind, def, $8)
      | Pwild -> Elet (id_anonymous pat.pat_loc, false, kind, def, $8)
      | _ -> Ematch (def, [pat, $8]) }
760 761
| LET ghost kind labels(lident_op_id) EQUAL seq_expr IN seq_expr
    { Elet ($4, $2, $3, $6, $8) }
762
| LET ghost kind labels(lident_nq) mk_expr(fun_defn) IN seq_expr
763 764 765
    { Elet ($4, $2, $3, $5, $7) }
| LET ghost kind labels(lident_op_id) mk_expr(fun_defn) IN seq_expr
    { Elet ($4, $2, $3, $5, $7) }
766
| LET REC with_list1(rec_defn) IN seq_expr
767
    { Erec ($3, $5) }
768
| FUN binders spec ARROW spec seq_expr
769 770 771
    { Efun ($2, None, Ity.MaskVisible, spec_union $3 $5, $6) }
| ANY return spec
    { Eany ([], Expr.RKnone, Some (fst $2), snd $2, $3) }
772 773
| VAL ghost kind labels(lident_rich) mk_expr(val_defn) IN seq_expr
    { Elet ($4, $2, $3, $5, $7) }
774 775 776 777
| MATCH seq_expr WITH match_cases(seq_expr) END
    { Ematch ($2, $4) }
| MATCH comma_list2(expr) WITH match_cases(seq_expr) END
    { Ematch (mk_expr (Etuple $2) $startpos($2) $endpos($2), $4) }
778 779 780 781
| EXCEPTION labels(uident) IN seq_expr
    { Eexn ($2, PTtuple [], Ity.MaskVisible, $4) }
| EXCEPTION labels(uident) return IN seq_expr
    { Eexn ($2, fst $3, snd $3, $5) }
782 783
| LABEL labels(uident) IN seq_expr
    { Emark ($2, $4) }
784
| WHILE seq_expr DO loop_annotation seq_expr DONE
785
    { let inv, var = $4 in Ewhile ($2, inv, var, $5) }
786
| FOR lident_nq EQUAL seq_expr for_direction seq_expr DO invariant* seq_expr DONE
787
    { Efor ($2, $4, $5, $6, $8, $9) }
788
| ABSURD
789
    { Eabsurd }
790 791 792 793
| RAISE uqualid expr_arg?
    { Eraise ($2, $3) }
| RAISE LEFTPAR uqualid expr_arg? RIGHTPAR
    { Eraise ($3, $4) }
794 795
| RETURN expr_arg?
    { Eraise (Qident (mk_id Dexpr.old_mark $startpos($1) $endpos($1)), $2) }
796 797
| TRY seq_expr WITH bar_list1(exn_handler) END
    { Etry ($2, $4) }
798
| GHOST expr
799 800 801
    { Eghost $2 }
| assertion_kind LEFTBRC term RIGHTBRC
    { Eassert ($1, $3) }
802
| label expr %prec prec_named
803 804 805
    { Enamed ($1, $2) }
| expr cast
    { Ecast ($1, $2) }
806

807 808
expr_arg: e = mk_expr(expr_arg_) { e }
expr_dot: e = mk_expr(expr_dot_) { e }
809 810

expr_arg_:
811 812 813 814 815 816 817 818 819 820 821
| qualid                    { Eident $1 }
| numeral                   { Econst $1 }
| TRUE                      { Etrue }
| FALSE                     { Efalse }
| o = oppref ; a = expr_arg { Eidapp (Qident o, [a]) }
| expr_sub                  { $1 }

expr_dot_:
| lqualid                   { Eident $1 }
| o = oppref ; a = expr_dot { Eidapp (Qident o, [a]) }
| expr_sub                  { $1 }
822

Andrei Paskevich's avatar
M.()  
Andrei Paskevich committed
823
expr_block:
824 825 826 827 828
| BEGIN single_spec spec seq_expr END
    { Efun ([], None, Ity.MaskVisible, spec_union $2 $3, $4) }
| BEGIN single_spec spec END
    { let e = mk_expr (Etuple []) $startpos $endpos in
      Efun ([], None, Ity.MaskVisible, spec_union $2 $3, e) }
829 830 831 832 833 834 835
| BEGIN seq_expr END                                { $2.expr_desc }
| LEFTPAR seq_expr RIGHTPAR                         { $2.expr_desc }
| BEGIN END                                         { Etuple [] }
| LEFTPAR RIGHTPAR                                  { Etuple [] }
| LEFTPAR comma_list2(expr) RIGHTPAR                { Etuple $2 }
| LEFTBRC field_list1(expr) RIGHTBRC                { Erecord $2 }
| LEFTBRC expr_arg WITH field_list1(expr) RIGHTBRC  { Eupdate ($2, $4) }
Andrei Paskevich's avatar
M.()  
Andrei Paskevich committed
836 837 838 839

expr_sub:
| expr_block                                        { $1 }
| uqualid DOT mk_expr(expr_block)                   { Escope ($1, $3) }
840
| expr_dot DOT lqualid_rich                         { Eidapp ($3, [$1]) }
Andrei Paskevich's avatar
M.()  
Andrei Paskevich committed
841
| PURE LEFTBRC term RIGHTBRC                        { Epure $3 }
842
| expr_arg LEFTSQ expr RIGHTSQ
843
    { Eidapp (get_op $startpos($2) $endpos($2), [$1;$3]) }
844
| expr_arg LEFTSQ expr LARROW expr RIGHTSQ