Project

General

Profile

Revision 36454535 src/corelang.ml

View differences:

src/corelang.ml
495 495

  
496 496
let rename_node f_node f_var f_const nd =
497 497
  let rename_var v = { v with var_id = f_var v.var_id } in
498
  let rename_eq eq = { eq with
499
      eq_lhs = List.map f_var eq.eq_lhs; 
500
      eq_rhs = rename_expr f_node f_var f_const eq.eq_rhs
501
    } 
502
  in
498 503
  let inputs = List.map rename_var nd.node_inputs in
499 504
  let outputs = List.map rename_var nd.node_outputs in
500 505
  let locals = List.map rename_var nd.node_locals in
......
502 507
  let node_checks = List.map (Dimension.expr_replace_var f_var)  nd.node_checks in
503 508
  let node_asserts = List.map 
504 509
    (fun a -> 
505
      { a with assert_expr = rename_expr f_node f_var f_const a.assert_expr } 
506
    ) nd.node_asserts
507
  in
508
  let eqs = List.map 
509
    (fun eq -> { eq with
510
      eq_lhs = List.map f_var eq.eq_lhs; 
511
      eq_rhs = rename_expr f_node f_var f_const eq.eq_rhs
512
    } ) nd.node_eqs
510
      {a with assert_expr = 
511
	  let expr = a.assert_expr in
512
	  rename_expr f_node f_var f_const expr})
513
    nd.node_asserts
513 514
  in
515
  let eqs = List.map rename_eq nd.node_eqs in
514 516
  let spec = 
515 517
    Utils.option_map 
516 518
      (fun s -> rename_node_annot f_node f_var f_const s) 
......
643 645
    Basic_library.internal_funs
644 646

  
645 647

  
648

  
649
(* Replace any occurence of a var in vars_to_replace by its associated
650
   expression in defs until e does not contain any such variables *)
651
let rec substitute_expr vars_to_replace defs e =
652
  let se = substitute_expr vars_to_replace defs in
653
  { e with expr_desc = 
654
      let ed = e.expr_desc in
655
      match ed with
656
      | Expr_const _ -> ed
657
      | Expr_array el -> Expr_array (List.map se el)
658
      | Expr_access (e1, d) -> Expr_access (se e1, d)
659
      | Expr_power (e1, d) -> Expr_power (se e1, d)
660
      | Expr_tuple el -> Expr_tuple (List.map se el)
661
      | Expr_ite (c, t, e) -> Expr_ite (se c, se t, se e)
662
      | Expr_arrow (e1, e2)-> Expr_arrow (se e1, se e2) 
663
      | Expr_fby (e1, e2) -> Expr_fby (se e1, se e2)
664
      | Expr_pre e' -> Expr_pre (se e')
665
      | Expr_when (e', i, l)-> Expr_when (se e', i, l)
666
      | Expr_merge (i, hl) -> Expr_merge (i, List.map (fun (t, h) -> (t, se h)) hl)
667
      | Expr_appl (i, e', i') -> Expr_appl (i, se e', i')
668
      | Expr_ident i -> 
669
	if List.exists (fun v -> v.var_id = i) vars_to_replace then (
670
	  let eq_i eq = eq.eq_lhs = [i] in
671
	  if List.exists eq_i defs then
672
	    let sub = List.find eq_i defs in
673
	    let sub' = se sub.eq_rhs in
674
	    sub'.expr_desc
675
	  else 
676
	    assert false
677
	)
678
	else
679
	  ed
680

  
681
  }
682
(* FAUT IL RETIRER ?
683
  
684
 let rec expr_to_eexpr  expr =
685
   { eexpr_tag = expr.expr_tag;
686
     eexpr_desc = expr_desc_to_eexpr_desc expr.expr_desc;
687
     eexpr_type = expr.expr_type;
688
     eexpr_clock = expr.expr_clock;
689
     eexpr_loc = expr.expr_loc
690
   }
691
 and expr_desc_to_eexpr_desc expr_desc =
692
   let conv = expr_to_eexpr in
693
   match expr_desc with
694
   | Expr_const c -> EExpr_const (match c with
695
     | Const_int x -> EConst_int x 
696
     | Const_real x -> EConst_real x 
697
     | Const_float x -> EConst_float x 
698
     | Const_tag x -> EConst_tag x 
699
     | _ -> assert false
700

  
701
   )
702
   | Expr_ident i -> EExpr_ident i
703
   | Expr_tuple el -> EExpr_tuple (List.map conv el)
704

  
705
   | Expr_arrow (e1, e2)-> EExpr_arrow (conv e1, conv e2) 
706
   | Expr_fby (e1, e2) -> EExpr_fby (conv e1, conv e2)
707
   | Expr_pre e' -> EExpr_pre (conv e')
708
   | Expr_appl (i, e', i') -> 
709
     EExpr_appl 
710
       (i, conv e', match i' with None -> None | Some(id, _) -> Some id)
711

  
712
   | Expr_when _
713
   | Expr_merge _ -> assert false
714
   | Expr_array _ 
715
   | Expr_access _ 
716
   | Expr_power _  -> assert false
717
   | Expr_ite (c, t, e) -> assert false 
718
   | _ -> assert false
719

  
720
     *)
646 721
let rec get_expr_calls nodes e =
647 722
  get_calls_expr_desc nodes e.expr_desc
648 723
and get_calls_expr_desc nodes expr_desc =

Also available in: Unified diff