CristalCaveGem » LustreC

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

(*                                                                  *)

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

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

(*                                                                  *)

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

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

(*  version 2.1.                                                    *)

(*                                                                  *)

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

open Lustre_types

open Corelang

open Machine_code_common

open Misc_printer

open Misc_lustre_function

open Ada_printer

 **)

struct

      @param fmt the formater to print on

      @param var_name the name of the variable

      @param value the value to be assigned

   **)

      (pp_value env) value

  (** Printing function for instruction. See

      {!type:Machine_code_types.instr_t} for more details on

      machine types.

      @param fmt the formater to print on

      @param instr the instruction to print

   **)

    let pp_instr = pp_machine_instr typed_submachines env in

      fprintf fmt "when %s =>@,%a" cond pp_block (List.map pp_instr instrs)

    (* Print a case *)

      fprintf fmt "case %a is@,%aend case"

    (* Print a if *)

    (* If neg is true the we must test for the negation of the condition. It

       first check that we don't have a negation and a else case, if so it

       inverses the two branch and remove the negation doing a recursive

       call. *)

      let pp_cond =

        if neg then

          fun fmt x -> fprintf fmt "! (%a)" (pp_value env) x

        else

          pp_value env

      in

      let pp_else = match instrs2 with

        | None -> fun fmt -> fprintf fmt ""

        | Some i2 -> fun fmt ->

            fprintf fmt "else@,%a" pp_block (List.map pp_instr i2)

      in

      fprintf fmt "if %a then@,%a%tend if"

        pp_cond g

        pp_block (List.map pp_instr instrs1)

        pp_else

      | MNoReset _ -> ()

      (* reset  *)

          let (substitution, submachine) = get_instance i typed_submachines in

          let args = if is_machine_statefull submachine then [[pp_state i]] else [] in

          pp_call fmt (pp_package_access (pp_package, pp_reset_procedure_name), args)

          let output = List.map pp_var_name il in

            (if is_machine_statefull submachine then [[pp_state i]] else [])

              @(if input!=[] then [input] else [])

              @(if output!=[] then [output] else [])

          in

          pp_call fmt (pp_package_access (pp_package, pp_step_procedure_name), args)

          fprintf fmt "%a" (Utils.fprintf_list ~sep:"" pp_oneline_comment) lines

     @param typed_submachines list of all typed machine instances of this machine

     @param fmt the formater to print on

     @param machine the machine

  **)

      | MLocalAssign (ident, value) -> 

          { instr_desc = MStateAssign (ident, value);

            lustre_eq= instr.lustre_eq }

      | x -> instr

      | None -> [], []

      | Some m_spec ->

          List.map (build_pp_var_decl_local (Some (true, [], []))) (List.filter (fun x -> not (List.mem x.var_id guarantees)) m_spec.mstep.step_locals),

          List.map transform_local_to_state_assign m_spec.mstep.step_instrs

    let pp_instr_list = List.map (pp_machine_instr typed_submachines env) (m.mstep.step_instrs@spec_instrs) in

  (** Print the definition of the reset procedure from a machine.

     @param typed_submachines list of all typed machine instances of this machine

     @param fmt the formater to print on

     @param machine the machine

  **)

      mkinstr (MStateAssign (var, mk_default_value var.var_type))

    in

      | None -> env, m.mmemory

      | Some m_spec ->

          env,

          (m.mmemory)

    in

    let assigns = List.map build_assign memory in

  (** Print the package definition(ads) of a machine.

    It requires the list of all typed instance.

    A typed submachine instance is (ident, type_machine) with ident

    the instance name and typed_machine is (substitution, machine) with machine

    the machine associated to the instance and substitution the instanciation of

    all its polymorphic types.

     @param fmt the formater to print on

     @param typed_submachines list of all typed machine instances of this machine

     @param m the machine

  **)

      if is_machine_statefull machine then

    in

    let aux pkgs (id, _) =

      try

        let (pkg, _) = List.assoc id ada_supported_funs in

        if List.mem pkg pkgs then

          pkgs

        else

          pkg::pkgs

      with Not_found -> pkgs

    in

    let pp_content fmt =

      fprintf fmt "%t%a"

        (*Define the reset procedure*)

        pp_reset

        (*Define the step procedure*)

    fprintf fmt "%a%t%a;@."

      (* Include all the required packages*)

      (pp_package (pp_package_name machine) [] true ) pp_content

(* Local Variables: *)

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

(* End: *)