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 (more than 2 operand), 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)

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

(* TODO *)

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

(* TODO *)

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

(* TODO *)

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

(* TODO *)

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

          `List

            [`String "ARRAY_TYPE_DEFINITION";

            (let fields = []  in

             let fields =

               ("definition",

                 ((fun x  -> vhdl_subtype_indication_t_to_yojson x)

                    arg0.definition))

               :: fields  in

             let fields =

               if arg0.const = None

               then fields

               else

                 ("const",

                   (((function

                      | None  -> `Null

                      | Some x ->

                          ((fun x  -> vhdl_constraint_t_to_yojson x)) x))

                      arg0.const))

                 :: fields

                in

             let fields =

               if arg0.indexes = []

               then fields

               else

                 ("indexes",

                   (((fun x  ->

                        `List

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

                      arg0.indexes))

                 :: fields

                in

             `Assoc fields)]

      | Record arg0 ->

          `List

            [`String "RECORD_TYPE_DEFINITION";

            ((fun x  ->

                `List

                  (List.map

                     (fun x  -> vhdl_element_declaration_t_to_yojson x) x)))

              arg0]

      | Enumerated arg0 ->

          `List

            [`String "ENUMERATION_TYPE_DEFINITION";

            ((fun x  ->

                `List (List.map (fun x  -> vhdl_name_t_to_yojson 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_TYPE_DEFINITION")::arg0::[]) ->

          ((function

            | `Assoc xs ->

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

                  match xs with

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

                      loop xs

                        (((function

                           | `List xs ->

                               map_bind (fun x  -> vhdl_name_t_of_yojson x)

                                 [] xs

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

                            x), arg1, arg2)

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

                      loop xs

                        (arg0,

                          ((function

                            | `Null -> Result.Ok None

                            | x ->

                                ((fun x  -> vhdl_constraint_t_of_yojson x) x)

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

                          arg2)

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

                      loop xs

                        (arg0, arg1,

                          ((fun x  -> vhdl_subtype_indication_t_of_yojson x)

                             x))

                  | [] ->

                      arg2 >>=

                        ((fun arg2  ->

                            arg1 >>=

                              (fun arg1  ->

                                 arg0 >>=

                                   (fun arg0  ->

                                      Result.Ok

                                        (Array

                                           {

                                             indexes = arg0;

                                             const = arg1;

                                             definition = arg2

                                           })))))

                  | _::xs -> loop xs _state  in

                loop xs

                  ((Result.Ok []), (Result.Ok None),

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

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

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

          ((function

            | `List xs ->

                map_bind (fun x  -> vhdl_element_declaration_t_of_yojson x)

                  [] xs

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

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

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

          ((function

            | `List xs -> map_bind (fun x  -> vhdl_name_t_of_yojson x) [] 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_element_declaration_t_to_yojson :

      vhdl_element_declaration_t -> Yojson.Safe.json)

  =

  ((let open! Ppx_deriving_yojson_runtime in

      fun x  ->

        let fields = []  in

        let fields =

          ("definition",

            ((fun x  -> vhdl_subtype_indication_t_to_yojson x) x.definition))

          :: fields  in

        let fields =

          ("names",

            ((fun x  ->

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

               x.names))

          :: fields  in

        `Assoc fields)

  [@ocaml.warning "-A"])

and (vhdl_element_declaration_t_of_yojson :

      Yojson.Safe.json ->

        vhdl_element_declaration_t Ppx_deriving_yojson_runtime.error_or)

  =

  ((let open! Ppx_deriving_yojson_runtime in

      function

      | `Assoc xs ->

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

            match xs with

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

                loop xs

                  (((function

                     | `List xs ->

                         map_bind (fun x  -> vhdl_name_t_of_yojson x) [] xs

                     | _ ->

                         Result.Error

                           "Vhdl_ast.vhdl_element_declaration_t.names") x),

                    arg1)

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

                loop xs

                  (arg0,

                    ((fun x  -> vhdl_subtype_indication_t_of_yojson x) x))

            | [] ->

                arg1 >>=

                  ((fun arg1  ->

                      arg0 >>=

                        (fun arg0  ->

                           Result.Ok { names = arg0; definition = arg1 })))

            | _::xs -> loop xs _state  in

          loop xs

            ((Result.Error "Vhdl_ast.vhdl_element_declaration_t.names"),

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

      | _ -> Result.Error "Vhdl_ast.vhdl_element_declaration_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";

            (let fields = []  in

             let fields =

               if arg0.unit_name = None

               then fields

               else

                 ("unit_name",

                   (((function

                      | None  -> `Null

                      | Some x -> ((fun x  -> vhdl_name_t_to_yojson x)) x))

                      arg0.unit_name))

                 :: fields

                in

             let fields =

               ("value", ((fun x  -> vhdl_cst_val_t_to_yojson x) arg0.value))

               :: fields  in

             `Assoc fields)]

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

               if arg0.att = None

               then fields

               else

                 ("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 =

               if arg0.elems = []

               then fields

               else

                 ("elems",

                   (((fun x  ->

                        `List

                          (List.map

                             (fun x  -> vhdl_element_assoc_t_to_yojson x) x)))

                      arg0.elems))

                 :: fields

                in

             `Assoc fields)]

      | QualifiedExpression arg0 ->

          `List

            [`String "QUALIFIED_EXPRESSION";