CristalCaveGem » LustreC

type vhdl_signal_condition_t =

  {                            

    expr: vhdl_waveform_element_t list [@default []];              (* when expression *)

                                             If None, could be a latch  *)

  }

[@@deriving show { with_path = false }, yojson {strict = false}];;

    label: vhdl_name_t [@default NoName];

    lhs: vhdl_name_t;        (* assigned signal = target*)

    rhs: vhdl_signal_condition_t list;                   (* expression *)

    delay: vhdl_expr_t [@default IsNull];

  }

[@@deriving show { with_path = false }, yojson {strict = false}];;

and show_vhdl_definition_t : vhdl_definition_t -> Ppx_deriving_runtime.string

  = fun x  -> Format.asprintf "%a" pp_vhdl_definition_t x

and pp_vhdl_expr_t :

  Format.formatter -> vhdl_expr_t -> Ppx_deriving_runtime.unit =

  let __11 () = pp_vhdl_expr_t

  typ: vhdl_subtype_indication_t ;

  init_val: vhdl_cst_val_t option [@default None]}

let rec pp_vhdl_parameter_t :

  Format.formatter -> vhdl_parameter_t -> Ppx_deriving_runtime.unit =

  let __2 () = pp_vhdl_cst_val_t

  ((let open! Ppx_deriving_runtime in

      fun fmt  ->

        fun x  ->

    [@ocaml.warning "-A"])

and show_vhdl_parameter_t : vhdl_parameter_t -> Ppx_deriving_runtime.string =

  parameters: vhdl_parameter_t list ;

  isPure: bool [@default false]}

let rec pp_vhdl_subprogram_spec_t :

  Format.formatter -> vhdl_subprogram_spec_t -> Ppx_deriving_runtime.unit =

  let __1 () = pp_vhdl_parameter_t

          (match x.subprogram_type with

          | "function" -> 

              if (x.isPure) then

              else

          | "procedure" ->

              Format.fprintf fmt "%s %s" x.subprogram_type x.name);

          (match x.parameters with

          (match x.typeMark with

          | NoName -> Format.fprintf fmt "";

          | _ -> 

              ((__0 ()) fmt) x.typeMark))

   [@ocaml.warning "-A"])

               (List.fold_left

                 (fun sep  ->

                   fun x  ->

                                ((__7 ()) fmt) x;

                                true

                 ) false x);

                                fun x  ->

                                        if sep then Format.fprintf fmt "";

                          ((__8 ()) fmt) x;

                          true) false x))) adefault));

            Format.fprintf fmt "@;end if@]"

        | Case { label = alabel; guard = aguard; branches = abranches } ->

            Format.fprintf fmt "exit";

            (match aloop_label with

               | None  -> Format.pp_print_string fmt ""

            ((function

               | None  -> Format.pp_print_string fmt ""

               | Some x ->

                     fun x  ->

                             if sep then Format.fprintf fmt "@;<0 2>";

                       ((__1 ()) fmt) x;

                       true) false x);

          )) x.if_block;)

    [@ocaml.warning "-A"])

                          if sep then Format.fprintf fmt "@ |@ ";

                          ((__0 ()) fmt) x;

                          true) false x);)) x.when_cond;

           (fun x  ->

               ignore

                 (List.fold_left

                              if sep then Format.fprintf fmt ",";

                              ((__3 ()) fmt) x;

                              true) false x);)) anames;

              ((__5 ()) fmt) ainit_val)))

        | SigDecl { names = anames; typ = atyp; init_val = ainit_val } ->

            (Format.fprintf fmt "signal ";

                         fun x  ->

                           if sep then Format.fprintf fmt ".";

                           ((__0 ()) fmt) x;

        | Use a0 ->

            (Format.fprintf fmt "use ";

             ((fun x  ->

type vhdl_signal_condition_t =

  {

let rec pp_vhdl_signal_condition_t :

  Format.formatter -> vhdl_signal_condition_t -> Ppx_deriving_runtime.unit =

  let __1 () = pp_vhdl_expr_t

      fun fmt  ->

        fun x  ->

          ((fun x  ->

          (match x.cond with

    [@ocaml.warning "-A"])

and show_vhdl_signal_condition_t :

      fun x  ->

        let fields = []  in

        let fields =

          then fields

           in

        let fields =

          if x.expr = []

                         Result.Error "Vhdl_ast.vhdl_signal_condition_t.expr")

                      x), arg1)

            | ("cond",x)::xs ->

            | [] ->

                arg1 >>=

                  ((fun arg1  ->

                      arg0 >>=

                        (fun arg0  -> Result.Ok { expr = arg0; cond = arg1 })))

            | _::xs -> loop xs _state  in

      | _ -> Result.Error "Vhdl_ast.vhdl_signal_condition_t")

  [@ocaml.warning "-A"])

  label: vhdl_name_t [@default NoName];

  lhs: vhdl_name_t ;

  rhs: vhdl_signal_condition_t list ;

let rec pp_vhdl_conditional_signal_t :

  Format.formatter -> vhdl_conditional_signal_t -> Ppx_deriving_runtime.unit

  =

  and __2 () = pp_vhdl_signal_condition_t

          Format.fprintf fmt " <= ";

          (match x.delay with

            | IsNull -> Format.fprintf fmt "";

                   Format.fprintf fmt " ");

          ((fun x  ->

             Format.fprintf fmt "@[";

               (List.fold_left

                 (fun sep  ->

                   fun x  ->

                      ((__2 ()) fmt) x;

                      true) false x);

          Format.fprintf fmt "@]")) x.rhs;

   [@ocaml.warning "-A"])

and show_vhdl_conditional_signal_t :

            fields

           in

        let fields =

          ("rhs",

            ((fun x  ->

                `List

  ((let open! Ppx_deriving_yojson_runtime in

      function

      | `Assoc xs ->

            match xs with

            | ("postponed",x)::xs ->

                loop xs

                     | _ ->

                         Result.Error

                           "Vhdl_ast.vhdl_conditional_signal_t.postponed") x),

            | ("label",x)::xs ->

                loop xs

                  (arg0, ((fun x  -> vhdl_name_t_of_yojson x) x), arg2, arg3,

            | ("lhs",x)::xs ->

                loop xs

                  (arg0, arg1, ((fun x  -> vhdl_name_t_of_yojson x) x), arg3,

            | ("rhs",x)::xs ->

                loop xs

                  (arg0, arg1, arg2,

                      | _ ->

                          Result.Error

                            "Vhdl_ast.vhdl_conditional_signal_t.rhs") x),

            | ("delay",x)::xs ->

                loop xs

                    ((fun x  -> vhdl_expr_t_of_yojson x) x))

            | [] ->

            | _::xs -> loop xs _state  in

          loop xs

            ((Result.Ok false), (Result.Ok NoName),

              (Result.Error "Vhdl_ast.vhdl_conditional_signal_t.lhs"),

              (Result.Error "Vhdl_ast.vhdl_conditional_signal_t.rhs"),

      | _ -> Result.Error "Vhdl_ast.vhdl_conditional_signal_t")

  [@ocaml.warning "-A"])

                         ((__3 ()) fmt) x;

                         Format.fprintf fmt ";";

                         true) false x);)) x.body;

    [@ocaml.warning "-A"])

and show_vhdl_process_t : vhdl_process_t -> Ppx_deriving_runtime.string =

                    if sep then Format.fprintf fmt ",@ ";

                      ((__3 ()) fmt) x;

                      true) false x))) x.branches;

    [@ocaml.warning "-A"])

and show_vhdl_selected_signal_t :

                         if sep then Format.fprintf fmt "@;";

                         ((__3 ()) fmt) x;

                         true) false x))) x.body;

    [@ocaml.warning "-A"])

and show_vhdl_architecture_t :

      fun fmt  ->

        function

        | Package a0 ->

             ((__0 ()) fmt) a0;

             Format.fprintf fmt "@.end;@]")

        | Entities a0 ->

                        fun x  ->

                          if sep then Format.fprintf fmt "@.";

                          ((__0 ()) fmt) x;

                          true) false x);

                )) x.contexts;

           Format.fprintf fmt "@.";);

      vhdl_signal_condition_t -> vhdl_signal_condition_t=

      fun { expr; cond }  ->

        let expr = self#list self#vhdl_waveform_element_t expr  in

    method vhdl_signal_selection_t :

      vhdl_signal_selection_t -> vhdl_signal_selection_t=

    method vhdl_conditional_signal_t :

      vhdl_conditional_signal_t -> vhdl_conditional_signal_t=

        let postponed = self#bool postponed  in

        let label = self#vhdl_name_t label  in

        let lhs = self#vhdl_name_t lhs  in

        let rhs = self#list self#vhdl_signal_condition_t rhs  in

        let delay = self#vhdl_expr_t delay  in

    method vhdl_process_t : vhdl_process_t -> vhdl_process_t=

      fun { id; declarations; active_sigs; body }  ->

      vhdl_signal_condition_t -> vhdl_signal_condition_t=

      fun { expr; cond }  ->

        let expr = self#list self#vhdl_waveform_element_t expr  in

    method vhdl_signal_selection_t :

      vhdl_signal_selection_t -> vhdl_signal_selection_t=

    method vhdl_conditional_signal_t :

      vhdl_conditional_signal_t -> vhdl_conditional_signal_t=

        let postponed = self#bool postponed  in

        let label = self#vhdl_name_t label  in

        let lhs = self#vhdl_name_t lhs  in

        let rhs = self#list self#vhdl_signal_condition_t rhs  in

        let delay = self#vhdl_expr_t delay  in

    method vhdl_process_t : vhdl_process_t -> vhdl_process_t=

      fun { id; declarations; active_sigs; body }  ->