CristalCaveGem » LustreC

(********************************************************************)

(*                                                                  *)

(*  The LustreC compiler toolset   /  The LustreC Development Team  *)

(*  Copyright 2012 -    --   ONERA - CNRS - INPT                    *)

(*                                                                  *)

(*  LustreC is free software, distributed WITHOUT ANY WARRANTY      *)

(*  under the terms of the GNU Lesser General Public License        *)

(*  version 2.1.                                                    *)

(*                                                                  *)

(********************************************************************)

(* This module is used for the lustre test generator *)

open Format

open Log

open Utils

open Compiler_common

let usage = "Usage: lustret [options] \x1b[4msource file\x1b[0m"

  let trace_fmt = formatter_of_out_channel trace_file in

  Format.fprintf trace_fmt "@[<v 2>{@ %a@ }@]"

         Format.fprintf fmt "\"%s\": { @[<v 0>%a,@ %a@ }@]" mutant_name

           Mutation.print_directive_json mutation Mutation.print_loc_json

           mutation_loc))

  let source_name = dirname ^ "/" ^ basename ^ extension in

  Log.report ~level:1 (fun fmt -> fprintf fmt "@[<v>");

  (* Parsing source *)

    with Compiler_stages.StopPhase1 prog ->

      if !Options.print_nodes then (

        Format.printf "%a@.@?" Printers.pp_node_list prog;

        exit 0)

      else assert false

  (* Two cases - generation of coverage conditions - generation of mutants: a

     number of mutated lustre files *)

    (* Could be changed *)

    (* Modified Lustre is produced in fresh .lus file *)

    let source_lus = source_file ^ ".lus" in

    let source_out = open_out source_lus in

    Printers.pp_prog fmt prog_mcdc;

    Format.fprintf fmt "@.@?";

    let prog_mcdc = Normalization.normalize_prog params prog_mcdc in

    let fmt = formatter_of_out_channel source_out in

    EMF_backend.translate fmt basename prog_mcdc machine_code;

  let cpt = ref 0 in

      (fun (mutation, mutation_loc, mutant) ->

        (* Debugging code *)

        (* if List.mem !cpt [238;371;601;799;875;998] then *)

        (* Format.eprintf "Mutant %i: %a -> %a" !cpt Printers.pp_expr orig_e

           Printers.pp_expr new_e *)

        (* ; *)

        incr cpt;

        let mutant_basename =

          Filename.basename basename ^ ".mutant.n" ^ string_of_int !cpt

          ^ extension

        in

        let mutant_filename =

          match !Options.dest_dir with

          | "" ->

            (* Mutants are generated in source directory *)

            basename ^ ".mutant.n" ^ string_of_int !cpt ^ extension

          | dir ->

            (* Mutants are generated in target directory *)

            dir ^ "/" ^ mutant_basename

        in

        let mutant_out =

          try open_out mutant_filename

          with Sys_error _ ->

            Format.eprintf "Unable to open file %s for writing.@."

              mutant_filename;

            exit 1

        in

        let mutant_fmt = formatter_of_out_channel mutant_out in

        report ~level:1 (fun fmt ->

            fprintf fmt ".. generating mutant %s: %a@,@?" mutant_filename

              Mutation.print_directive mutation);

        Format.fprintf mutant_fmt "%a@." Printers.pp_prog mutant;

        mutation, mutation_loc, mutant_basename)

  in

      (* Mutant report is generated in source directory *)

      basename ^ ".mutation.json"

    | dir ->

      (* Mutants are generated in target directory *)

      dir ^ "/" ^ Filename.basename basename ^ ".mutation.json"

  pp_trace trace_filename mutation_list;

  (* Printing the CMakeLists.txt file *)

    (if !Options.dest_dir = "" then "" else !Options.dest_dir ^ "/")

    ^ "CMakeLists.txt"

  let cmake_file = open_out cmakelists in

  let cmake_fmt = formatter_of_out_channel cmake_file in

  Format.fprintf cmake_fmt "cmake_minimum_required(VERSION 3.5)@.";

    Version.testgen_path;

  Format.fprintf cmake_fmt "include(\"%s/FindLustre.cmake\")@."

    Version.testgen_path;

  Format.fprintf cmake_fmt "@[<v 2>FOREACH(lus_file ${LFILES})@ ";

  Format.fprintf cmake_fmt "get_lustre_name_ext(${lus_file} L E)@ ";

    Format.fprintf cmake_fmt "NODE \"%s_mutant\"@ " !Options.main_node;

  Format.fprintf cmake_fmt "ENDFOREACH()@.@?";

  match extension with

    testgen_source dirname basename extension

  | _ ->

    assert false

let anonymous filename =

    List.fold_left

      (fun (ok, ext) ext' ->

        if (not ok) && Filename.check_suffix filename ext' then true, ext'

        else ok, ext)

      (false, "") extensions

  in

    let dirname = Filename.dirname filename in

    let basename = Filename.chop_suffix (Filename.basename filename) ext in

    testgen dirname basename ext

let _ =

  Global.initialize ();

  Corelang.add_internal_funs ();

  try

    Printexc.record_backtrace true;

    Arg.parse options anonymous usage

  with

  | Parse.Error _

  | Clocks.Error (_, _)

  | Error.Error _

  (*| Task_set.Error _*)

  | Causality.Error _ ->

    exit 1

  | Sys_error msg ->

    eprintf "Failure: %s@." msg

  | exc ->

    track_exception ();

    raise exc

(* Local Variables: *)

(* compile-command:"make -C .." *)

(* End: *)