Demo.ml 13.4 KB
Newer Older
charguer's avatar
charguer committed
1
2
open Pervasives

charguer's avatar
demos    
charguer committed
3
4
5
6
7
8
(** 
 *
 * This file contains unit tests for testing the generation of
 * characteristic formulae, their display, and their associated
 * tactics.
 *)
charguer's avatar
init  
charguer committed
9

charguer's avatar
encours    
charguer committed
10

charguer's avatar
xwhile    
charguer committed
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
(*--TODO

let f () =
  let r : '_a ref = ref [] in
  !r

let f () =
  let r : int ref = ref [] in
  !r

let f () : 'a list =
  let r : 'a ref = ref [] in
  !r

*)

charguer's avatar
charguer committed
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
(********************************************************************)
(* ** Encoding of names *)

(* type renaming_t_ = int   --rejected *)
(* type renaming_t__ = int  --rejected *)
(* type renaming_t1 = C_  --rejected *)

type renaming_t' = int
type renaming_t2 = C'
type 'a renaming_t3 = int 
type 'a_ renaming_t4 = int 

let renaming_demo () =
   (* let x_ = 3 in   --rejected *)
   (* let x__ = 3 in  --rejected *)
   let x = 3 in
   let x' = 3 in
   let x_' = 3 in
   let exists = 3 in
   let array = 3 in
   ()

charguer's avatar
xwhile    
charguer committed
49

charguer's avatar
demos    
charguer committed
50
(********************************************************************)
charguer's avatar
xfor    
charguer committed
51
(* ** Return *) 
charguer's avatar
demos    
charguer committed
52

charguer's avatar
xpat    
charguer committed
53
let ret_unit x =
charguer's avatar
demos    
charguer committed
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
  ()

let ret_int () =
  3

let ret_int_pair () =
  (3,4)

let ret_poly () =
  []


(********************************************************************)
(* ** Sequence *)

charguer's avatar
xpat    
charguer committed
69
70
71
72
let seq_ret_unit () =
   ret_unit 1; 
   ret_unit 2; 
   ret_unit 3
charguer's avatar
demos    
charguer committed
73
74
75
76
77
78
79
80
81
82
83
84
85
86


(********************************************************************)
(* ** Let-value *)

let let_val_int () =
   let x = 3 in
   x

let let_val_pair_int () =
   let x = (3,4) in
   x

let let_val_poly () =
charguer's avatar
charguer committed
87
   let _x = [] in
charguer's avatar
demos    
charguer committed
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
122
123
124
125
126
127
128
129
130
131
132
133
134
   3


(********************************************************************)
(* ** Let-pattern *)

let let_pattern_pair_int () =
   let (x,y) = (3,4) in
   x

let let_pattern_pair_int_wildcard () =
   let (x,_) = (3,4) in
   x


(********************************************************************)
(* ** Let-term *)

let let_term_nested_id_calls () =
   let f x = x in
   let a = f (f (f 2)) in
   a

let let_term_nested_pairs_calls () =
   let f x y = (x,y) in
   let a = f (f 1 2) (f 3 (f 4 5)) in
   a


(********************************************************************)
(* ** Let-function *)

let let_fun_const () =
  let f () = 3 in
  f()

let let_fun_poly_id () =
  let f x = x in
  f 3

let let_fun_poly_pair_homogeneous () =
  let f (x:'a) (y:'a) = (x,y) in
  f 3 3

let let_fun_on_the_fly () =
  (fun x f -> f x) 3 (fun x -> x+1) 

charguer's avatar
cp    
charguer committed
135
136
137
138
let let_fun_in_let () =
  let f = (assert (true); fun x -> x) in
  f

charguer's avatar
demos    
charguer committed
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

(********************************************************************)
(* ** Partial applications *)

let app_partial_2_1 () =
   let f x y = (x,y) in
   f 3

let app_partial_3_2 () =
   let f x y z = (x,z) in
   f 2 4

let app_partial_add () =
  let add x y = x + y in
  let g = add 1 in g 2
 
let app_partial_appto () =
  let appto x f = f x in
charguer's avatar
charguer committed
157
  let _r = appto 3 ((+) 1) in
charguer's avatar
demos    
charguer committed
158
159
160
161
162
163
164
165
166
  appto 3 (fun x -> x + 1)

let test_partial_app_arities () =
   let func4 a b c d = a + b + c + d in
   let f1 = func4 1 in
   let f2 = func4 1 2 in
   let f3 = func4 1 2 3 in
   f1 2 3 4 + f2 3 4 + f3 4

charguer's avatar
cp    
charguer committed
167
let app_partial_builtin_add () =
charguer's avatar
charguer committed
168
169
170
  let f = (+) 1 in
  f 2

charguer's avatar
cp    
charguer committed
171
172
173
174
let app_partial_builtin_and () =
  let f = (&&) true in
  f false

charguer's avatar
charguer committed
175

charguer's avatar
demos    
charguer committed
176
177
178
179
180
181
182
183
(********************************************************************)
(* ** Over applications *)

let app_over_id () =
   let f x = x in
   f f 3


charguer's avatar
charguer committed
184
185
186
187
188
(********************************************************************)
(* ** Infix functions *)

let (+++) x y = x + y  

charguer's avatar
charguer committed
189
let infix_aux x y = x +++ y
charguer's avatar
charguer committed
190
191
192
193

let (---) = infix_aux


charguer's avatar
cp    
charguer committed
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
(********************************************************************)
(* ** Lazy binary operators *)

let lazyop_val () =
  if true && (false || true) then 1 else 0

let lazyop_term () =
  let f x = (x = 0) in
  if f 1 || f 0 then 1 else 0

let lazyop_mixed () =
  let f x = (x = 0) in
  if true && (f 1 || (f 0 && true)) then 1 else 0


(********************************************************************)
(* ** Comparison operators *)

let compare_int () =
  (1 <> 0 && 1 <= 2) || (0 = 1 && 1 >= 2 && 1 < 2 && 2 > 1)

let compare_min () =
  (min 0 1)

(*
let compare_float () =
  (1. <> 0. && 1. <= 2.) || (0. = 1. && 1. >= 2. && 1. < 2. && 2. > 1.)
*)

charguer's avatar
cp    
charguer committed
223
224
225
226
227
228
(********************************************************************)
(* ** List operators *)

let list_ops () =
  let x = [1] in
  List.length (List.rev (List.concat (List.append [x] [x; x])))
charguer's avatar
cp    
charguer committed
229
230


charguer's avatar
charguer committed
231
232
233
(********************************************************************)
(* ** Inlined total functions *)

charguer's avatar
charguer committed
234
235
236
237
238
239
240
241
let inlined_fun_arith () =
   let n = 2 in
   1 - (1 / n) + ((2 * 2) / 2) mod (- 3)

let inlined_fun_others n =
  fst (succ n, ignore (pred n))


charguer's avatar
charguer committed
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266

(********************************************************************)
(* ** Polymorphic functions *)

let top_fun_poly_id x =
  x

let top_fun_poly_proj1 (x,y) =
  x

let top_fun_poly_pair_homogeneous (x:'a) (y:'a) =
  (x,y)


(********************************************************************)
(* ** Top-level values *)

let top_val_int = 5

let top_val_int_list : int list = []

let top_val_poly_list = []

let top_val_poly_list_pair = ([],[])

charguer's avatar
charguer committed
267
268
(* TODO

charguer's avatar
charguer committed
269
270
let (top_val_pair_int_1,top_val_pair_int_2) = (1,2)

charguer's avatar
charguer committed
271
272
273
274
275
276
277
278
let (top_val_pair_fun_1,top_val_pair_fun_2) =
  ((fun () -> 1), (fun () -> 1))
*)

(* problematic generalization
let (top_val_pair_fun_1,top_val_pair_fun_2) =
  ((fun x -> x), (fun x -> x))
*)
charguer's avatar
charguer committed
279

charguer's avatar
charguer committed
280

charguer's avatar
demos    
charguer committed
281
282
283
284
(********************************************************************)
(* ** Polymorphic let bindings *)

let let_poly_nil () = 
charguer's avatar
polylet    
charguer committed
285
286
  let x = [] in x

charguer's avatar
demos    
charguer committed
287
let let_poly_nil_pair () = 
charguer's avatar
polylet    
charguer committed
288
289
  let x = ([], []) in x

charguer's avatar
demos    
charguer committed
290
let let_poly_nil_pair_homogeneous () =
charguer's avatar
polylet    
charguer committed
291
292
  let x : ('a list * 'a list) = ([], []) in x
 
charguer's avatar
demos    
charguer committed
293
let let_poly_nil_pair_heterogeneous () =
charguer's avatar
polylet    
charguer committed
294
  let x : ('a list * int list) = ([], []) in x
charguer's avatar
encours    
charguer committed
295
296


charguer's avatar
xwhile    
charguer committed
297

charguer's avatar
charguer committed
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
(********************************************************************)
(* ** Type annotations *)

let annot_let () =
   let x : int = 3 in x

let annot_tuple_arg () =
   (3, ([] : int list))

let annot_pattern_var x =
   match (x : int list) with [] -> 1 | _ -> 0

let annot_pattern_constr () =
   match ([] : int list) with [] -> 1 | _ -> 0


charguer's avatar
demos    
charguer committed
314
315
(********************************************************************)
(* ** Pattern-matching *)
charguer's avatar
init  
charguer committed
316

charguer's avatar
demos    
charguer committed
317
318
let match_pair_as () =
   match (3,4) with (a, (b as c)) as p -> (c,p)
charguer's avatar
init  
charguer committed
319

charguer's avatar
charguer committed
320
321
322
323
let match_nested () =
  let l = [ (1,1); (0,0); (2,2) ] in
  match l with
  | _::(0,0)::q -> q
charguer's avatar
xpat    
charguer committed
324
  | _ -> [(2,2)]
charguer's avatar
charguer committed
325
326

(* not yet supported when clauses
charguer's avatar
demos    
charguer committed
327
328
329
330
331
332
let match_term_when () =
   let f x = x + 1 in
   match f 3 with 
   | 0 -> 1
   | n when n > 0 -> 2
   | _ -> 3
charguer's avatar
charguer committed
333
*)
charguer's avatar
init  
charguer committed
334
335


charguer's avatar
demos    
charguer committed
336
(********************************************************************)
charguer's avatar
charguer committed
337
(* ** Fatal Exceptions *)
charguer's avatar
init  
charguer committed
338

charguer's avatar
demos    
charguer committed
339
340
let exn_assert_false () =
   assert false
charguer's avatar
init  
charguer committed
341

charguer's avatar
demos    
charguer committed
342
343
let exn_failwith () =
   failwith "ok"
charguer's avatar
init  
charguer committed
344

charguer's avatar
demos    
charguer committed
345
346
exception My_exn 

charguer's avatar
demos    
charguer committed
347
let exn_raise () =
charguer's avatar
demos    
charguer committed
348
   raise My_exn
charguer's avatar
init  
charguer committed
349
350


charguer's avatar
charguer committed
351
352
353
354
(********************************************************************)
(* ** Assertions *)

let assert_true () =
charguer's avatar
charguer committed
355
356
  assert true; 
  3
charguer's avatar
charguer committed
357
358

let assert_pos x =
charguer's avatar
charguer committed
359
360
  assert (x > 0);
  3
charguer's avatar
charguer committed
361
362

let assert_same (x:int) (y:int) =
charguer's avatar
charguer committed
363
364
  assert (x = y); 
  3
charguer's avatar
charguer committed
365

charguer's avatar
charguer committed
366
367
368
369
370
371
372
373
374
375
376
let assert_let () =
  assert (let x = true in true); 
  3

let assert_seq () =
  let r = ref 0 in
  assert (incr r; true); 
  !r

let assert_in_seq () =
  (assert (true); 3) + 1
charguer's avatar
charguer committed
377
378


charguer's avatar
demos    
charguer committed
379
380
(********************************************************************)
(* ** Conditionals *)
charguer's avatar
init  
charguer committed
381

charguer's avatar
demos    
charguer committed
382
383
let if_true () =
   if true then 1 else 0
charguer's avatar
init  
charguer committed
384

charguer's avatar
demos    
charguer committed
385
386
387
388
389
390
391
392
393
394
395
let if_term () =
   let f x = true in
   if f 0 then 1 else 0

let if_else_if () =
   let f x = false in
   if f 0 then 1 
   else if f 1 then 2
   else 0

let if_then_no_else b =
charguer's avatar
init  
charguer committed
396
  let r = ref 0 in
charguer's avatar
demos    
charguer committed
397
  if b
charguer's avatar
init  
charguer committed
398
399
400
401
     then incr r; 
  !r


charguer's avatar
demos    
charguer committed
402
403
(********************************************************************)
(* ** Records *)
charguer's avatar
init  
charguer committed
404

charguer's avatar
demos    
charguer committed
405
406
407
type 'a sitems = {
  mutable nb : int;
  mutable items : 'a list; }
charguer's avatar
init  
charguer committed
408

charguer's avatar
demos    
charguer committed
409
410
let sitems_build n =
  { nb = n; items = [] }
charguer's avatar
init  
charguer committed
411

charguer's avatar
demos    
charguer committed
412
413
let sitems_get_nb r =
  r.nb
charguer's avatar
init  
charguer committed
414

charguer's avatar
demos    
charguer committed
415
416
let sitems_incr_nb r =
  r.nb <- r.nb + 1 
charguer's avatar
init  
charguer committed
417

charguer's avatar
demos    
charguer committed
418
419
let sitems_length_items r =
  List.length r.items
charguer's avatar
init  
charguer committed
420

charguer's avatar
demos    
charguer committed
421
422
423
let sitems_push x r =
  r.nb <- r.nb + 1;
  r.items <- x :: r.items
charguer's avatar
init  
charguer committed
424
425


charguer's avatar
cp    
charguer committed
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440

(********************************************************************)
(* ** Evaluation order *)

let order_app () =
  let r = ref 0 in
  let h () = assert (!r = 2); (fun a b -> a + b) in
  let f () = incr r; 1 in
  let g () = assert (!r = 1); incr r; 1 in
  (h()) (g()) (f())

let order_constr () =
  let r = ref 0 in
  let f () = incr r; 1 in
  let g () = assert (!r = 1); 1 in
charguer's avatar
charguer committed
441
  (g() :: f() :: [])
charguer's avatar
cp    
charguer committed
442
443
444
445
446
447
448
449
450
451
452
453
454

let order_list () =
  let r = ref 0 in
  let f () = incr r; 1 in
  let g () = assert (!r = 1); 1 in
  [ g() ; f() ]

let order_tuple () =
  let r = ref 0 in
  let f () = incr r; 1 in
  let g () = assert (!r = 1); 1 in
  (g(), f())

charguer's avatar
charguer committed
455
456
457
458
459
460
461
462
463
464
465
let order_record () : 'a sitems =
  let r = ref 0 in
  let g () : 'a list = incr r; [] in
  let f () = assert (!r = 1); 1 in
  { nb = f(); items = g() }

(* not yet supported : relaxed value restriction;
   (below, the call to g() results in a fresh type variable).
   The work around is to annotate a bit more, as done above;
   this avoids having a type for [g] that is too general.

charguer's avatar
cp    
charguer committed
466
467
468
469
470
let order_record () =
  let r = ref 0 in
  let g () = incr r; [] in
  let f () = assert (!r = 1); 1 in
  { nb = f(); items = g() }
charguer's avatar
charguer committed
471
*)
charguer's avatar
cp    
charguer committed
472

charguer's avatar
charguer committed
473
474
475
476
477
let order_array () =
  let r = ref 0 in
  let f () = incr r; 1 in
  let g () = assert (!r = 1); 1 in
  [| g() ; f() |]
charguer's avatar
cp    
charguer committed
478
479


charguer's avatar
xgc    
charguer committed
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
(********************************************************************)
(* ** References *)

let ref_gc () =
  let r1 = ref 1 in
  let r2 = ref 1 in
  let r3 = ref 1 in
  let r4 = ref 1 in
  let x = 
     let r5 = ref 2 in
     !r5 
     in
  x + !r1


charguer's avatar
demos    
charguer committed
495
496
(********************************************************************)
(* ** Arrays *)
charguer's avatar
init  
charguer committed
497

charguer's avatar
demos    
charguer committed
498
let array_ops () =
charguer's avatar
charguer committed
499
  (* TODO let u = ([||]  : int array) in *)
charguer's avatar
demos    
charguer committed
500
  let t = Array.make 3 0 in
charguer's avatar
charguer committed
501
  let _x = t.(1) in
charguer's avatar
demos    
charguer committed
502
  t.(2) <- 4;
charguer's avatar
charguer committed
503
504
  let _y = t.(2) in
  let _z = t.(1) in
charguer's avatar
demos    
charguer committed
505
  Array.length t
charguer's avatar
init  
charguer committed
506
507


charguer's avatar
demos    
charguer committed
508
509
510
511
512
513
(********************************************************************)
(* ** While loops *)

let while_decr () =
   let n = ref 3 in
   let c = ref 0 in
charguer's avatar
charguer committed
514
   while !n > 0 do  
charguer's avatar
demos    
charguer committed
515
516
517
518
519
520
521
      incr c;
      decr n;
   done;
   !c

let while_false () =
   while false do () done
charguer's avatar
init  
charguer committed
522
523


charguer's avatar
demos    
charguer committed
524
525
526
(********************************************************************)
(* ** For loops *)

charguer's avatar
xwhile    
charguer committed
527
let for_to_incr r =
charguer's avatar
demos    
charguer committed
528
   let n = ref 0 in
charguer's avatar
xwhile    
charguer committed
529
   for i = 0 to pred r do
charguer's avatar
demos    
charguer committed
530
531
532
533
      incr n;
   done;
   !n

charguer's avatar
xwhile    
charguer committed
534
535
536
537
538
539
540
(*
let for_downto r =
   let n = ref 0 in
   for i = pred r downto 0 do
      incr n;
   done;
   !n
charguer's avatar
charguer committed
541

charguer's avatar
xwhile    
charguer committed
542
*)
charguer's avatar
charguer committed
543

charguer's avatar
demos    
charguer committed
544
545
546
547
548
549
(********************************************************************)
(* ** Recursive function *)

let rec rec_partial_half x =
  if x = 0 then 0
  else if x = 1 then assert false
charguer's avatar
recfun    
charguer committed
550
  else 1 + rec_partial_half (x-2)
charguer's avatar
init  
charguer committed
551

charguer's avatar
cp    
charguer committed
552
553
let rec rec_mutual_f x =
  if x <= 0 then x else 1 + rec_mutual_g (x-2)
charguer's avatar
charguer committed
554
and rec_mutual_g x =
charguer's avatar
cp    
charguer committed
555
556
  rec_mutual_f (x+1)

charguer's avatar
init  
charguer committed
557

charguer's avatar
charguer committed
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
(********************************************************************)
(* ** External *)

external external_func : int -> 'a -> 'a array = "%external_func"



(********************************************************************)
(* ** Type abbreviation *)

type type_intpair = (int * int)

type 'a type_homo_pair = ('a * 'a)

type ('a,'b) type_poly_pair = (('a * 'b) * ('a * 'b))

charguer's avatar
charguer committed
574
575
576
let type_clashing_with_var = 3
type type_clashing_with_var = int

charguer's avatar
charguer committed
577
578
579
580
581
582
583
584
585
586
587
588
589

(********************************************************************)
(* ** Type algebraic *)

type 'a alga_three = 
  | Alga_A 
  | Alga_B of int * int 
  | Alga_C of (int * int)
  | Alga_D of 'a 
  | Alga_E of 'a * ('a -> 'a)

type ('a,'b) algb_erase = 
  | Algb_A of 'a
charguer's avatar
charguer committed
590
  | Algb_B of (int -> 'b)
charguer's avatar
charguer committed
591
592
593
594
595


(********************************************************************)
(* ** Type record *)

charguer's avatar
array    
charguer committed
596
597
598
type recorda = { 
   mutable recorda1 : int; 
   mutable recorda2 : int }
charguer's avatar
charguer committed
599

charguer's avatar
array    
charguer committed
600
601
602
603
604
(*----*)

type ('a,'b) recordb = 
  { mutable recordb1 : 'a ; 
    mutable recordb2 : 'b -> 'b }
charguer's avatar
charguer committed
605
606
607

(* not supported: record overloading of fields 
  -- else would need to prefix all fields with the type... *)
charguer's avatar
charguer committed
608
609
610
611
612


(********************************************************************)
(* ** Type mutual *)

charguer's avatar
array    
charguer committed
613
614
(*----*)

charguer's avatar
charguer committed
615
616
617
type typereca1 = | Typereca_1 of typereca2
 and typereca2 = | Typereca_2 of typereca1

charguer's avatar
array    
charguer committed
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
(*----*)

(* not supported: recursive definitions using abbreviation

type typerecb1 = | Typerecb_1 of typerecb2
 and typerecb2 = typerecb1 list

   --> the work around by inlining, e.g.:
*)

type typerecc1 = | Typerecc_1 of typerecc1 list
type typerecc2 = typerecc1 list

(*----*)

(* not supported: recursive definition of inductive and pure records
charguer's avatar
charguer committed
634
635
   -- technically could be supported, if the record was encoded
      on the fly into a coq mutual inductive
charguer's avatar
charguer committed
636
637
type typerecb1 = | Typerecb_1 of typerecb2
 and typerecb2 = { typerecb_2 : typerecb1 }
charguer's avatar
charguer committed
638
639

  --> the work around is to break circularity using polymorphism, e.g.:
charguer's avatar
charguer committed
640
*)
charguer's avatar
charguer committed
641

charguer's avatar
xwhile    
charguer committed
642
type 'a typerecb2 = { mutable typerecb_2 : 'a }
charguer's avatar
charguer committed
643
644
type typerecb1 = | Typerecb_1 of typerecb1 typerecb2

charguer's avatar
array    
charguer committed
645
(*----*)
charguer's avatar
charguer committed
646

charguer's avatar
array    
charguer committed
647
648
(* Circularity between mutable records and inductive is broken 
   through the indirection at type loc *)
charguer's avatar
charguer committed
649

charguer's avatar
xwhile    
charguer committed
650
type 'a typerecd1 = { mutable typerecd1_f : 'a typerecd2 }
charguer's avatar
array    
charguer committed
651
652
653
654
and 'a typerecd2 = 
   | Typerecd_2a 
   | Typerecd_2b of 'a typerecd1 
   | Typerecd_2c of 'a typerecd3 
charguer's avatar
xwhile    
charguer committed
655
and 'a typerecd3 = { mutable typerecd3_f : 'a typerecd2 }
charguer's avatar
charguer committed
656
657
658
659
660
661
662
663
664



(********************************************************************)
(* ** Local module *)

module ModFoo = struct
   
   type t = int
charguer's avatar
charguer committed
665
   let x : t = 3
charguer's avatar
charguer committed
666
667
668

end

charguer's avatar
charguer committed
669

charguer's avatar
charguer committed
670
671
672
673
(********************************************************************)
(* ** Local module signature *)

module type ModBarType = sig
charguer's avatar
init  
charguer committed
674

charguer's avatar
charguer committed
675
676
   type t
   val x : t
charguer's avatar
init  
charguer committed
677

charguer's avatar
charguer committed
678
679
680
681
682
end

module ModBar : ModBarType = struct
   
   type t = int
charguer's avatar
charguer committed
683
   let x : t = 3
charguer's avatar
charguer committed
684
685
686
687
688
689
690
691
692
693

end


(********************************************************************)
(* ** Functor *)

module ModFunctor (Bar : ModBarType) = struct
   
   type u = Bar.t
charguer's avatar
charguer committed
694
   let x : u = Bar.x
charguer's avatar
charguer committed
695
696
697
698
699
700

end

module ModFunctorTyped (Bar : ModBarType) : ModBarType = struct
   
   type t = Bar.t
charguer's avatar
charguer committed
701
   let x : t = Bar.x
charguer's avatar
charguer committed
702
703
704
705
706
707

end


(********************************************************************)
(* ** TODO: import of auxiliary files, like in examples/DemoMake *)
charguer's avatar
array    
charguer committed
708