CristalCaveGem » LustreC

let rename_app id =

  let node = Corelang.node_from_name id in

  let is_imported =

    match node.top_decl_desc with

    | ImportedNode _ -> true

    | _ -> false

  in

  if !Options.no_mutation_suffix || is_imported then

  nb_consts: int;

  {consts=IntSet.empty; nb_consts=0; nb_boolexpr=0; nb_pre=0; nb_op=OpCount.empty}

      nb_consts = r1.nb_consts + r2.nb_consts;

  | Const_int i -> {empty_records with consts = IntSet.singleton i; nb_consts = 1}

		   (fun fmt -> fprintf fmt "mutation: %a becomes %a@ " 

	  report ~level:1 (fun fmt -> fprintf fmt "%i mutants remaining@ " nb); 

  | Some (SwitchIntCst (0, id)) ->

     (set_mutation_loc (); Const_int id) 

  (* Local references to keep track of generated directives *)

  (* build a set of integer 0, 1, ... n-1 for input n *)

  let cpt_to_intset cpt =

    let arr = Array.init cpt (fun x -> x) in

    Array.fold_right IntSet.add arr IntSet.empty

  in

  let possible_const_id = cpt_to_intset !records.nb_consts in

  (* let possible_boolexpr_id = cpt_to_intset !records.nb_boolexpr in *)

  (* let possible_pre_id = cpt_to_intset !records.nb_pre in *)

  let incremented_const_id = ref IntSet.empty in

  let decremented_const_id = ref IntSet.empty in

  let create_new_incr_decr registered build =

    let possible = IntSet.diff possible_const_id !registered |> IntSet.elements in

    let len = List.length possible in

    if len <= 0 then

      false, build (-1) (* Should not be stored *)

    else

      let picked = List.nth possible (Random.int (List.length possible)) in

      registered := IntSet.add picked !registered;

      true, build picked

  in

  let module DblIntSet = Set.Make (struct type t = int * int let compare = compare end) in

  let switch_const_id = ref DblIntSet.empty in

  let switch_set =

    if IntSet.cardinal !records.consts <= 1 then

      DblIntSet.empty

    else

      (* First element is cst id (the ith cst) while second is the

		       ith element of the set of gathered constants

		       !record.consts *)

      IntSet.fold (fun cst_id set ->

	IntSet.fold (fun ith_cst set ->

	  DblIntSet.add (cst_id, ith_cst) set

	) !records.consts set

      ) possible_const_id DblIntSet.empty 

  in

  let create_new_switch registered build =

    let possible = DblIntSet.diff switch_set !registered |> DblIntSet.elements in

    let len = List.length possible in

    if len <= 0 then

      false, build (-1,-1) (* Should not be stored *)

    else

      let picked = List.nth possible (Random.int (List.length possible)) in

      registered := DblIntSet.add picked !registered;

      true, build picked

  in

	(* TODO: check if we can generate more cases. The following lines were

	   cylcing and missing to detect that the enumaration was complete,

	   leading to a non terminating process. The current setting is harder

	   but may miss enumerating some cases. To be checked! *)

	(* if List.mem current mutants then *)

	(*   find_next_new init (next_change current) *)

	(* else *)

	  | 5 -> create_new_incr_decr incremented_const_id (fun x -> IncrIntCst x)

	  | 4 -> create_new_incr_decr decremented_const_id (fun x -> DecrIntCst x)

	  | 3 -> create_new_switch switch_const_id (fun (x,y) -> SwitchIntCst(x, y))

	  "Only %i mutants directives generated out of %i expected@ "

	  report ~level:2 (fun fmt -> fprintf fmt " %i mutants directive generated out of %i expected@ " (nb-rnb) nb);