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.                                                    *)

(*                                                                  *)

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

open Machine_code_types

open Spec_common

open Clocks

open Causality

   - where are used the mconst. They contain initialization of

(*                      si : initialization instructions *)

(*                       j : node aka machine instances  *)

(*                       d : local variables             *)

(*                       s : step instructions           *)

(* Machine processing requires knowledge about variables and local

   variables. Local could be memories while other could not.  *)

type machine_env = {

  get_var: string -> var_decl

}

let build_env locals non_locals =

  let all = VSet.union locals non_locals in

  {

    is_local = (fun id -> VSet.exists (fun v -> v.var_id = id) locals);

        (* Format.eprintf "Impossible to find variable %s in set %a@.@?"

         *   id

         *   VSet.pp all; *)

        raise Not_found)

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

(* Basic functions to translate to machine values, instructions *) 

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

let translate_ident env id =

  try

 (* id is a constant *)

  try

                   (const_of_top (Hashtbl.find Corelang.consts_table id)))

    in

    mk_val (Var vdecl) vdecl.var_type

  with Not_found ->

   (* id is a tag, getting its type in the list of declared enums *)

    let typ = (typedef_of_top (Hashtbl.find Corelang.tag_table id)).tydef_id in

    mk_val (Cst (Const_tag id)) (Type_predef.type_const typ)

  with Not_found ->

    Format.eprintf "internal error: Machine_code.translate_ident %s@.@?" id;

    assert false

   so that the C semantics is preserved *)

  | Expr_appl (id, e, r) ->

    if List.exists (fun e -> Types.is_bool_type e.expr_type) (expr_list_of_expr e)

    then let id =

           match id with

           | "="  -> "equi"

           | "!=" -> "xor"

           | _    -> id in

      { expr with expr_desc = Expr_appl (id, e, r) }

    else expr

  | _ -> expr

let specialize_op expr =

  match !Options.output with

  | "C" -> specialize_to_c expr

  | _   -> expr

    match expr.expr_desc with

      Cst v

    | Expr_ident x ->

      (translate_ident env x).value_desc

    | Expr_array el ->

      Array (List.map translate_expr el)

    | Expr_access (t, i) ->

      Access (translate_expr t, translate_expr (expr_of_dimension i))

    | Expr_power  (e, n) ->

      Power (translate_expr e, translate_expr (expr_of_dimension n))

    | Expr_when (e1, _, _) ->

      (translate_expr e1).value_desc

      Fun (node_name nd, List.map translate_expr (expr_list_of_expr e))

    | Expr_ite (g,t,e) when Backends.is_functional () ->

         functional ones, like horn backend, ite are preserved in

         expression. While they are removed for C or Java backends. *)

    | _ ->

      Format.eprintf "Normalization error for backend %s: %a@."

        !Options.output

        Printers.pp_expr expr;

      raise NormalizationError

  mk_val value_desc expr.expr_type

  | _ ->

    Format.eprintf "internal error: translate_guard %a@." Printers.pp_expr expr;

    assert false

  let translate_act = translate_act env in

  let translate_guard = translate_guard env in

  let translate_ident = translate_ident env in

  let translate_expr = translate_expr env in

    mk_conditional ~lustre_eq

      (translate_guard c)

      [translate_act (y, t)]

      [translate_act (y, e)]

  | Expr_merge (x, hl) ->

      (translate_ident x)

      (List.map (fun (t, h) -> t, [translate_act (y, h)]) hl)

  | _ ->

    mk_assign ~lustre_eq y (translate_expr expr)

(* Datastructure updated while visiting equations *)

type machine_ctx = {

  m: VSet.t;

  (* Reset instructions *)

  j: (Lustre_types.top_decl * Dimension.dim_expr list) IMap.t;

  (* Step instructions *)

  mp: mc_formula_t list;

  (* Clocked spec *)

  c: mc_formula_t IMap.t;

  (* Transition spec *)

  t: mc_formula_t list;

  m = VSet.empty;

  si = [];

  j = IMap.empty;

  s = [];

  mp = [];

  c = IMap.empty;

  t = []

}

(* Main function to translate equations into this machine context we

   are building *) 

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

  mkinstr

    (Imply (mk_clocked_on id vs, inst.instr_spec))

    (MBranch (v, [l, [inst]]))

let control_on_clock env ctx ck inst =

  let rec aux (ck_ids, vs, ctx, inst as acc) ck =

    match (Clocks.repr ck).cdesc with

    | Con (ck, cr, l) ->

      let id = Clocks.const_of_carrier cr in

      let v = translate_ident env id in

      let ck_ids' = String.concat "_" ck_ids in

      let id' = id ^ "_" ^ ck_ids' in

      let ck_spec = mk_condition v l in

      aux (id :: ck_ids,

           v :: vs,

           { ctx

             with c = IMap.add id ck_spec

                      (IMap.add id'

                         (And [ck_spec; mk_clocked_on ck_ids' vs]) ctx.c)

           },

           mk_control id' (v :: vs) v l inst) ck

    | _ -> acc

  in

  let _, _, ctx, inst = aux ([], [], ctx, inst) ck in

  ctx, inst

let reset_instance env i r c =

  match r with

  | Some r ->

    [snd (control_on_clock env ctx_init c

            (mk_conditional

               (translate_guard env r)

               [mkinstr True (MReset i)]

               [mkinstr True (MNoReset i)]))]

  | None -> []

let translate_eq env ctx eq =

  let translate_expr = translate_expr env in

  let translate_act = translate_act env in

    let ctx, ins = control_on_clock env ctx ck inst in

    { ctx with s = ins :: ctx.s }

  in

    control_on_clock ck (mkinstr' instr) in

     Printers.pp_node_eq eq Clocks.print_ck eq.eq_rhs.expr_clock;  *)

  | [x], Expr_arrow (e1, e2)                     ->

    let o = new_instance (Arrow.arrow_top_decl ()) eq.eq_rhs.expr_tag in

    let c1 = translate_expr e1 in

    let c2 = translate_expr e2 in

      j = IMap.add o (Arrow.arrow_top_decl (), []) ctx.j;

      m = VSet.add var_x ctx.m;

    }

      m = VSet.add var_x ctx.m;

      si = mkinstr' (MStateAssign (var_x, translate_expr e1)) :: ctx.si;

    }

  | p, Expr_appl (f, arg, r)

    when not (Basic_library.is_expr_internal_fun eq.eq_rhs) ->

    let var_p = List.map (fun v -> env.get_var v) p in

    let el = expr_list_of_expr arg in

    let vl = List.map translate_expr el in

    let node_f = node_from_name f in

    let call_f = node_f, NodeDep.filter_static_inputs (node_inputs node_f) el in

    let o = new_instance node_f eq.eq_rhs.expr_tag in

    let env_cks = List.fold_right (fun arg cks -> arg.expr_clock :: cks)

        el [eq.eq_rhs.expr_clock] in

    let call_ck = Clock_calculus.compute_root_clock

        (Clock_predef.ck_tuple env_cks) in

      Clock_calculus.unify_imported_clock (Some call_ck) eq.eq_rhs.expr_clock eq.eq_rhs.expr_loc;

      Format.eprintf "call %a: %a: %a@," Printers.pp_expr eq.eq_rhs Clocks.print_ck (Clock_predef.ck_tuple env_cks) Clocks.print_ck call_ck;*)

    { ctx with

      si = if Stateless.check_node node_f

      j = IMap.add o call_f ctx.j;

           else reset_instance o r call_ck)

          @ ctx.s

  | [x], _ ->

    Format.eprintf "internal error: Machine_code.translate_eq %a@?"

      Printers.pp_node_eq eq;

    assert false

      if vdecl.var_dec_const

      then

        { eq_lhs = [vdecl.var_id];

        } :: eqs

      else eqs)

    locals []

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

(* Processing nodes *) 

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

  let exprl = List.map (fun assert_ -> assert_.assert_expr ) nd.node_asserts in

  if Backends.is_functional () then

    [], [], exprl

  else (* Each assert(e) is associated to a fresh variable v and declared as

          v=e; assert (v); *)

    let _, vars, eql, assertl =

      List.fold_left (fun (i, vars, eqlist, assertlist) expr ->

          let loc = expr.expr_loc in

          let var_id = nd.node_id ^ "_assert_" ^ string_of_int i in

          let assert_var =

            mkvar_decl

              loc

              ~orig:false (* fresh var *)

              (var_id,

               mktyp loc Tydec_bool,

               mkclock loc Ckdec_any,

               false, (* not a constant *)

               None, (* no default value *)

               Some nd.node_id

              )

          in

          assert_var.var_type <- Type_predef.type_bool (* Types.new_ty (Types.Tbool) *);

          let eq = mkeq loc ([var_id], expr) in

           assert_var::vars,

           eq::eqlist,

           {expr with expr_desc = Expr_ident var_id}::assertlist)

    in

    vars, eql, assertl

let translate_core sorted_eqs locals other_vars =

  let constant_eqs = constant_equations locals in

  let ctx0 = translate_eqs env ctx_init constant_eqs in

  assert (VSet.is_empty ctx0.m);

  assert (ctx0.si = []);

  let ctx = translate_eqs env ctx_init sorted_eqs in

  let eqs, auts = get_node_eqs nd in

  assert (auts = []); (* Automata should be expanded by now *)

     to be declared for each assert *)

  let new_locals, assert_instrs, nd_node_asserts = process_asserts nd in

  (* Build the env: variables visible in the current scope *)

  let inout_vars = (VSet.of_list (nd.node_inputs @ nd.node_outputs)) in

  let env = build_env locals inout_vars  in 

  (* Format.eprintf "Node content is %a@." Printers.pp_node nd; *)

   *   VSet.pp locals

   *   VSet.pp inout_vars

   * ; *)

  (* Removing computed memories from locals. We also removed unused variables. *)

  let updated_locals =

    let l = VSet.elements (VSet.diff locals ctx.m) in

    List.fold_left (fun res v -> if List.mem v.var_id unused then res else v::res) [] l

  in

    mname = nd;

    mconst = ctx0_s;

    mstep = {

      step_outputs = nd.node_outputs;

      step_locals = updated_locals;

      step_checks = List.map (fun d -> d.Dimension.dim_loc,

                                       translate_expr env

                                         (expr_of_dimension d))

          nd.node_checks;

      step_instrs = (

        (* special treatment depending on the active backend. For horn backend,

           common branches are not merged while they are in C or Java

           backends. *)

        if !Backends.join_guards then

          join_guards_list ctx.s

        else

          ctx.s

      );

      step_asserts = List.map (translate_expr env) nd_node_asserts;

    };

    (* Processing spec: there is no processing performed here. Contract

       cocospec node, or the current one is a cocospec node. Contract do

       not contain any statement or import. *)

    mspec = { mnode_spec = nd.node_spec; mtransitions = [] };

    List.map

         let node = node_of_top decl in

      ) nodes

  machines

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

(* End: *)