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"]

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

  {

  indexes: vhdl_name_t list [@default []];

  const: vhdl_constraint_t option [@default None];

  definition: vhdl_subtype_indication_t } [@name "ARRAY_TYPE_DEFINITION"]

  | Record of vhdl_element_declaration_t list

  [@name "RECORD_TYPE_DEFINITION"]

  | Enumerated of vhdl_name_t list [@name "ENUMERATION_TYPE_DEFINITION"]

  | Void 

and vhdl_element_declaration_t =

  {

  names: vhdl_name_t list ;

  definition: vhdl_subtype_indication_t }

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

  {

  value: vhdl_cst_val_t ;

  unit_name: vhdl_name_t option [@default None]} [@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"]

  | QualifiedExpression of

  {

  type_mark: vhdl_name_t ;

  aggregate: vhdl_element_assoc_t list ;

  expression: vhdl_expr_t option } [@name "QUALIFIED_EXPRESSION"]

  | 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 [@default []];

  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 __4 () = pp_vhdl_name_t

  and __3 () = pp_vhdl_element_declaration_t

  and __2 () = pp_vhdl_subtype_indication_t

  and __1 () = pp_vhdl_constraint_t

  and __0 () = pp_vhdl_name_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 ""

                 | Some x ->

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

                      )) a0;

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

        | Bit_vector (a0,a1) ->

             (Format.fprintf fmt "array (%d,%d) of bit") a0 a1;

        | Array

            { indexes = aindexes; const = aconst; definition = adefinition }

            ->

            Format.fprintf fmt "array";

            (match aindexes with

            | [] -> Format.fprintf fmt "";

            | _ ->

              Format.fprintf fmt "(@[<v>";

              ((fun x  ->

                ignore

                (List.fold_left

                  (fun sep  ->

                    fun x  ->

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

                      ((__0 ()) fmt) x;

                      Format.fprintf fmt " range <>";

                      true) false x)) aindexes);

              Format.fprintf fmt ")@]");

            (function

              | None  -> Format.pp_print_string fmt ""

              | Some x ->

                ((__1 ()) fmt) x) aconst;

            Format.fprintf fmt " of ";

            ((__2 ()) fmt) adefinition;

        | Record a0 ->

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

            (fun x  ->

              ignore

                (List.fold_left

                  (fun sep  ->

                    fun x  ->

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

                        ((__3 ()) fmt) x;

                        true) false x);

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

        | Enumerated a0 ->

            (Format.fprintf fmt "(";

            ((fun x  ->

              ignore

              (List.fold_left

                (fun sep  ->

                  fun x  ->

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

                      ((__4 ()) fmt) x;

                    true) false x))) a0;

             Format.fprintf fmt ")");

        | Void  -> Format.pp_print_string fmt "")

    [@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

and pp_vhdl_element_declaration_t :

  Format.formatter -> vhdl_element_declaration_t -> Ppx_deriving_runtime.unit

  =

  let __1 () = pp_vhdl_subtype_indication_t

  and __0 () = pp_vhdl_name_t

   in

  ((let open! Ppx_deriving_runtime in

      fun fmt  ->

        fun x  ->

            (fun x  ->

                ignore

                  (List.fold_left

                     (fun sep  ->

                        fun x  ->

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

                          ((__0 ()) fmt) x;

                          true) false x)) x.names;

           Format.fprintf fmt ":@ ";

           ((__1 ()) fmt) x.definition)

    [@ocaml.warning "-A"])

and show_vhdl_element_declaration_t :

  vhdl_element_declaration_t -> Ppx_deriving_runtime.string =

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

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;

          (match x.const with

            | NoConstraint -> Format.fprintf fmt "";

            | _ -> 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

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

(* TODO Adapt 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 "type ";

            ((__0 ()) fmt) aname;

            Format.fprintf fmt " is ";

            ((__1 ()) fmt) adefinition;

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

            Format.fprintf fmt "subtype ";

            ((__2 ()) fmt) aname;

            Format.fprintf fmt " is ";

            ((__3 ()) fmt) atyp;

   )

    [@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

(* TODO adapt for Op, Time, Sig, suffixMod *)

and pp_vhdl_expr_t :

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

  let __11 () = pp_vhdl_expr_t

  and __10 () = pp_vhdl_element_assoc_t

  and __9 () = pp_vhdl_name_t

  and __8 () = pp_vhdl_element_assoc_t

  and __7 () = pp_vhdl_suffix_selection_t

  and __6 () = pp_vhdl_expr_t

  and __5 () = pp_vhdl_signal_attributes_t

  and __4 () = pp_vhdl_name_t

  and __3 () = pp_vhdl_expr_t

  and __2 () = pp_vhdl_name_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 { value = avalue; unit_name = aunit_name } ->

             ((__1 ()) fmt) avalue;

             (function

                | None  -> Format.pp_print_string fmt ""

                | Some x ->

                    Format.fprintf fmt " ";

                    ((__2 ()) fmt) x) aunit_name;

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

            (match aargs with

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

            | hd::[] ->

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

               ((__3 ()) fmt) hd

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

               ((__3 ()) fmt) hd;

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

               ((__3 ()) 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 ";@ ";

                            ((__3 ()) 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";

               ((__4 ()) 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 ";

                     ((__5 ()) 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";

               ((__6 ()) fmt) aexpr;

               Format.fprintf fmt "@]");

              Format.fprintf fmt ";@ ";

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

              ((__7 ()) fmt) aselection;

              Format.fprintf fmt "@]");

             Format.fprintf fmt "@]}")

        | Aggregate { elems = aelems } ->

            (match aelems with

            | [] -> Format.fprintf fmt "";

            | _ ->

              (Format.fprintf fmt "(@[";

              ((fun x  ->

                  ignore

                    (List.fold_left

                       (fun sep  ->

                          fun x  ->

                            if sep then Format.fprintf fmt ", ";

                            ((__8 ()) fmt) x;

                            true) false x))) aelems;

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

        | QualifiedExpression

            { type_mark = atype_mark; aggregate = aaggregate;

              expression = aexpression }

            ->

              ((__9 ()) fmt) atype_mark;

              Format.fprintf fmt "'";

              (match aaggregate with

              | [] -> Format.fprintf fmt "";

              | _ -> 

                Format.fprintf fmt "(@[<v>";

                ((fun x  ->

                   ignore

                     (List.fold_left

                        (fun sep  ->

                           fun x  ->

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

                             ((__10 ()) fmt) x;

                             true) false x))) aaggregate;

              Format.fprintf fmt ")@]");

              (match aexpression with

              | None  -> Format.pp_print_string fmt ""

              | Some x ->

                  ((__11 ()) fmt) x;);

        | 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

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

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 -> Format.pp_print_string fmt ""

              | Some b -> ((__1 ()) fmt) b);

              Format.fprintf fmt " => "));

          (match x.actual_name with

          | None -> 

              ((match x.actual_designator with

              | None -> Format.pp_print_string fmt ""

              | Some NoName -> Format.pp_print_string fmt ""

              | Some b -> ((__3 ()) fmt) b);

              (match x.actual_expr with

              | None -> Format.pp_print_string fmt ""

              | Some IsNull -> Format.pp_print_string fmt ""

              | Some c -> ((__4 ()) fmt) c);)

          | Some a -> 

              (((__2 ()) fmt) a;

              (match a with

              | NoName -> ()

              | _ -> Format.fprintf fmt "(");

              (match x.actual_designator with

              | None -> Format.pp_print_string fmt ""

              | Some b -> ((__3 ()) fmt) b);

              (match x.actual_expr with

              | None -> Format.pp_print_string fmt ""

              | Some IsNull -> Format.pp_print_string fmt ""

              | Some c -> ((__4 ()) fmt) c);

              (match a with

              | NoName -> ()

              | _ -> 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  ->

            (match x.choices with

            | [] -> Format.fprintf fmt "";

            | _ -> 

              (((fun x  ->

                ignore

                  (List.fold_left

                     (fun sep  ->

                        fun x  ->

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

                          ((__0 ()) fmt) x;

                          true) false x))) x.choices;

              Format.fprintf fmt " => ";));

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