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

(* 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

(* TODO Adapt for Type *)

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

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

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

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

            ((fun x  -> vhdl_type_t_to_yojson x)) arg2]

      | Enumerated arg0 ->

          `List

            [`String "Enumerated";

            ((fun x  ->

                `List

                  (List.map

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

              arg0]

      | Void  -> `List [`String "Void"])

  [@ocaml.warning "-A"])

and (vhdl_type_t_of_yojson :

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

  =

  ((let open! Ppx_deriving_yojson_runtime in

      function

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

          ((function

            | `String x -> Result.Ok x

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

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

      | `List ((`String "Range")::arg0::arg1::arg2::[]) ->

          ((function

            | `Int x -> Result.Ok x

            | _ -> Result.Error "Vhdl_ast.vhdl_type_t") arg2) >>=

            ((fun arg2  ->

                ((function

                  | `Int x -> Result.Ok x

                  | _ -> Result.Error "Vhdl_ast.vhdl_type_t") arg1) >>=

                  (fun arg1  ->

                     ((function

                       | `Null -> Result.Ok None

                       | x ->

                           ((function

                             | `String x -> Result.Ok x

                             | _ -> Result.Error "Vhdl_ast.vhdl_type_t") x)

                             >>= ((fun x  -> Result.Ok (Some x)))) arg0)

                       >>=

                       (fun arg0  -> Result.Ok (Range (arg0, arg1, arg2))))))

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

          ((function

            | `Int x -> Result.Ok x

            | _ -> Result.Error "Vhdl_ast.vhdl_type_t") arg1) >>=

            ((fun arg1  ->

                ((function

                  | `Int x -> Result.Ok x

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

                  (fun arg0  -> Result.Ok (Bit_vector (arg0, arg1)))))

      | `List ((`String "Array")::arg0::arg1::arg2::[]) ->

          ((fun x  -> vhdl_type_t_of_yojson x) arg2) >>=

            ((fun arg2  ->

                ((function

                  | `Int x -> Result.Ok x

                  | _ -> Result.Error "Vhdl_ast.vhdl_type_t") arg1) >>=

                  (fun arg1  ->

                     ((function

                       | `Int x -> Result.Ok x

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

                       (fun arg0  -> Result.Ok (Array (arg0, arg1, arg2))))))

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

          ((function

            | `List xs ->

                map_bind

                  (function

                   | `String x -> Result.Ok x

                   | _ -> Result.Error "Vhdl_ast.vhdl_type_t") [] xs

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

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

      | `List ((`String "Void")::[]) -> Result.Ok Void

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

  [@ocaml.warning "-A"])

and (vhdl_subtype_indication_t_to_yojson :

      vhdl_subtype_indication_t -> Yojson.Safe.json)

  =

  ((let open! Ppx_deriving_yojson_runtime in

      fun x  ->

        let fields = []  in

        let fields =

          if x.const = NoConstraint

          then fields

          else

            ("const", (((fun x  -> vhdl_constraint_t_to_yojson x)) x.const))

            :: fields

           in

        let fields =

          if x.functionName = NoName

          then fields

          else

            ("functionName",

              (((fun x  -> vhdl_name_t_to_yojson x)) x.functionName))

            :: fields

           in

        let fields =

          if x.name = NoName

          then fields

          else ("name", (((fun x  -> vhdl_name_t_to_yojson x)) x.name)) ::

            fields

           in

        `Assoc fields)

  [@ocaml.warning "-A"])

and (vhdl_subtype_indication_t_of_yojson :

      Yojson.Safe.json ->

        vhdl_subtype_indication_t Ppx_deriving_yojson_runtime.error_or)

  =

  ((let open! Ppx_deriving_yojson_runtime in

      function

      | `Assoc xs ->

          let rec loop xs ((arg0,arg1,arg2) as _state) =

            match xs with

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

                loop xs (((fun x  -> vhdl_name_t_of_yojson x) x), arg1, arg2)

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

                loop xs (arg0, ((fun x  -> vhdl_name_t_of_yojson x) x), arg2)

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

                loop xs

                  (arg0, arg1, ((fun x  -> vhdl_constraint_t_of_yojson x) x))

            | [] ->

                arg2 >>=

                  ((fun arg2  ->

                      arg1 >>=

                        (fun arg1  ->

                           arg0 >>=

                             (fun arg0  ->

                                Result.Ok

                                  {

                                    name = arg0;

                                    functionName = arg1;

                                    const = arg2

                                  }))))

            | _::xs -> loop xs _state  in

          loop xs

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

              (Result.Ok NoConstraint))

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

  [@ocaml.warning "-A"])

and (vhdl_discrete_range_t_to_yojson :

      vhdl_discrete_range_t -> Yojson.Safe.json)

  =

  ((let open! Ppx_deriving_yojson_runtime in

      function

      | SubDiscreteRange arg0 ->

          `List

            [`String "SUB_DISCRETE_RANGE";

            ((fun x  -> vhdl_subtype_indication_t_to_yojson x)) arg0]

      | NamedRange arg0 ->

          `List

            [`String "NAMED_RANGE";

            ((fun x  -> vhdl_name_t_to_yojson x)) arg0]

      | DirectedRange arg0 ->

          `List

            [`String "RANGE_WITH_DIRECTION";

            (let fields = []  in

             let fields =

               ("_to", ((fun x  -> vhdl_expr_t_to_yojson x) arg0._to)) ::

               fields  in

             let fields =

               ("from", ((fun x  -> vhdl_expr_t_to_yojson x) arg0.from)) ::

               fields  in

             let fields =

               ("direction",

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

                    arg0.direction))

               :: fields  in

             `Assoc fields)])

  [@ocaml.warning "-A"])

and (vhdl_discrete_range_t_of_yojson :

      Yojson.Safe.json ->

        vhdl_discrete_range_t Ppx_deriving_yojson_runtime.error_or)

  =

  ((let open! Ppx_deriving_yojson_runtime in

      function

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

          ((fun x  -> vhdl_subtype_indication_t_of_yojson x) arg0) >>=

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

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

          ((fun x  -> vhdl_name_t_of_yojson x) arg0) >>=

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

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

          ((function

            | `Assoc xs ->

                let rec loop xs ((arg0,arg1,arg2) as _state) =

                  match xs with

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

                      loop xs

                        (((function

                           | `String x -> Result.Ok x

                           | _ ->

                               Result.Error

                                 "Vhdl_ast.vhdl_discrete_range_t.direction")

                            x), arg1, arg2)

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

                      loop xs

                        (arg0, ((fun x  -> vhdl_expr_t_of_yojson x) x), arg2)

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

                      loop xs

                        (arg0, arg1, ((fun x  -> vhdl_expr_t_of_yojson x) x))

                  | [] ->

                      arg2 >>=

                        ((fun arg2  ->

                            arg1 >>=

                              (fun arg1  ->

                                 arg0 >>=

                                   (fun arg0  ->

                                      Result.Ok

                                        (DirectedRange

                                           {

                                             direction = arg0;

                                             from = arg1;

                                             _to = arg2

                                           })))))

                  | _::xs -> loop xs _state  in

                loop xs

                  ((Result.Error "Vhdl_ast.vhdl_discrete_range_t.direction"),

                    (Result.Error "Vhdl_ast.vhdl_discrete_range_t.from"),

                    (Result.Error "Vhdl_ast.vhdl_discrete_range_t._to"))

            | _ -> Result.Error "Vhdl_ast.vhdl_discrete_range_t")) arg0

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

  [@ocaml.warning "-A"])

and (vhdl_constraint_t_to_yojson : vhdl_constraint_t -> Yojson.Safe.json) =

  ((let open! Ppx_deriving_yojson_runtime in

      function

      | RefConstraint arg0 ->

          `List

            [`String "RefConstraint";

            (let fields = []  in

             let fields =

               ("ref_name",

                 ((fun x  -> vhdl_name_t_to_yojson x) arg0.ref_name))

               :: fields  in

             `Assoc fields)]

      | RangeConstraint arg0 ->

          `List

            [`String "RANGE_CONSTRAINT";

            (let fields = []  in

             let fields =

               ("range",

                 ((fun x  -> vhdl_discrete_range_t_to_yojson x) arg0.range))

               :: fields  in

             `Assoc fields)]

      | IndexConstraint arg0 ->

          `List

            [`String "INDEX_CONSTRAINT";

            (let fields = []  in

             let fields =

               ("ranges",

                 ((fun x  ->

                     `List

                       (List.map

                          (fun x  -> vhdl_discrete_range_t_to_yojson x) x))

                    arg0.ranges))

               :: fields  in

             `Assoc fields)]

      | ArrayConstraint arg0 ->

          `List

            [`String "ARRAY_CONSTRAINT";

            (let fields = []  in

             let fields =

               ("sub", ((fun x  -> vhdl_constraint_t_to_yojson x) arg0.sub))

               :: fields  in

             let fields =

               ("ranges",

                 ((fun x  ->

                     `List

                       (List.map

                          (fun x  -> vhdl_discrete_range_t_to_yojson x) x))

                    arg0.ranges))

               :: fields  in

             `Assoc fields)]

      | RecordConstraint  -> `List [`String "RecordConstraint"]

      | NoConstraint  -> `List [`String "NoConstraint"])

  [@ocaml.warning "-A"])

and (vhdl_constraint_t_of_yojson :

      Yojson.Safe.json ->

        vhdl_constraint_t Ppx_deriving_yojson_runtime.error_or)

  =

  ((let open! Ppx_deriving_yojson_runtime in

      function

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

          ((function

            | `Assoc xs ->

                let rec loop xs (arg0 as _state) =

                  match xs with

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

                      loop xs ((fun x  -> vhdl_name_t_of_yojson x) x)

                  | [] ->

                      arg0 >>=

                        ((fun arg0  ->

                            Result.Ok (RefConstraint { ref_name = arg0 })))

                  | _::xs -> loop xs _state  in

                loop xs (Result.Error "Vhdl_ast.vhdl_constraint_t.ref_name")

            | _ -> Result.Error "Vhdl_ast.vhdl_constraint_t")) arg0

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

          ((function

            | `Assoc xs ->

                let rec loop xs (arg0 as _state) =

                  match xs with

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

                      loop xs

                        ((fun x  -> vhdl_discrete_range_t_of_yojson x) x)

                  | [] ->

                      arg0 >>=

                        ((fun arg0  ->

                            Result.Ok (RangeConstraint { range = arg0 })))

                  | _::xs -> loop xs _state  in

                loop xs (Result.Error "Vhdl_ast.vhdl_constraint_t.range")

            | _ -> Result.Error "Vhdl_ast.vhdl_constraint_t")) arg0

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

          ((function

            | `Assoc xs ->

                let rec loop xs (arg0 as _state) =

                  match xs with

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

                      loop xs

                        ((function

                          | `List xs ->

                              map_bind

                                (fun x  -> vhdl_discrete_range_t_of_yojson x)

                                [] xs

                          | _ ->

                              Result.Error

                                "Vhdl_ast.vhdl_constraint_t.ranges") x)

                  | [] ->

                      arg0 >>=

                        ((fun arg0  ->

                            Result.Ok (IndexConstraint { ranges = arg0 })))

                  | _::xs -> loop xs _state  in

                loop xs (Result.Error "Vhdl_ast.vhdl_constraint_t.ranges")

            | _ -> Result.Error "Vhdl_ast.vhdl_constraint_t")) arg0

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

          ((function

            | `Assoc xs ->

                let rec loop xs ((arg0,arg1) as _state) =

                  match xs with

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

                      loop xs

                        (((function

                           | `List xs ->

                               map_bind

                                 (fun x  -> vhdl_discrete_range_t_of_yojson x)

                                 [] xs

                           | _ ->

                               Result.Error

                                 "Vhdl_ast.vhdl_constraint_t.ranges") x),

                          arg1)

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

                      loop xs

                        (arg0, ((fun x  -> vhdl_constraint_t_of_yojson x) x))

                  | [] ->

                      arg1 >>=

                        ((fun arg1  ->

                            arg0 >>=

                              (fun arg0  ->

                                 Result.Ok

                                   (ArrayConstraint

                                      { ranges = arg0; sub = arg1 }))))

                  | _::xs -> loop xs _state  in

                loop xs

                  ((Result.Error "Vhdl_ast.vhdl_constraint_t.ranges"),

                    (Result.Error "Vhdl_ast.vhdl_constraint_t.sub"))

            | _ -> Result.Error "Vhdl_ast.vhdl_constraint_t")) arg0

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

          Result.Ok RecordConstraint

      | `List ((`String "NoConstraint")::[]) -> Result.Ok NoConstraint

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

  [@ocaml.warning "-A"])

and (vhdl_definition_t_to_yojson : vhdl_definition_t -> Yojson.Safe.json) =

  ((let open! Ppx_deriving_yojson_runtime in

      function

      | Type arg0 ->

          `List

            [`String "TYPE_DECLARATION";

            (let fields = []  in

             let fields =

               ("definition",

                 ((fun x  -> vhdl_type_t_to_yojson x) arg0.definition))

               :: fields  in

             let fields =

               ("name", ((fun x  -> vhdl_name_t_to_yojson x) arg0.name)) ::

               fields  in

             `Assoc fields)]

      | Subtype arg0 ->

          `List

            [`String "SUBTYPE_DECLARATION";

            (let fields = []  in

             let fields =

               ("typ",

                 ((fun x  -> vhdl_subtype_indication_t_to_yojson x) arg0.typ))

               :: fields  in

             let fields =

               ("name", ((fun x  -> vhdl_name_t_to_yojson x) arg0.name)) ::

               fields  in

             `Assoc fields)])

  [@ocaml.warning "-A"])

and (vhdl_definition_t_of_yojson :

      Yojson.Safe.json ->

        vhdl_definition_t Ppx_deriving_yojson_runtime.error_or)

  =

  ((let open! Ppx_deriving_yojson_runtime in

      function

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

          ((function

            | `Assoc xs ->

                let rec loop xs ((arg0,arg1) as _state) =

                  match xs with

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

                      loop xs (((fun x  -> vhdl_name_t_of_yojson x) x), arg1)

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

                      loop xs (arg0, ((fun x  -> vhdl_type_t_of_yojson x) x))

                  | [] ->

                      arg1 >>=

                        ((fun arg1  ->

                            arg0 >>=

                              (fun arg0  ->

                                 Result.Ok

                                   (Type { name = arg0; definition = arg1 }))))

                  | _::xs -> loop xs _state  in

                loop xs

                  ((Result.Error "Vhdl_ast.vhdl_definition_t.name"),

                    (Result.Error "Vhdl_ast.vhdl_definition_t.definition"))

            | _ -> Result.Error "Vhdl_ast.vhdl_definition_t")) arg0

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

          ((function

            | `Assoc xs ->

                let rec loop xs ((arg0,arg1) as _state) =

                  match xs with

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

                      loop xs (((fun x  -> vhdl_name_t_of_yojson x) x), arg1)

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

                      loop xs

                        (arg0,

                          ((fun x  -> vhdl_subtype_indication_t_of_yojson x)

                             x))

                  | [] ->

                      arg1 >>=

                        ((fun arg1  ->

                            arg0 >>=

                              (fun arg0  ->

                                 Result.Ok

                                   (Subtype { name = arg0; typ = arg1 }))))

                  | _::xs -> loop xs _state  in

                loop xs

                  ((Result.Error "Vhdl_ast.vhdl_definition_t.name"),

                    (Result.Error "Vhdl_ast.vhdl_definition_t.typ"))

            | _ -> Result.Error "Vhdl_ast.vhdl_definition_t")) arg0

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

  [@ocaml.warning "-A"])

and (vhdl_expr_t_to_yojson : vhdl_expr_t -> Yojson.Safe.json) =

  ((let open! Ppx_deriving_yojson_runtime in

      function

      | Call arg0 ->

          `List [`String "CALL"; ((fun x  -> vhdl_name_t_to_yojson x)) arg0]

      | Cst arg0 ->

          `List

            [`String "CONSTANT_VALUE";

            ((fun x  -> vhdl_cst_val_t_to_yojson x)) arg0]

      | Op arg0 ->

          `List

            [`String "EXPRESSION";

            (let fields = []  in

             let fields =

               if arg0.args = []

               then fields

               else

                 ("args",

                   (((fun x  ->

                        `List

                          (List.map (fun x  -> vhdl_expr_t_to_yojson x) x)))

                      arg0.args))

                 :: fields

                in

             let fields =

               if arg0.id = ""

               then fields

               else

                 ("id",

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

                      arg0.id))

                 :: fields

                in

             `Assoc fields)]

      | IsNull  -> `List [`String "IsNull"]

      | Time arg0 ->

          `List

            [`String "Time";

            (let fields = []  in

             let fields =

               if arg0.phy_unit = ""

               then fields

               else

                 ("phy_unit",

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

                      arg0.phy_unit))

                 :: fields

                in

             let fields =

               ("value",

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

               :: fields  in

             `Assoc fields)]

      | Sig arg0 ->

          `List

            [`String "Sig";

            (let fields = []  in

             let fields =

               ("att",

                 ((function

                   | None  -> `Null

                   | Some x ->

                       ((fun x  -> vhdl_signal_attributes_t_to_yojson x)) x)

                    arg0.att))

               :: fields  in

             let fields =

               ("name", ((fun x  -> vhdl_name_t_to_yojson x) arg0.name)) ::

               fields  in

             `Assoc fields)]

      | SuffixMod arg0 ->

          `List

            [`String "SuffixMod";

            (let fields = []  in

             let fields =

               ("selection",

                 ((fun x  -> vhdl_suffix_selection_t_to_yojson x)

                    arg0.selection))

               :: fields  in

             let fields =

               ("expr", ((fun x  -> vhdl_expr_t_to_yojson x) arg0.expr)) ::

               fields  in

             `Assoc fields)]

      | Aggregate arg0 ->

          `List

            [`String "AGGREGATE";

            (let fields = []  in

             let fields =

               ("elems",

                 ((fun x  ->

                     `List

                       (List.map (fun x  -> vhdl_element_assoc_t_to_yojson x)

                          x)) arg0.elems))

               :: fields  in

             `Assoc fields)]

      | Others  -> `List [`String "OTHERS"])

  [@ocaml.warning "-A"])

and (vhdl_expr_t_of_yojson :

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

  =

  ((let open! Ppx_deriving_yojson_runtime in

      function

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

          ((fun x  -> vhdl_name_t_of_yojson x) arg0) >>=

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

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

          ((fun x  -> vhdl_cst_val_t_of_yojson x) arg0) >>=

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

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

          ((function

            | `Assoc xs ->

                let rec loop xs ((arg0,arg1) as _state) =

                  match xs with

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

                      loop xs

                        (((function

                           | `String x -> Result.Ok x

                           | _ -> Result.Error "Vhdl_ast.vhdl_expr_t.id") x),

                          arg1)

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

                      loop xs

                        (arg0,

                          ((function

                            | `List xs ->

                                map_bind (fun x  -> vhdl_expr_t_of_yojson x)

                                  [] xs

                            | _ -> Result.Error "Vhdl_ast.vhdl_expr_t.args")

                             x))

                  | [] ->

                      arg1 >>=

                        ((fun arg1  ->

                            arg0 >>=

                              (fun arg0  ->

                                 Result.Ok (Op { id = arg0; args = arg1 }))))

                  | _::xs -> loop xs _state  in

                loop xs ((Result.Ok ""), (Result.Ok []))

            | _ -> Result.Error "Vhdl_ast.vhdl_expr_t")) arg0

      | `List ((`String "IsNull")::[]) -> Result.Ok IsNull

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

          ((function

            | `Assoc xs ->

                let rec loop xs ((arg0,arg1) as _state) =

                  match xs with

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

                      loop xs

                        (((function

                           | `Int x -> Result.Ok x

                           | _ -> Result.Error "Vhdl_ast.vhdl_expr_t.value")

                            x), arg1)

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

                      loop xs

                        (arg0,

                          ((function

                            | `String x -> Result.Ok x

                            | _ ->

                                Result.Error "Vhdl_ast.vhdl_expr_t.phy_unit")

                             x))

                  | [] ->

                      arg1 >>=

                        ((fun arg1  ->

                            arg0 >>=

                              (fun arg0  ->

                                 Result.Ok

                                   (Time { value = arg0; phy_unit = arg1 }))))

                  | _::xs -> loop xs _state  in

                loop xs

                  ((Result.Error "Vhdl_ast.vhdl_expr_t.value"),

                    (Result.Ok ""))

            | _ -> Result.Error "Vhdl_ast.vhdl_expr_t")) arg0

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

          ((function

            | `Assoc xs ->

                let rec loop xs ((arg0,arg1) as _state) =

                  match xs with

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

                      loop xs (((fun x  -> vhdl_name_t_of_yojson x) x), arg1)

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

                      loop xs

                        (arg0,

                          ((function

                            | `Null -> Result.Ok None

                            | x ->

                                ((fun x  ->

                                    vhdl_signal_attributes_t_of_yojson x) x)

                                  >>= ((fun x  -> Result.Ok (Some x)))) x))

                  | [] ->

                      arg1 >>=

                        ((fun arg1  ->

                            arg0 >>=

                              (fun arg0  ->

                                 Result.Ok (Sig { name = arg0; att = arg1 }))))

                  | _::xs -> loop xs _state  in

                loop xs

                  ((Result.Error "Vhdl_ast.vhdl_expr_t.name"),

                    (Result.Error "Vhdl_ast.vhdl_expr_t.att"))

            | _ -> Result.Error "Vhdl_ast.vhdl_expr_t")) arg0

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

          ((function

            | `Assoc xs ->

                let rec loop xs ((arg0,arg1) as _state) =

                  match xs with

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

                      loop xs (((fun x  -> vhdl_expr_t_of_yojson x) x), arg1)

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

                      loop xs

                        (arg0,

                          ((fun x  -> vhdl_suffix_selection_t_of_yojson x) x))

                  | [] ->

                      arg1 >>=

                        ((fun arg1  ->

                            arg0 >>=

                              (fun arg0  ->

                                 Result.Ok

                                   (SuffixMod

                                      { expr = arg0; selection = arg1 }))))

                  | _::xs -> loop xs _state  in

                loop xs

                  ((Result.Error "Vhdl_ast.vhdl_expr_t.expr"),

                    (Result.Error "Vhdl_ast.vhdl_expr_t.selection"))

            | _ -> Result.Error "Vhdl_ast.vhdl_expr_t")) arg0

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

          ((function

            | `Assoc xs ->

                let rec loop xs (arg0 as _state) =

                  match xs with

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

                      loop xs

                        ((function

                          | `List xs ->

                              map_bind

                                (fun x  -> vhdl_element_assoc_t_of_yojson x)

                                [] xs

                          | _ -> Result.Error "Vhdl_ast.vhdl_expr_t.elems") x)

                  | [] ->

                      arg0 >>=

                        ((fun arg0  -> Result.Ok (Aggregate { elems = arg0 })))

                  | _::xs -> loop xs _state  in

                loop xs (Result.Error "Vhdl_ast.vhdl_expr_t.elems")

            | _ -> Result.Error "Vhdl_ast.vhdl_expr_t")) arg0

      | `List ((`String "OTHERS")::[]) -> Result.Ok Others

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

  [@ocaml.warning "-A"])

and (vhdl_name_t_to_yojson : vhdl_name_t -> Yojson.Safe.json) =

  ((let open! Ppx_deriving_yojson_runtime in

      function

      | Simple arg0 ->

          `List

            [`String "SIMPLE_NAME";

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

      | Identifier arg0 ->

          `List

            [`String "IDENTIFIER";

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

      | Selected arg0 ->

          `List

            [`String "SELECTED_NAME";

            ((fun x  ->

                `List (List.map (fun x  -> vhdl_name_t_to_yojson x) x))) arg0]

      | Index arg0 ->

          `List

            [`String "INDEXED_NAME";

            (let fields = []  in

             let fields =

               ("exprs",

                 ((fun x  ->

                     `List (List.map (fun x  -> vhdl_expr_t_to_yojson x) x))

                    arg0.exprs))

               :: fields  in

             let fields =

               ("id", ((fun x  -> vhdl_name_t_to_yojson x) arg0.id)) ::

               fields  in

             `Assoc fields)]

      | Slice arg0 ->

          `List

            [`String "SLICE_NAME";

            (let fields = []  in

             let fields =

               ("range",

                 ((fun x  -> vhdl_discrete_range_t_to_yojson x) arg0.range))

               :: fields  in

             let fields =

               ("id", ((fun x  -> vhdl_name_t_to_yojson x) arg0.id)) ::

               fields  in

             `Assoc fields)]

      | Attribute arg0 ->

          `List

            [`String "ATTRIBUTE_NAME";

            (let fields = []  in

             let fields =

               if arg0.expr = IsNull

               then fields

               else

                 ("expr", (((fun x  -> vhdl_expr_t_to_yojson x)) arg0.expr))

                 :: fields

                in

             let fields =

               ("designator",

                 ((fun x  -> vhdl_name_t_to_yojson x) arg0.designator))

               :: fields  in

             let fields =

               ("id", ((fun x  -> vhdl_name_t_to_yojson x) arg0.id)) ::

               fields  in

             `Assoc fields)]

      | Function arg0 ->

          `List

            [`String "FUNCTION_CALL";

            (let fields = []  in

             let fields =

               ("assoc_list",

                 ((fun x  ->

                     `List

                       (List.map (fun x  -> vhdl_assoc_element_t_to_yojson x)

                          x)) arg0.assoc_list))

               :: fields  in

             let fields =

               ("id", ((fun x  -> vhdl_name_t_to_yojson x) arg0.id)) ::

               fields  in

             `Assoc fields)]

      | NoName  -> `List [`String "NoName"])

  [@ocaml.warning "-A"])

and (vhdl_name_t_of_yojson :

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

  =

  ((let open! Ppx_deriving_yojson_runtime in

      function

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

          ((function

            | `String x -> Result.Ok x

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

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

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

          ((function

            | `String x -> Result.Ok x

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

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

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

          ((function

            | `List xs -> map_bind (fun x  -> vhdl_name_t_of_yojson x) [] xs

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

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

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

          ((function

            | `Assoc xs ->

                let rec loop xs ((arg0,arg1) as _state) =

                  match xs with

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

                      loop xs (((fun x  -> vhdl_name_t_of_yojson x) x), arg1)

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

                      loop xs

                        (arg0,

                          ((function

                            | `List xs ->

                                map_bind (fun x  -> vhdl_expr_t_of_yojson x)

                                  [] xs

                            | _ -> Result.Error "Vhdl_ast.vhdl_name_t.exprs")

                             x))

                  | [] ->

                      arg1 >>=

                        ((fun arg1  ->

                            arg0 >>=

                              (fun arg0  ->

                                 Result.Ok

                                   (Index { id = arg0; exprs = arg1 }))))

                  | _::xs -> loop xs _state  in