CristalCaveGem » LustreC

#AC_SUBST(VERSION_CODENAME, "Xia/Shao Kang")

AC_CONFIG_SRCDIR([src/main_lustre_compiler.ml])

# default prefix is /usr/local

AC_PREFIX_DEFAULT(/usr/local)

"main_lustre_compiler.native": use_str

"main_lustre_compiler.native": use_unix

"main_lustre_compiler.native": use_nums

<*.ml{,i}>: package(ocamlgraph)

<*.ml{,i}>: use_str

<*.ml{,i}>: use_unix

let load_file f =

  let ic = open_in f in

  let n = in_channel_length ic in

  really_input ic s 0 n;

  close_in ic;

  (s)

  (* Creating destination directory if needed *)

  create_dest_dir ();

  Typing.uneval_prog_generics prog;

  Clock_calculus.uneval_prog_generics prog;

open Corelang

open Log

open Format

let compute_records_eq eq = compute_records_expr eq.eq_rhs

let compute_records_node nd = 

let compute_records_top_decl td =

  match td.top_decl_desc with

  | Node nd -> compute_records_node nd

  | _ -> empty_records

let compute_records prog = 

  else

    i

  if Random.int 100 > threshold_random_float then

  else 

let rdm_mutate_op op = 

match op with

  match (Types.repr expr.expr_type).Types.tdesc with 

  | Types.Tbool ->

    (* if Random.int 100 > threshold_negate_bool_var then *)

    Some (expr, new_e), new_e

    (* else  *)

    (*   expr *)

let rdm_mutate_const_value c =

  match c with

  | Const_int i -> Const_int (rdm_mutate_int i)

  | Const_array _

  | Const_tag _ -> c

let rdm_mutate_const c =

    else

      let mut, new_args = rdm_mutate_expr args in

      mut, mk_e (Expr_appl (op_id, new_args, r))

  (* Other constructs are kept.

  | Expr_fby of expr * expr

  | Expr_array of expr list

  | Expr_uclock of expr * int

  | Expr_dclock of expr * int

  | Expr_phclock of expr * rat *)

let rdm_mutate_eq eq =

  let mutation, new_rhs = rdm_mutate_expr eq.eq_rhs in

  mutation, { eq with eq_rhs = new_rhs }

		 report ~level:1 

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

		     Printers.pp_node_eq eq

		     Printers.pp_node_eq new_eq);

  in

let rdm_mutate_top_decl td =

  match td.top_decl_desc with

  | Node nd -> 

    let mutation, new_node = rdm_mutate_node nd in 

    mutation, { td with top_decl_desc = Node new_node}

  | _ -> None, td

(* Create a single mutant with the provided random seed *)

  match !target with

  | Some (Boolexpr 0) -> (

    target := None;

  )

  | Some (Boolexpr n) ->

      (target := Some (Boolexpr (n-1)); expr)

let fold_mutate_eq eq =

  { eq with eq_rhs = fold_mutate_expr eq.eq_rhs }

let fold_mutate_node nd = 

  { nd with 

    node_id = rename_app nd.node_id

  }

let fold_mutate_top_decl td =

  match td.top_decl_desc with

  | _ -> td

(* Create a single mutant with the provided random seed *)

      (compute_neg_expr (cpt_pre+1) e)

  | Expr_appl (op_name, args, r) when List.mem op_name rel_op -> 

  | Expr_appl (op_name, args, r) -> 

    List.map 

	(compute_neg_expr cpt_pre args)

  | Expr_ident _ when (Types.repr expr.expr_type).Types.tdesc = Types.Tbool ->

  | _ -> []

and  

  | _::_, Types.Ttuple tl, Expr_tuple rhs -> List.iter2 mcdc_var_def eq.eq_lhs rhs

  | _ -> mcdc_expr 0 eq.eq_rhs 

let mcdc_top_decl td = 

  match td.top_decl_desc with

  | _ -> ()