CristalCaveGem » LustreC

let base_types =

  ["integer";

  "character";

  "bit";

  "real";

  "natural";

  "positive";

  "std_logic";

  "std_logic_vector"] 

let std_logic_cst = ["U"; "X"; "0"; "1"; "Z"; "W"; "L"; "H"; "-"] 

let literal_base = ["B"; "O"; "X"; "UB"; "UO"; "UX"; "SB"; "SO"; "SX"; "D"] 

type vhdl_cst_val_t =

  | CstInt of int 

  | CstStdLogic of string 

  | CstLiteral of string [@name "CST_LITERAL"]

(* Adapted *)

let rec (pp_vhdl_cst_val_t :

          Format.formatter -> vhdl_cst_val_t -> Ppx_deriving_runtime.unit)

  =

  ((let open! Ppx_deriving_runtime in

      fun fmt  ->

        function

        | CstInt a0 ->

             (Format.fprintf fmt "%d") a0;

        | CstStdLogic a0 ->

             (Format.fprintf fmt "%S") a0;

        | CstLiteral a0 ->

             (Format.fprintf fmt "%s") a0;)

  [@ocaml.warning "-A"])

and show_vhdl_cst_val_t : vhdl_cst_val_t -> Ppx_deriving_runtime.string =

  fun x  -> Format.asprintf "%a" pp_vhdl_cst_val_t x

let rec (vhdl_cst_val_t_to_yojson : vhdl_cst_val_t -> Yojson.Safe.json) =

  ((let open! Ppx_deriving_yojson_runtime in

      function

      | CstInt arg0 ->

          `List

            [`String "CstInt";

            ((fun (x : Ppx_deriving_runtime.int)  -> `Int x)) arg0]

      | CstStdLogic arg0 ->

          `List

            [`String "CstStdLogic";

            ((fun (x : Ppx_deriving_runtime.string)  -> `String x)) arg0]

      | CstLiteral arg0 ->

          `List

            [`String "CST_LITERAL";

            ((fun (x : Ppx_deriving_runtime.string)  -> `String x)) arg0])

  [@ocaml.warning "-A"])

and (vhdl_cst_val_t_of_yojson :

      Yojson.Safe.json -> vhdl_cst_val_t Ppx_deriving_yojson_runtime.error_or)

  =

  ((let open! Ppx_deriving_yojson_runtime in

      function

      | `List ((`String "CstInt")::arg0::[]) ->

          ((function

            | `Int x -> Result.Ok x

            | _ -> Result.Error "Vhdl_ast.vhdl_cst_val_t") arg0) >>=

            ((fun arg0  -> Result.Ok (CstInt arg0)))

      | `List ((`String "CstStdLogic")::arg0::[]) ->

          ((function

            | `String x -> Result.Ok x

            | _ -> Result.Error "Vhdl_ast.vhdl_cst_val_t") arg0) >>=

            ((fun arg0  -> Result.Ok (CstStdLogic arg0)))

      | `List ((`String "CST_LITERAL")::arg0::[]) ->

          ((function

            | `String x -> Result.Ok x

            | _ -> Result.Error "Vhdl_ast.vhdl_cst_val_t") arg0) >>=

            ((fun arg0  -> Result.Ok (CstLiteral arg0)))

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

  [@ocaml.warning "-A"])

type vhdl_type_t =

  | Base of string 

  | Range of string option * int * int 

  | Bit_vector of int * int 

  | Array of int * int * vhdl_type_t 

  | Enumerated of string list 

  | Void 

and vhdl_subtype_indication_t =

  {

  name: vhdl_name_t [@default NoName];

  functionName: vhdl_name_t [@default NoName];

  const: vhdl_constraint_t [@default NoConstraint]}

and vhdl_discrete_range_t =

  | SubDiscreteRange of vhdl_subtype_indication_t

  [@name "SUB_DISCRETE_RANGE"]

  | NamedRange of vhdl_name_t [@name "NAMED_RANGE"]

  | DirectedRange of

  {

  direction: string ;

  from: vhdl_expr_t ;

  _to: vhdl_expr_t } [@name "RANGE_WITH_DIRECTION"]

and vhdl_constraint_t =

  | RefConstraint of {

  ref_name: vhdl_name_t } 

  | RangeConstraint of {

  range: vhdl_discrete_range_t } [@name "RANGE_CONSTRAINT"]

  | IndexConstraint of {

  ranges: vhdl_discrete_range_t list } [@name "INDEX_CONSTRAINT"]

  | ArrayConstraint of

  {

  ranges: vhdl_discrete_range_t list ;

  sub: vhdl_constraint_t } [@name "ARRAY_CONSTRAINT"]

  | RecordConstraint 

  | NoConstraint 

and vhdl_definition_t =

  | Type of {

  name: vhdl_name_t ;

  definition: vhdl_type_t } [@name "TYPE_DECLARATION"]

  | Subtype of {

  name: vhdl_name_t ;

  typ: vhdl_subtype_indication_t } [@name "SUBTYPE_DECLARATION"]

and vhdl_expr_t =

  | Call of vhdl_name_t [@name "CALL"]

  | Cst of vhdl_cst_val_t [@name "CONSTANT_VALUE"]

  | Op of {

  id: string [@default ""];

  args: vhdl_expr_t list [@default []]} [@name "EXPRESSION"]

  | IsNull [@name "IsNull"]

  | Time of {

  value: int ;

  phy_unit: string [@default ""]} 

  | Sig of {

  name: vhdl_name_t ;

  att: vhdl_signal_attributes_t option } 

  | SuffixMod of {

  expr: vhdl_expr_t ;

  selection: vhdl_suffix_selection_t } 

  | Aggregate of {

  elems: vhdl_element_assoc_t list } [@name "AGGREGATE"]

  | Others [@name "OTHERS"]

and vhdl_name_t =

  | Simple of string [@name "SIMPLE_NAME"]

  | Identifier of string [@name "IDENTIFIER"]

  | Selected of vhdl_name_t list [@name "SELECTED_NAME"]

  | Index of {

  id: vhdl_name_t ;

  exprs: vhdl_expr_t list } [@name "INDEXED_NAME"]

  | Slice of {

  id: vhdl_name_t ;

  range: vhdl_discrete_range_t } [@name "SLICE_NAME"]

  | Attribute of

  {

  id: vhdl_name_t ;

  designator: vhdl_name_t ;

  expr: vhdl_expr_t [@default IsNull]} [@name "ATTRIBUTE_NAME"]

  | Function of {

  id: vhdl_name_t ;

  assoc_list: vhdl_assoc_element_t list } [@name "FUNCTION_CALL"]

  | NoName 

and vhdl_assoc_element_t =

  {

  formal_name: vhdl_name_t option [@default None];

  formal_arg: vhdl_name_t option [@default None];

  actual_name: vhdl_name_t option [@default None];

  actual_designator: vhdl_name_t option [@default None];

  actual_expr: vhdl_expr_t option [@default None]}

and vhdl_element_assoc_t = {

  choices: vhdl_expr_t list ;

  expr: vhdl_expr_t }

and vhdl_array_attributes_t =

  | AAttInt of {

  id: string ;

  arg: int } 

  | AAttAscending 

and vhdl_signal_attributes_t =

  | SigAtt of string 

and vhdl_string_attributes_t =

  | StringAtt of string 

and vhdl_suffix_selection_t =

  | Idx of int 

  | SuffixRange of int * int

let rec pp_vhdl_type_t :

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

  let __0 () = pp_vhdl_type_t  in

  ((let open! Ppx_deriving_runtime in

      fun fmt  ->

        function

        | Base a0 ->

             (Format.fprintf fmt "%s") a0;

        | Range (a0,a1,a2) ->

             ((

               (Format.fprintf fmt "%d") a1);

               ((function

                 | None  -> Format.pp_print_string fmt "None"

                 | Some x ->

                      (Format.fprintf fmt "%S") x;

                      )) a0;

              (Format.fprintf fmt "%d") a2);

        | Bit_vector (a0,a1) ->

             (Format.fprintf fmt "%d .. %d") a0 a1;

        | Array (a0,a1,a2) ->

             (((__0 ()) fmt) a2;

              (Format.fprintf fmt "[%d,%d]") a0 a1);

        | Enumerated a0 ->

             ((fun x  ->

                 Format.fprintf fmt "@[<2>[";

                 ignore

                   (List.fold_left

                      (fun sep  ->

                         fun x  ->

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

                           (Format.fprintf fmt "%S") x;

                           true) false x);

                 Format.fprintf fmt "@,]@]")) a0;

        | Void  -> Format.pp_print_string fmt "Void")

    [@ocaml.warning "-A"])

and show_vhdl_type_t : vhdl_type_t -> Ppx_deriving_runtime.string =

  fun x  -> Format.asprintf "%a" pp_vhdl_type_t x

(* Adapted *)

and pp_vhdl_subtype_indication_t :

  Format.formatter -> vhdl_subtype_indication_t -> Ppx_deriving_runtime.unit

  =

  let __2 () = pp_vhdl_constraint_t

  and __1 () = pp_vhdl_name_t

  and __0 () = pp_vhdl_name_t

   in

  ((let open! Ppx_deriving_runtime in

      fun fmt  ->

        fun x  ->

          ((__0 ()) fmt) x.name;

          ((__1 ()) fmt) x.functionName;

          Format.fprintf fmt " ";

          ((__2 ()) fmt) x.const;

    )

    [@ocaml.warning "-A"])

and show_vhdl_subtype_indication_t :

  vhdl_subtype_indication_t -> Ppx_deriving_runtime.string =

  fun x  -> Format.asprintf "%a" pp_vhdl_subtype_indication_t x

(* Adapted *)

and pp_vhdl_discrete_range_t :

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

  let __3 () = pp_vhdl_expr_t

  and __2 () = pp_vhdl_expr_t

  and __1 () = pp_vhdl_name_t

  and __0 () = pp_vhdl_subtype_indication_t

   in

  ((let open! Ppx_deriving_runtime in

      fun fmt  ->

        function

        | SubDiscreteRange a0 ->

             ((__0 ()) fmt) a0;

        | NamedRange a0 ->

             ((__1 ()) fmt) a0;

        | DirectedRange { direction = adirection; from = afrom; _to = a_to }

            ->

               ((__2 ()) fmt) afrom;

               (Format.fprintf fmt " %s ") adirection;

               ((__3 ()) fmt) a_to;

    )

    [@ocaml.warning "-A"])

and show_vhdl_discrete_range_t :

  vhdl_discrete_range_t -> Ppx_deriving_runtime.string =

  fun x  -> Format.asprintf "%a" pp_vhdl_discrete_range_t x

(* Requires adaptation for: ArrayConstraint, RecordConstraint *)

and pp_vhdl_constraint_t :

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

  let __4 () = pp_vhdl_constraint_t

  and __3 () = pp_vhdl_discrete_range_t

  and __2 () = pp_vhdl_discrete_range_t

  and __1 () = pp_vhdl_discrete_range_t

  and __0 () = pp_vhdl_name_t

   in

  ((let open! Ppx_deriving_runtime in

      fun fmt  ->

        function

        | RefConstraint { ref_name = aref_name } ->

             (Format.fprintf fmt "(";

              ((__0 ()) fmt) aref_name;

              Format.fprintf fmt ")");

        | RangeConstraint { range = arange } ->

             (Format.fprintf fmt "(";

              ((__1 ()) fmt) arange;

              Format.fprintf fmt ")");

        | IndexConstraint { ranges = aranges } ->

            Format.fprintf fmt "(";

            ((fun x  ->

                ignore

                  (List.fold_left

                     (fun sep  ->

                        fun x  ->

                          if sep then Format.fprintf fmt ", ";

                          ((__2 ()) fmt) x;

                          true) false x))) aranges;

            Format.fprintf fmt ")";

        | ArrayConstraint { ranges = aranges; sub = asub } ->

            (Format.fprintf fmt "@[<2>ArrayConstraint {@,";

             ((Format.fprintf fmt "@[%s =@ " "ranges";

               ((fun x  ->

                   Format.fprintf fmt "@[<2>[";

                   ignore

                     (List.fold_left

                        (fun sep  ->

                           fun x  ->

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

                             ((__3 ()) fmt) x;

                             true) false x);

                   Format.fprintf fmt "@,]@]")) aranges;

               Format.fprintf fmt "@]");

              Format.fprintf fmt ";@ ";

              Format.fprintf fmt "@[%s =@ " "sub";

              ((__4 ()) fmt) asub;

              Format.fprintf fmt "@]");

             Format.fprintf fmt "@]}")

        | RecordConstraint  -> Format.pp_print_string fmt ""

        | NoConstraint  -> Format.pp_print_string fmt "")

    [@ocaml.warning "-A"])

and show_vhdl_constraint_t : vhdl_constraint_t -> Ppx_deriving_runtime.string

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

and pp_vhdl_definition_t :

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

  let __3 () = pp_vhdl_subtype_indication_t

  and __2 () = pp_vhdl_name_t

  and __1 () = pp_vhdl_type_t

  and __0 () = pp_vhdl_name_t

   in

  ((let open! Ppx_deriving_runtime in

      fun fmt  ->

        function

        | Type { name = aname; definition = adefinition } ->

            Format.fprintf fmt "@[<2>type ";

            ((__0 ()) fmt) aname;

            Format.fprintf fmt " is ";

            ((__1 ()) fmt) adefinition;

            Format.fprintf fmt "@]}";

        | Subtype { name = aname; typ = atyp } ->

            Format.fprintf fmt "@[<2>subtype ";

            ((__2 ()) fmt) aname;

            Format.fprintf fmt " is ";

            ((__3 ()) fmt) atyp;

            Format.fprintf fmt "@]";

   )

    [@ocaml.warning "-A"])

and show_vhdl_definition_t : vhdl_definition_t -> Ppx_deriving_runtime.string

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

(* adaptation to be provided for Op, Time, Sig, suffixMod, Aggregate,  *)

and pp_vhdl_expr_t :

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

  let __7 () = pp_vhdl_element_assoc_t

  and __6 () = pp_vhdl_suffix_selection_t

  and __5 () = pp_vhdl_expr_t

  and __4 () = pp_vhdl_signal_attributes_t

  and __3 () = pp_vhdl_name_t

  and __2 () = pp_vhdl_expr_t

  and __1 () = pp_vhdl_cst_val_t

  and __0 () = pp_vhdl_name_t

   in

  ((let open! Ppx_deriving_runtime in

      fun fmt  ->

        function

        | Call a0 ->

             ((__0 ()) fmt) a0;

        | Cst a0 ->

             ((__1 ()) fmt) a0;

        | Op { id = aid; args = aargs } ->

            (match aargs with

            | [] -> (Format.fprintf fmt "%s") aid;

            | hd::[] ->

               (Format.fprintf fmt "%s") aid;

               ((__2 ()) fmt) hd

            | hd::(hd2::[]) -> 

               ((__2 ()) fmt) hd;

               (Format.fprintf fmt " %s ") aid;

               ((__2 ()) fmt) hd2

            | _ ->

            (Format.fprintf fmt "@[<2>Op {@,";

             ((Format.fprintf fmt "@[%s =@ " "id";

               (Format.fprintf fmt "%S") aid;

               Format.fprintf fmt "@]");

              Format.fprintf fmt ";@ ";

              Format.fprintf fmt "@[%s =@ " "args";

              ((fun x  ->

                  Format.fprintf fmt "@[<2>[";

                  ignore

                    (List.fold_left

                       (fun sep  ->

                          fun x  ->

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

                            ((__2 ()) fmt) x;

                            true) false x);

                  Format.fprintf fmt "@,]@]")) aargs;

              Format.fprintf fmt "@]");

             Format.fprintf fmt "@]}"))

        | IsNull  -> Format.pp_print_string fmt ""

        | Time { value = avalue; phy_unit = aphy_unit } ->

            (Format.fprintf fmt "@[<2>Time {@,";

             ((Format.fprintf fmt "@[%s =@ " "value";

               (Format.fprintf fmt "%d") avalue;

               Format.fprintf fmt "@]");

              Format.fprintf fmt ";@ ";

              Format.fprintf fmt "@[%s =@ " "phy_unit";

              (Format.fprintf fmt "%S") aphy_unit;

              Format.fprintf fmt "@]");

             Format.fprintf fmt "@]}")

        | Sig { name = aname; att = aatt } ->

            (Format.fprintf fmt "@[<2>Sig {@,";

             ((Format.fprintf fmt "@[%s =@ " "name";

               ((__3 ()) fmt) aname;

               Format.fprintf fmt "@]");

              Format.fprintf fmt ";@ ";

              Format.fprintf fmt "@[%s =@ " "att";

              ((function

                | None  -> Format.pp_print_string fmt "None"

                | Some x ->

                    (Format.pp_print_string fmt "(Some ";

                     ((__4 ()) fmt) x;

                     Format.pp_print_string fmt ")"))) aatt;

              Format.fprintf fmt "@]");

             Format.fprintf fmt "@]}")

        | SuffixMod { expr = aexpr; selection = aselection } ->

            (Format.fprintf fmt "@[<2>SuffixMod {@,";

             ((Format.fprintf fmt "@[%s =@ " "expr";

               ((__5 ()) fmt) aexpr;

               Format.fprintf fmt "@]");

              Format.fprintf fmt ";@ ";

              Format.fprintf fmt "@[%s =@ " "selection";

              ((__6 ()) fmt) aselection;

              Format.fprintf fmt "@]");

             Format.fprintf fmt "@]}")

        | Aggregate { elems = aelems } ->

            (Format.fprintf fmt "@[<2>Aggregate {@,";

             (Format.fprintf fmt "@[%s =@ " "elems";

              ((fun x  ->

                  Format.fprintf fmt "@[<2>[";

                  ignore

                    (List.fold_left

                       (fun sep  ->

                          fun x  ->

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

                            ((__7 ()) fmt) x;

                            true) false x);

                  Format.fprintf fmt "@,]@]")) aelems;

              Format.fprintf fmt "@]");

             Format.fprintf fmt "@]}")

        | Others  -> Format.pp_print_string fmt "others")

    [@ocaml.warning "-A"])

and show_vhdl_expr_t : vhdl_expr_t -> Ppx_deriving_runtime.string =

  fun x  -> Format.asprintf "%a" pp_vhdl_expr_t x

(* Adapted *)

and pp_vhdl_name_t :

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

  let __9 () = pp_vhdl_assoc_element_t

  and __8 () = pp_vhdl_name_t

  and __7 () = pp_vhdl_expr_t

  and __6 () = pp_vhdl_name_t

  and __5 () = pp_vhdl_name_t

  and __4 () = pp_vhdl_discrete_range_t

  and __3 () = pp_vhdl_name_t

  and __2 () = pp_vhdl_expr_t

  and __1 () = pp_vhdl_name_t

  and __0 () = pp_vhdl_name_t

   in

  ((let open! Ppx_deriving_runtime in

      fun fmt  ->

        function

        | Simple a0 ->

             (Format.fprintf fmt "%s") a0;

        | Identifier a0 ->

             (Format.fprintf fmt "%s") a0;

        | Selected a0 ->

             ((fun x  ->

                 ignore

                   (List.fold_left

                      (fun sep  ->

                         fun x  ->

                           if sep then Format.fprintf fmt ".";

                           ((__0 ()) fmt) x;

                           true) false x);) a0;)

        | Index { id = aid; exprs = aexprs } ->

            ((__1 ()) fmt) aid;

            Format.fprintf fmt "(";

            (fun x  ->

                ignore

                (List.fold_left

                  (fun sep  ->

                    fun x  ->

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

                                  ((__2 ()) fmt) x;

                                  true

                  ) false x);

            ) aexprs;

            Format.fprintf fmt ")";

        | Slice { id = aid; range = arange } ->

              ((__3 ()) fmt) aid;

              Format.fprintf fmt "(";

              ((__4 ()) fmt) arange;

              Format.fprintf fmt ")";

        | Attribute { id = aid; designator = adesignator; expr = aexpr } ->

              ((__5 ()) fmt) aid;

              Format.fprintf fmt "\'";

              ((__6 ()) fmt) adesignator;

              (match aexpr with

              | IsNull -> Format.fprintf fmt "";

              | _ ->

                Format.fprintf fmt "(";

                ((__7 ()) fmt) aexpr;

                Format.fprintf fmt ")")

        | Function { id = aid; assoc_list = aassoc_list } ->

            (((__8 ()) fmt) aid;

            Format.fprintf fmt "(";

            ((fun x  ->

              Format.fprintf fmt "@[";

              ignore

                (List.fold_left

                   (fun sep  ->

                      fun x  ->

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

                        ((__9 ()) fmt) x;

                        true) false x);

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

            Format.fprintf fmt ")";)

        | NoName  -> Format.pp_print_string fmt "")

    [@ocaml.warning "-A"])

and show_vhdl_name_t : vhdl_name_t -> Ppx_deriving_runtime.string =

  fun x  -> Format.asprintf "%a" pp_vhdl_name_t x

(* Adapted *)

and pp_vhdl_assoc_element_t :

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

  let __4 () = pp_vhdl_expr_t

  and __3 () = pp_vhdl_name_t

  and __2 () = pp_vhdl_name_t

  and __1 () = pp_vhdl_name_t

  and __0 () = pp_vhdl_name_t

   in

  ((let open! Ppx_deriving_runtime in

      fun fmt  ->

        fun x  ->

          (match x.formal_name with

          | None -> Format.pp_print_string fmt ""

          | Some NoName -> Format.pp_print_string fmt ""

          | Some a -> 

              (((__0 ()) fmt) a;

              (match x.formal_arg with

              | None -> ()

              | Some b -> Format.fprintf fmt "(";

                          ((__1 ()) fmt) b;

                          Format.fprintf fmt ")");

              Format.fprintf fmt " => "));

          (match x.actual_name with

          | None -> Format.pp_print_string fmt ""

          | Some a -> 

              (((__2 ()) fmt) a;

              (match x.actual_designator with

              | None -> ()

              | Some NoName -> Format.pp_print_string fmt ""

              | Some b -> (Format.fprintf fmt "(";

                          ((__3 ()) fmt) b;

                          Format.fprintf fmt ")"));

              (match x.actual_expr with

              | None -> ()

              | Some IsNull -> Format.pp_print_string fmt ""

              | Some c -> (Format.fprintf fmt "(";

                          ((__4 ()) fmt) c;

                          Format.fprintf fmt ")"))));)

    [@ocaml.warning "-A"])

and show_vhdl_assoc_element_t :

  vhdl_assoc_element_t -> Ppx_deriving_runtime.string =

  fun x  -> Format.asprintf "%a" pp_vhdl_assoc_element_t x

and pp_vhdl_element_assoc_t :

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

  let __1 () = pp_vhdl_expr_t

  and __0 () = pp_vhdl_expr_t

   in

  ((let open! Ppx_deriving_runtime in

      fun fmt  ->

        fun x  ->

          Format.fprintf fmt "@[<2>{ ";

          ((Format.fprintf fmt "@[%s =@ " "choices";

            ((fun x  ->

                Format.fprintf fmt "@[<2>[";

                ignore

                  (List.fold_left

                     (fun sep  ->

                        fun x  ->

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

                          ((__0 ()) fmt) x;

                          true) false x);

                Format.fprintf fmt "@,]@]")) x.choices;

            Format.fprintf fmt "@]");

           Format.fprintf fmt ";@ ";

           Format.fprintf fmt "@[%s =@ " "expr";

           ((__1 ()) fmt) x.expr;

           Format.fprintf fmt "@]");

          Format.fprintf fmt "@ }@]")

    [@ocaml.warning "-A"])

and show_vhdl_element_assoc_t :

  vhdl_element_assoc_t -> Ppx_deriving_runtime.string =

  fun x  -> Format.asprintf "%a" pp_vhdl_element_assoc_t x

and (pp_vhdl_array_attributes_t :

      Format.formatter ->

        vhdl_array_attributes_t -> Ppx_deriving_runtime.unit)

  =

  ((let open! Ppx_deriving_runtime in

      fun fmt  ->

        function

        | AAttInt { id = aid; arg = aarg } ->

            (Format.fprintf fmt "@[<2>AAttInt {@,";

             ((Format.fprintf fmt "@[%s =@ " "id";

               (Format.fprintf fmt "%S") aid;

               Format.fprintf fmt "@]");

              Format.fprintf fmt ";@ ";

              Format.fprintf fmt "@[%s =@ " "arg";

              (Format.fprintf fmt "%d") aarg;

              Format.fprintf fmt "@]");

             Format.fprintf fmt "@]}")

        | AAttAscending  -> Format.pp_print_string fmt "AAttAscending")

  [@ocaml.warning "-A"])

and show_vhdl_array_attributes_t :

  vhdl_array_attributes_t -> Ppx_deriving_runtime.string =

  fun x  -> Format.asprintf "%a" pp_vhdl_array_attributes_t x

and (pp_vhdl_signal_attributes_t :

      Format.formatter ->

        vhdl_signal_attributes_t -> Ppx_deriving_runtime.unit)

  =

  ((let open! Ppx_deriving_runtime in

      fun fmt  ->

        function

        | SigAtt a0 ->

            (Format.fprintf fmt "(@[<2>SigAtt@ ";

             (Format.fprintf fmt "%S") a0;

             Format.fprintf fmt "@])"))

  [@ocaml.warning "-A"])

and show_vhdl_signal_attributes_t :

  vhdl_signal_attributes_t -> Ppx_deriving_runtime.string =

  fun x  -> Format.asprintf "%a" pp_vhdl_signal_attributes_t x

and (pp_vhdl_string_attributes_t :

      Format.formatter ->

        vhdl_string_attributes_t -> Ppx_deriving_runtime.unit)

  =

  ((let open! Ppx_deriving_runtime in

      fun fmt  ->

        function

        | StringAtt a0 ->

            (Format.fprintf fmt "(@[<2>StringAtt@ ";

             (Format.fprintf fmt "%S") a0;

             Format.fprintf fmt "@])"))

  [@ocaml.warning "-A"])

and show_vhdl_string_attributes_t :

  vhdl_string_attributes_t -> Ppx_deriving_runtime.string =

  fun x  -> Format.asprintf "%a" pp_vhdl_string_attributes_t x

and (pp_vhdl_suffix_selection_t :

      Format.formatter ->

        vhdl_suffix_selection_t -> Ppx_deriving_runtime.unit)

  =

  ((let open! Ppx_deriving_runtime in

      fun fmt  ->

        function

        | Idx a0 ->

            (Format.fprintf fmt "(@[<2>Idx@ ";

             (Format.fprintf fmt "%d") a0;

             Format.fprintf fmt "@])")

        | SuffixRange (a0,a1) ->

            (Format.fprintf fmt "(@[<2>SuffixRange (@,";

             ((Format.fprintf fmt "%d") a0;

              Format.fprintf fmt ",@ ";

              (Format.fprintf fmt "%d") a1);

             Format.fprintf fmt "@,))@]"))

  [@ocaml.warning "-A"])

and show_vhdl_suffix_selection_t :

  vhdl_suffix_selection_t -> Ppx_deriving_runtime.string =

  fun x  -> Format.asprintf "%a" pp_vhdl_suffix_selection_t x

let rec (vhdl_type_t_to_yojson : vhdl_type_t -> Yojson.Safe.json) =

  ((let open! Ppx_deriving_yojson_runtime in

      function

      | Base arg0 ->

          `List

            [`String "Base";

            ((fun (x : Ppx_deriving_runtime.string)  -> `String x)) arg0]

      | Range (arg0,arg1,arg2) ->

          `List

            [`String "Range";

            ((function

              | None  -> `Null

              | Some x ->

                  ((fun (x : Ppx_deriving_runtime.string)  -> `String x)) x))

              arg0;

            ((fun (x : Ppx_deriving_runtime.int)  -> `Int x)) arg1;

            ((fun (x : Ppx_deriving_runtime.int)  -> `Int x)) arg2]

      | Bit_vector (arg0,arg1) ->

          `List

            [`String "Bit_vector";

            ((fun (x : Ppx_deriving_runtime.int)  -> `Int x)) arg0;

            ((fun (x : Ppx_deriving_runtime.int)  -> `Int x)) arg1]

      | Array (arg0,arg1,arg2) ->

          `List

            [`String "Array";