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