CristalCaveGem » LustreC

  (** Print a new statement instantiating a generic package.

     @param fmt the formater to print on

     @param substitutions the instanciation substitution

     @param machine the machine to instanciate

  **)

  let pp_new_package fmt (substitutions, machine) =

    let pp_name = pp_package_name machine in

    let pp_new_name = pp_package_name_with_polymorphic substitutions machine in

    let instanciations = List.map (fun (id, typ) -> (pp_polymorphic_type id, fun fmt -> pp_type fmt typ)) substitutions in

    pp_package_instanciation pp_new_name pp_name fmt instanciations

  (** Print a precondition in aspect

     @param fmt the formater to print on

     @param expr the expession to print as pre

  **)

  let pp_pre fmt expr =

    fprintf fmt "Pre => %a"

      pp_clean_ada_identifier expr

  (** Print a postcondition in aspect

     @param fmt the formater to print on

     @param expr the expession to print as pre

  **)

  let pp_post fmt ident =

    fprintf fmt "Post => %a"

      pp_clean_ada_identifier ident

  (** Print the declaration of a procedure with a contract

     @param pp_prototype the prototype printer

     @param fmt the formater to print on

     @param contract the contract for the function to declare

  **)

  let pp_contract guarantees fmt =

    fprintf fmt "@,  @[<v>Global => null%t%a@]"

      (Utils.pp_final_char_if_non_empty ",@," guarantees)

      (Utils.fprintf_list ~sep:",@," pp_post) guarantees

(*

  let pp_transition_name fmt = fprintf fmt "transition"

  let pp_state_name_transition suffix fmt = fprintf fmt "%t_%s" pp_state_name suffix

  (** Printing function for basic assignement [var_name := value].

  let pp_basic_assign m fmt var_name value =

    fprintf fmt "%a = %a"

      (pp_access_var m) var_name

      (pp_value m) value

  let rec pp_machine_instr typed_submachines machine instr fmt =

    let pp_instr = pp_machine_instr typed_submachines machine in

    (* Print args for a step call *)

    let pp_state i fmt = fprintf fmt "%t.%s" pp_state_name i in

    let pp_args vl il fmt =

      fprintf fmt "@[%a@]%t@[%a@]"

        (Utils.fprintf_list ~sep:",@ " (pp_value machine)) vl

        (Utils.pp_final_char_if_non_empty ",@," il)

        (Utils.fprintf_list ~sep:",@ " pp_var_name) il

    in

    (* Print a when branch of a case *)

    let pp_when (cond, instrs) fmt =

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

    in

    (* Print a case *)

    let pp_case fmt (g, hl) =

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

        (pp_value machine) g

        pp_block (List.map pp_when hl)

    in

    (* 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 rec pp_if neg fmt (g, instrs1, instrs2) =

      match neg, instrs2 with

        | true, Some x -> pp_if false fmt (g, x, Some instrs1)

        | _ ->

          let pp_cond =

            if neg then

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

            else

              pp_value machine

          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

    in

          pp_call fmt (pp_package_access (pp_package, pp_name), [pp_state i])

          pp_basic_assign machine fmt ident value

          pp_basic_assign machine fmt ident value

          pp_basic_assign machine fmt i0 value

          pp_package_call

            pp_step_procedure_name

            fmt

            (substitution, submachine, pp_state i, Some (pp_args vl il))

      | MBranch (_, []) -> assert false

      | MBranch (g, (c1, i1)::tl) when c1=tag_false || c1=tag_true ->

          let neg = c1=tag_false in

          let other = match tl with

            | []         -> None

            | [(c2, i2)] -> Some i2

            | _          -> assert false

          pp_if neg fmt (g, i1, other)

      | MBranch (g, hl) -> pp_case fmt (g, hl)

      | MComment s  ->

          let lines = String.split_on_char '\n' s in

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

  let pp_transition_predicate typed_submachines fmt (opt_spec_machine, m) =

    let spec_instrs = match opt_spec_machine with

      | None -> []

      | Some m -> m.mstep.step_instrs

    in

    fprintf fmt "function %t (%a; %a) return Boolean is (@,  @[<v>%a@,@]) with Ghost"

      pp_transition_name

      pp_var_decl_mode (In, pp_state_name_transition "old", pp_state_type)

      pp_var_decl_mode (In, pp_state_name_transition "new", pp_state_type)

      (Utils.fprintf_list ~sep:" and@," (pp_machine_instr typed_submachines m)) (m.mstep.step_instrs@spec_instrs)*)

  let pp_file fmt (typed_submachines, ((opt_spec_machine, guarantees), m)) =

      (pp_type_decl pp_state_type AdaLimitedPrivate)

    let vars = List.map (build_pp_var_decl AdaNoMode) m.mmemory in

    let states = List.map build_pp_state_decl_from_subinstance typed_instances in

    let var_lists = (if vars = [] then [] else [vars])@(if states = [] then [] else [states]) in

    let pp_private_section fmt = fprintf fmt "@,private@,@,%a%t%a"

      (*Instantiate the polymorphic type that need to be instantiated*)

      (Utils.fprintf_list ~sep:";@," pp_new_package) typed_machines_to_instanciate

      (Utils.pp_final_char_if_non_empty ";@,@," typed_machines_to_instanciate)

      (*Define the state type*)

      (pp_record pp_state_type) var_lists

      let pp_contract_opt = match guarantees with

                              | [] -> None

                              | _ ->  Some (pp_contract guarantees) in

      fprintf fmt "%a%a%a%a" (* %a;@, *)

        (*Declare the transition predicate*)

        (* pp_transition_predicate typed_submachines) (opt_spec_machine, m) *)

        pp_ifstatefull pp_private_section