Project

General

Profile

Download (173 KB) Statistics
| Branch: | Tag: | Revision:
1
open Vhdl_ast
2

    
3
let rec (vhdl_cst_val_t_to_yojson : vhdl_cst_val_t -> Yojson.Safe.json) =
4
  ((let open! Ppx_deriving_yojson_runtime in
5
      function
6
      | CstInt arg0 ->
7
          `List
8
            [`String "CstInt";
9
            ((fun (x : Ppx_deriving_runtime.int)  -> `Int x)) arg0]
10
      | CstStdLogic arg0 ->
11
          `List
12
            [`String "CstStdLogic";
13
            ((fun (x : Ppx_deriving_runtime.string)  -> `String x)) arg0]
14
      | CstLiteral arg0 ->
15
          `List
16
            [`String "CST_LITERAL";
17
            ((fun (x : Ppx_deriving_runtime.string)  -> `String x)) arg0])
18
  [@ocaml.warning "-A"])
19

    
20
and (vhdl_cst_val_t_of_yojson :
21
      Yojson.Safe.json -> vhdl_cst_val_t Ppx_deriving_yojson_runtime.error_or)
22
  =
23
  ((let open! Ppx_deriving_yojson_runtime in
24
      function
25
      | `List ((`String "CstInt")::arg0::[]) ->
26
          ((function
27
            | `Int x -> Result.Ok x
28
            | _ -> Result.Error "Vhdl_ast.vhdl_cst_val_t") arg0) >>=
29
            ((fun arg0  -> Result.Ok (CstInt arg0)))
30
      | `List ((`String "CstStdLogic")::arg0::[]) ->
31
          ((function
32
            | `String x -> Result.Ok x
33
            | _ -> Result.Error "Vhdl_ast.vhdl_cst_val_t") arg0) >>=
34
            ((fun arg0  -> Result.Ok (CstStdLogic arg0)))
35
      | `List ((`String "CST_LITERAL")::arg0::[]) ->
36
          ((function
37
            | `String x -> Result.Ok x
38
            | _ -> Result.Error "Vhdl_ast.vhdl_cst_val_t") arg0) >>=
39
            ((fun arg0  -> Result.Ok (CstLiteral arg0)))
40
      | _ -> Result.Error "Vhdl_ast.vhdl_cst_val_t")
41
  [@ocaml.warning "-A"])
42

    
43
let rec (vhdl_type_t_to_yojson : vhdl_type_t -> Yojson.Safe.json) =
44
  ((let open! Ppx_deriving_yojson_runtime in
45
      function
46
      | Base arg0 ->
47
          `List
48
            [`String "Base";
49
            ((fun (x : Ppx_deriving_runtime.string)  -> `String x)) arg0]
50
      | Range (arg0,arg1,arg2) ->
51
          `List
52
            [`String "Range";
53
            ((function
54
              | None  -> `Null
55
              | Some x ->
56
                  ((fun (x : Ppx_deriving_runtime.string)  -> `String x)) x))
57
              arg0;
58
            ((fun (x : Ppx_deriving_runtime.int)  -> `Int x)) arg1;
59
            ((fun (x : Ppx_deriving_runtime.int)  -> `Int x)) arg2]
60
      | Bit_vector (arg0,arg1) ->
61
          `List
62
            [`String "Bit_vector";
63
            ((fun (x : Ppx_deriving_runtime.int)  -> `Int x)) arg0;
64
            ((fun (x : Ppx_deriving_runtime.int)  -> `Int x)) arg1]
65
      | Array arg0 ->
66
          `List
67
            [`String "ARRAY_TYPE_DEFINITION";
68
            (let fields = []  in
69
             let fields =
70
               ("definition",
71
                 ((fun x  -> vhdl_subtype_indication_t_to_yojson x)
72
                    arg0.definition))
73
               :: fields  in
74
             let fields =
75
               if arg0.const = None
76
               then fields
77
               else
78
                 ("const",
79
                   (((function
80
                      | None  -> `Null
81
                      | Some x ->
82
                          ((fun x  -> vhdl_constraint_t_to_yojson x)) x))
83
                      arg0.const))
84
                 :: fields
85
                in
86
             let fields =
87
               if arg0.indexes = []
88
               then fields
89
               else
90
                 ("indexes",
91
                   (((fun x  ->
92
                        `List
93
                          (List.map (fun x  -> vhdl_name_t_to_yojson x) x)))
94
                      arg0.indexes))
95
                 :: fields
96
                in
97
             `Assoc fields)]
98
      | Record arg0 ->
99
          `List
100
            [`String "RECORD_TYPE_DEFINITION";
101
            ((fun x  ->
102
                `List
103
                  (List.map
104
                     (fun x  -> vhdl_element_declaration_t_to_yojson x) x)))
105
              arg0]
106
      | Enumerated arg0 ->
107
          `List
108
            [`String "ENUMERATION_TYPE_DEFINITION";
109
            ((fun x  ->
110
                `List (List.map (fun x  -> vhdl_name_t_to_yojson x) x))) arg0]
111
      | Void  -> `List [`String "Void"])
112
  [@ocaml.warning "-A"])
113

    
114
and (vhdl_type_t_of_yojson :
115
      Yojson.Safe.json -> vhdl_type_t Ppx_deriving_yojson_runtime.error_or)
116
  =
117
  ((let open! Ppx_deriving_yojson_runtime in
118
      function
119
      | `List ((`String "Base")::arg0::[]) ->
120
          ((function
121
            | `String x -> Result.Ok x
122
            | _ -> Result.Error "Vhdl_ast.vhdl_type_t") arg0) >>=
123
            ((fun arg0  -> Result.Ok (Base arg0)))
124
      | `List ((`String "Range")::arg0::arg1::arg2::[]) ->
125
          ((function
126
            | `Int x -> Result.Ok x
127
            | _ -> Result.Error "Vhdl_ast.vhdl_type_t") arg2) >>=
128
            ((fun arg2  ->
129
                ((function
130
                  | `Int x -> Result.Ok x
131
                  | _ -> Result.Error "Vhdl_ast.vhdl_type_t") arg1) >>=
132
                  (fun arg1  ->
133
                     ((function
134
                       | `Null -> Result.Ok None
135
                       | x ->
136
                           ((function
137
                             | `String x -> Result.Ok x
138
                             | _ -> Result.Error "Vhdl_ast.vhdl_type_t") x)
139
                             >>= ((fun x  -> Result.Ok (Some x)))) arg0)
140
                       >>=
141
                       (fun arg0  -> Result.Ok (Range (arg0, arg1, arg2))))))
142
      | `List ((`String "Bit_vector")::arg0::arg1::[]) ->
143
          ((function
144
            | `Int x -> Result.Ok x
145
            | _ -> Result.Error "Vhdl_ast.vhdl_type_t") arg1) >>=
146
            ((fun arg1  ->
147
                ((function
148
                  | `Int x -> Result.Ok x
149
                  | _ -> Result.Error "Vhdl_ast.vhdl_type_t") arg0) >>=
150
                  (fun arg0  -> Result.Ok (Bit_vector (arg0, arg1)))))
151
      | `List ((`String "ARRAY_TYPE_DEFINITION")::arg0::[]) ->
152
          ((function
153
            | `Assoc xs ->
154
                let rec loop xs ((arg0,arg1,arg2) as _state) =
155
                  match xs with
156
                  | ("indexes",x)::xs ->
157
                      loop xs
158
                        (((function
159
                           | `List xs ->
160
                               map_bind (fun x  -> vhdl_name_t_of_yojson x)
161
                                 [] xs
162
                           | _ -> Result.Error "Vhdl_ast.vhdl_type_t.indexes")
163
                            x), arg1, arg2)
164
                  | ("const",x)::xs ->
165
                      loop xs
166
                        (arg0,
167
                          ((function
168
                            | `Null -> Result.Ok None
169
                            | x ->
170
                                ((fun x  -> vhdl_constraint_t_of_yojson x) x)
171
                                  >>= ((fun x  -> Result.Ok (Some x)))) x),
172
                          arg2)
173
                  | ("definition",x)::xs ->
174
                      loop xs
175
                        (arg0, arg1,
176
                          ((fun x  -> vhdl_subtype_indication_t_of_yojson x)
177
                             x))
178
                  | [] ->
179
                      arg2 >>=
180
                        ((fun arg2  ->
181
                            arg1 >>=
182
                              (fun arg1  ->
183
                                 arg0 >>=
184
                                   (fun arg0  ->
185
                                      Result.Ok
186
                                        (Array
187
                                           {
188
                                             indexes = arg0;
189
                                             const = arg1;
190
                                             definition = arg2
191
                                           })))))
192
                  | _::xs -> loop xs _state  in
193
                loop xs
194
                  ((Result.Ok []), (Result.Ok None),
195
                    (Result.Error "Vhdl_ast.vhdl_type_t.definition"))
196
            | _ -> Result.Error "Vhdl_ast.vhdl_type_t")) arg0
197
      | `List ((`String "RECORD_TYPE_DEFINITION")::arg0::[]) ->
198
          ((function
199
            | `List xs ->
200
                map_bind (fun x  -> vhdl_element_declaration_t_of_yojson x)
201
                  [] xs
202
            | _ -> Result.Error "Vhdl_ast.vhdl_type_t") arg0) >>=
203
            ((fun arg0  -> Result.Ok (Record arg0)))
204
      | `List ((`String "ENUMERATION_TYPE_DEFINITION")::arg0::[]) ->
205
          ((function
206
            | `List xs -> map_bind (fun x  -> vhdl_name_t_of_yojson x) [] xs
207
            | _ -> Result.Error "Vhdl_ast.vhdl_type_t") arg0) >>=
208
            ((fun arg0  -> Result.Ok (Enumerated arg0)))
209
      | `List ((`String "Void")::[]) -> Result.Ok Void
210
      | _ -> Result.Error "Vhdl_ast.vhdl_type_t")
211
  [@ocaml.warning "-A"])
212

    
213
and (vhdl_element_declaration_t_to_yojson :
214
      vhdl_element_declaration_t -> Yojson.Safe.json)
215
  =
216
  ((let open! Ppx_deriving_yojson_runtime in
217
      fun x  ->
218
        let fields = []  in
219
        let fields =
220
          ("definition",
221
            ((fun x  -> vhdl_subtype_indication_t_to_yojson x) x.definition))
222
          :: fields  in
223
        let fields =
224
          ("names",
225
            ((fun x  ->
226
                `List (List.map (fun x  -> vhdl_name_t_to_yojson x) x))
227
               x.names))
228
          :: fields  in
229
        `Assoc fields)
230
  [@ocaml.warning "-A"])
231

    
232
and (vhdl_element_declaration_t_of_yojson :
233
      Yojson.Safe.json ->
234
        vhdl_element_declaration_t Ppx_deriving_yojson_runtime.error_or)
235
  =
236
  ((let open! Ppx_deriving_yojson_runtime in
237
      function
238
      | `Assoc xs ->
239
          let rec loop xs ((arg0,arg1) as _state) =
240
            match xs with
241
            | ("names",x)::xs ->
242
                loop xs
243
                  (((function
244
                     | `List xs ->
245
                         map_bind (fun x  -> vhdl_name_t_of_yojson x) [] xs
246
                     | _ ->
247
                         Result.Error
248
                           "Vhdl_ast.vhdl_element_declaration_t.names") x),
249
                    arg1)
250
            | ("definition",x)::xs ->
251
                loop xs
252
                  (arg0,
253
                    ((fun x  -> vhdl_subtype_indication_t_of_yojson x) x))
254
            | [] ->
255
                arg1 >>=
256
                  ((fun arg1  ->
257
                      arg0 >>=
258
                        (fun arg0  ->
259
                           Result.Ok { names = arg0; definition = arg1 })))
260
            | _::xs -> loop xs _state  in
261
          loop xs
262
            ((Result.Error "Vhdl_ast.vhdl_element_declaration_t.names"),
263
              (Result.Error "Vhdl_ast.vhdl_element_declaration_t.definition"))
264
      | _ -> Result.Error "Vhdl_ast.vhdl_element_declaration_t")
265
  [@ocaml.warning "-A"])
266

    
267
and (vhdl_subtype_indication_t_to_yojson :
268
      vhdl_subtype_indication_t -> Yojson.Safe.json)
269
  =
270
  ((let open! Ppx_deriving_yojson_runtime in
271
      fun x  ->
272
        let fields = []  in
273
        let fields =
274
          if x.const = NoConstraint
275
          then fields
276
          else
277
            ("const", (((fun x  -> vhdl_constraint_t_to_yojson x)) x.const))
278
            :: fields
279
           in
280
        let fields =
281
          if x.functionName = NoName
282
          then fields
283
          else
284
            ("functionName",
285
              (((fun x  -> vhdl_name_t_to_yojson x)) x.functionName))
286
            :: fields
287
           in
288
        let fields =
289
          if x.name = NoName
290
          then fields
291
          else ("name", (((fun x  -> vhdl_name_t_to_yojson x)) x.name)) ::
292
            fields
293
           in
294
        `Assoc fields)
295
  [@ocaml.warning "-A"])
296

    
297
and (vhdl_subtype_indication_t_of_yojson :
298
      Yojson.Safe.json ->
299
        vhdl_subtype_indication_t Ppx_deriving_yojson_runtime.error_or)
300
  =
301
  ((let open! Ppx_deriving_yojson_runtime in
302
      function
303
      | `Assoc xs ->
304
          let rec loop xs ((arg0,arg1,arg2) as _state) =
305
            match xs with
306
            | ("name",x)::xs ->
307
                loop xs (((fun x  -> vhdl_name_t_of_yojson x) x), arg1, arg2)
308
            | ("functionName",x)::xs ->
309
                loop xs (arg0, ((fun x  -> vhdl_name_t_of_yojson x) x), arg2)
310
            | ("const",x)::xs ->
311
                loop xs
312
                  (arg0, arg1, ((fun x  -> vhdl_constraint_t_of_yojson x) x))
313
            | [] ->
314
                arg2 >>=
315
                  ((fun arg2  ->
316
                      arg1 >>=
317
                        (fun arg1  ->
318
                           arg0 >>=
319
                             (fun arg0  ->
320
                                Result.Ok
321
                                  {
322
                                    name = arg0;
323
                                    functionName = arg1;
324
                                    const = arg2
325
                                  }))))
326
            | _::xs -> loop xs _state  in
327
          loop xs
328
            ((Result.Ok NoName), (Result.Ok NoName),
329
              (Result.Ok NoConstraint))
330
      | _ -> Result.Error "Vhdl_ast.vhdl_subtype_indication_t")
331
  [@ocaml.warning "-A"])
332

    
333
and (vhdl_discrete_range_t_to_yojson :
334
      vhdl_discrete_range_t -> Yojson.Safe.json)
335
  =
336
  ((let open! Ppx_deriving_yojson_runtime in
337
      function
338
      | SubDiscreteRange arg0 ->
339
          `List
340
            [`String "SUB_DISCRETE_RANGE";
341
            ((fun x  -> vhdl_subtype_indication_t_to_yojson x)) arg0]
342
      | NamedRange arg0 ->
343
          `List
344
            [`String "NAMED_RANGE";
345
            ((fun x  -> vhdl_name_t_to_yojson x)) arg0]
346
      | DirectedRange arg0 ->
347
          `List
348
            [`String "RANGE_WITH_DIRECTION";
349
            (let fields = []  in
350
             let fields =
351
               ("_to", ((fun x  -> vhdl_expr_t_to_yojson x) arg0._to)) ::
352
               fields  in
353
             let fields =
354
               ("from", ((fun x  -> vhdl_expr_t_to_yojson x) arg0.from)) ::
355
               fields  in
356
             let fields =
357
               ("direction",
358
                 ((fun (x : Ppx_deriving_runtime.string)  -> `String x)
359
                    arg0.direction))
360
               :: fields  in
361
             `Assoc fields)])
362
  [@ocaml.warning "-A"])
363

    
364
and (vhdl_discrete_range_t_of_yojson :
365
      Yojson.Safe.json ->
366
        vhdl_discrete_range_t Ppx_deriving_yojson_runtime.error_or)
367
  =
368
  ((let open! Ppx_deriving_yojson_runtime in
369
      function
370
      | `List ((`String "SUB_DISCRETE_RANGE")::arg0::[]) ->
371
          ((fun x  -> vhdl_subtype_indication_t_of_yojson x) arg0) >>=
372
            ((fun arg0  -> Result.Ok (SubDiscreteRange arg0)))
373
      | `List ((`String "NAMED_RANGE")::arg0::[]) ->
374
          ((fun x  -> vhdl_name_t_of_yojson x) arg0) >>=
375
            ((fun arg0  -> Result.Ok (NamedRange arg0)))
376
      | `List ((`String "RANGE_WITH_DIRECTION")::arg0::[]) ->
377
          ((function
378
            | `Assoc xs ->
379
                let rec loop xs ((arg0,arg1,arg2) as _state) =
380
                  match xs with
381
                  | ("direction",x)::xs ->
382
                      loop xs
383
                        (((function
384
                           | `String x -> Result.Ok x
385
                           | _ ->
386
                               Result.Error
387
                                 "Vhdl_ast.vhdl_discrete_range_t.direction")
388
                            x), arg1, arg2)
389
                  | ("from",x)::xs ->
390
                      loop xs
391
                        (arg0, ((fun x  -> vhdl_expr_t_of_yojson x) x), arg2)
392
                  | ("_to",x)::xs ->
393
                      loop xs
394
                        (arg0, arg1, ((fun x  -> vhdl_expr_t_of_yojson x) x))
395
                  | [] ->
396
                      arg2 >>=
397
                        ((fun arg2  ->
398
                            arg1 >>=
399
                              (fun arg1  ->
400
                                 arg0 >>=
401
                                   (fun arg0  ->
402
                                      Result.Ok
403
                                        (DirectedRange
404
                                           {
405
                                             direction = arg0;
406
                                             from = arg1;
407
                                             _to = arg2
408
                                           })))))
409
                  | _::xs -> loop xs _state  in
410
                loop xs
411
                  ((Result.Error "Vhdl_ast.vhdl_discrete_range_t.direction"),
412
                    (Result.Error "Vhdl_ast.vhdl_discrete_range_t.from"),
413
                    (Result.Error "Vhdl_ast.vhdl_discrete_range_t._to"))
414
            | _ -> Result.Error "Vhdl_ast.vhdl_discrete_range_t")) arg0
415
      | _ -> Result.Error "Vhdl_ast.vhdl_discrete_range_t")
416
  [@ocaml.warning "-A"])
417

    
418
and (vhdl_constraint_t_to_yojson : vhdl_constraint_t -> Yojson.Safe.json) =
419
  ((let open! Ppx_deriving_yojson_runtime in
420
      function
421
      | RefConstraint arg0 ->
422
          `List
423
            [`String "RefConstraint";
424
            (let fields = []  in
425
             let fields =
426
               ("ref_name",
427
                 ((fun x  -> vhdl_name_t_to_yojson x) arg0.ref_name))
428
               :: fields  in
429
             `Assoc fields)]
430
      | RangeConstraint arg0 ->
431
          `List
432
            [`String "RANGE_CONSTRAINT";
433
            (let fields = []  in
434
             let fields =
435
               ("range",
436
                 ((fun x  -> vhdl_discrete_range_t_to_yojson x) arg0.range))
437
               :: fields  in
438
             `Assoc fields)]
439
      | IndexConstraint arg0 ->
440
          `List
441
            [`String "INDEX_CONSTRAINT";
442
            (let fields = []  in
443
             let fields =
444
               ("ranges",
445
                 ((fun x  ->
446
                     `List
447
                       (List.map
448
                          (fun x  -> vhdl_discrete_range_t_to_yojson x) x))
449
                    arg0.ranges))
450
               :: fields  in
451
             `Assoc fields)]
452
      | ArrayConstraint arg0 ->
453
          `List
454
            [`String "ARRAY_CONSTRAINT";
455
            (let fields = []  in
456
             let fields =
457
               ("sub", ((fun x  -> vhdl_constraint_t_to_yojson x) arg0.sub))
458
               :: fields  in
459
             let fields =
460
               ("ranges",
461
                 ((fun x  ->
462
                     `List
463
                       (List.map
464
                          (fun x  -> vhdl_discrete_range_t_to_yojson x) x))
465
                    arg0.ranges))
466
               :: fields  in
467
             `Assoc fields)]
468
      | RecordConstraint  -> `List [`String "RecordConstraint"]
469
      | NoConstraint  -> `List [`String "NoConstraint"])
470
  [@ocaml.warning "-A"])
471

    
472
and (vhdl_constraint_t_of_yojson :
473
      Yojson.Safe.json ->
474
        vhdl_constraint_t Ppx_deriving_yojson_runtime.error_or)
475
  =
476
  ((let open! Ppx_deriving_yojson_runtime in
477
      function
478
      | `List ((`String "RefConstraint")::arg0::[]) ->
479
          ((function
480
            | `Assoc xs ->
481
                let rec loop xs (arg0 as _state) =
482
                  match xs with
483
                  | ("ref_name",x)::xs ->
484
                      loop xs ((fun x  -> vhdl_name_t_of_yojson x) x)
485
                  | [] ->
486
                      arg0 >>=
487
                        ((fun arg0  ->
488
                            Result.Ok (RefConstraint { ref_name = arg0 })))
489
                  | _::xs -> loop xs _state  in
490
                loop xs (Result.Error "Vhdl_ast.vhdl_constraint_t.ref_name")
491
            | _ -> Result.Error "Vhdl_ast.vhdl_constraint_t")) arg0
492
      | `List ((`String "RANGE_CONSTRAINT")::arg0::[]) ->
493
          ((function
494
            | `Assoc xs ->
495
                let rec loop xs (arg0 as _state) =
496
                  match xs with
497
                  | ("range",x)::xs ->
498
                      loop xs
499
                        ((fun x  -> vhdl_discrete_range_t_of_yojson x) x)
500
                  | [] ->
501
                      arg0 >>=
502
                        ((fun arg0  ->
503
                            Result.Ok (RangeConstraint { range = arg0 })))
504
                  | _::xs -> loop xs _state  in
505
                loop xs (Result.Error "Vhdl_ast.vhdl_constraint_t.range")
506
            | _ -> Result.Error "Vhdl_ast.vhdl_constraint_t")) arg0
507
      | `List ((`String "INDEX_CONSTRAINT")::arg0::[]) ->
508
          ((function
509
            | `Assoc xs ->
510
                let rec loop xs (arg0 as _state) =
511
                  match xs with
512
                  | ("ranges",x)::xs ->
513
                      loop xs
514
                        ((function
515
                          | `List xs ->
516
                              map_bind
517
                                (fun x  -> vhdl_discrete_range_t_of_yojson x)
518
                                [] xs
519
                          | _ ->
520
                              Result.Error
521
                                "Vhdl_ast.vhdl_constraint_t.ranges") x)
522
                  | [] ->
523
                      arg0 >>=
524
                        ((fun arg0  ->
525
                            Result.Ok (IndexConstraint { ranges = arg0 })))
526
                  | _::xs -> loop xs _state  in
527
                loop xs (Result.Error "Vhdl_ast.vhdl_constraint_t.ranges")
528
            | _ -> Result.Error "Vhdl_ast.vhdl_constraint_t")) arg0
529
      | `List ((`String "ARRAY_CONSTRAINT")::arg0::[]) ->
530
          ((function
531
            | `Assoc xs ->
532
                let rec loop xs ((arg0,arg1) as _state) =
533
                  match xs with
534
                  | ("ranges",x)::xs ->
535
                      loop xs
536
                        (((function
537
                           | `List xs ->
538
                               map_bind
539
                                 (fun x  -> vhdl_discrete_range_t_of_yojson x)
540
                                 [] xs
541
                           | _ ->
542
                               Result.Error
543
                                 "Vhdl_ast.vhdl_constraint_t.ranges") x),
544
                          arg1)
545
                  | ("sub",x)::xs ->
546
                      loop xs
547
                        (arg0, ((fun x  -> vhdl_constraint_t_of_yojson x) x))
548
                  | [] ->
549
                      arg1 >>=
550
                        ((fun arg1  ->
551
                            arg0 >>=
552
                              (fun arg0  ->
553
                                 Result.Ok
554
                                   (ArrayConstraint
555
                                      { ranges = arg0; sub = arg1 }))))
556
                  | _::xs -> loop xs _state  in
557
                loop xs
558
                  ((Result.Error "Vhdl_ast.vhdl_constraint_t.ranges"),
559
                    (Result.Error "Vhdl_ast.vhdl_constraint_t.sub"))
560
            | _ -> Result.Error "Vhdl_ast.vhdl_constraint_t")) arg0
561
      | `List ((`String "RecordConstraint")::[]) ->
562
          Result.Ok RecordConstraint
563
      | `List ((`String "NoConstraint")::[]) -> Result.Ok NoConstraint
564
      | _ -> Result.Error "Vhdl_ast.vhdl_constraint_t")
565
  [@ocaml.warning "-A"])
566

    
567
and (vhdl_definition_t_to_yojson : vhdl_definition_t -> Yojson.Safe.json) =
568
  ((let open! Ppx_deriving_yojson_runtime in
569
      function
570
      | Type arg0 ->
571
          `List
572
            [`String "TYPE_DECLARATION";
573
            (let fields = []  in
574
             let fields =
575
               ("definition",
576
                 ((fun x  -> vhdl_type_t_to_yojson x) arg0.definition))
577
               :: fields  in
578
             let fields =
579
               ("name", ((fun x  -> vhdl_name_t_to_yojson x) arg0.name)) ::
580
               fields  in
581
             `Assoc fields)]
582
      | Subtype arg0 ->
583
          `List
584
            [`String "SUBTYPE_DECLARATION";
585
            (let fields = []  in
586
             let fields =
587
               ("typ",
588
                 ((fun x  -> vhdl_subtype_indication_t_to_yojson x) arg0.typ))
589
               :: fields  in
590
             let fields =
591
               ("name", ((fun x  -> vhdl_name_t_to_yojson x) arg0.name)) ::
592
               fields  in
593
             `Assoc fields)])
594
  [@ocaml.warning "-A"])
595

    
596
and (vhdl_definition_t_of_yojson :
597
      Yojson.Safe.json ->
598
        vhdl_definition_t Ppx_deriving_yojson_runtime.error_or)
599
  =
600
  ((let open! Ppx_deriving_yojson_runtime in
601
      function
602
      | `List ((`String "TYPE_DECLARATION")::arg0::[]) ->
603
          ((function
604
            | `Assoc xs ->
605
                let rec loop xs ((arg0,arg1) as _state) =
606
                  match xs with
607
                  | ("name",x)::xs ->
608
                      loop xs (((fun x  -> vhdl_name_t_of_yojson x) x), arg1)
609
                  | ("definition",x)::xs ->
610
                      loop xs (arg0, ((fun x  -> vhdl_type_t_of_yojson x) x))
611
                  | [] ->
612
                      arg1 >>=
613
                        ((fun arg1  ->
614
                            arg0 >>=
615
                              (fun arg0  ->
616
                                 Result.Ok
617
                                   (Type { name = arg0; definition = arg1 }))))
618
                  | _::xs -> loop xs _state  in
619
                loop xs
620
                  ((Result.Error "Vhdl_ast.vhdl_definition_t.name"),
621
                    (Result.Error "Vhdl_ast.vhdl_definition_t.definition"))
622
            | _ -> Result.Error "Vhdl_ast.vhdl_definition_t")) arg0
623
      | `List ((`String "SUBTYPE_DECLARATION")::arg0::[]) ->
624
          ((function
625
            | `Assoc xs ->
626
                let rec loop xs ((arg0,arg1) as _state) =
627
                  match xs with
628
                  | ("name",x)::xs ->
629
                      loop xs (((fun x  -> vhdl_name_t_of_yojson x) x), arg1)
630
                  | ("typ",x)::xs ->
631
                      loop xs
632
                        (arg0,
633
                          ((fun x  -> vhdl_subtype_indication_t_of_yojson x)
634
                             x))
635
                  | [] ->
636
                      arg1 >>=
637
                        ((fun arg1  ->
638
                            arg0 >>=
639
                              (fun arg0  ->
640
                                 Result.Ok
641
                                   (Subtype { name = arg0; typ = arg1 }))))
642
                  | _::xs -> loop xs _state  in
643
                loop xs
644
                  ((Result.Error "Vhdl_ast.vhdl_definition_t.name"),
645
                    (Result.Error "Vhdl_ast.vhdl_definition_t.typ"))
646
            | _ -> Result.Error "Vhdl_ast.vhdl_definition_t")) arg0
647
      | _ -> Result.Error "Vhdl_ast.vhdl_definition_t")
648
  [@ocaml.warning "-A"])
649

    
650
and (vhdl_expr_t_to_yojson : vhdl_expr_t -> Yojson.Safe.json) =
651
  ((let open! Ppx_deriving_yojson_runtime in
652
      function
653
      | Call arg0 ->
654
          `List [`String "CALL"; ((fun x  -> vhdl_name_t_to_yojson x)) arg0]
655
      | Cst arg0 ->
656
          `List
657
            [`String "CONSTANT_VALUE";
658
            (let fields = []  in
659
             let fields =
660
               if arg0.unit_name = None
661
               then fields
662
               else
663
                 ("unit_name",
664
                   (((function
665
                      | None  -> `Null
666
                      | Some x -> ((fun x  -> vhdl_name_t_to_yojson x)) x))
667
                      arg0.unit_name))
668
                 :: fields
669
                in
670
             let fields =
671
               ("value", ((fun x  -> vhdl_cst_val_t_to_yojson x) arg0.value))
672
               :: fields  in
673
             `Assoc fields)]
674
      | Op arg0 ->
675
          `List
676
            [`String "EXPRESSION";
677
            (let fields = []  in
678
             let fields =
679
               if arg0.args = []
680
               then fields
681
               else
682
                 ("args",
683
                   (((fun x  ->
684
                        `List
685
                          (List.map (fun x  -> vhdl_expr_t_to_yojson x) x)))
686
                      arg0.args))
687
                 :: fields
688
                in
689
             let fields =
690
               if arg0.id = ""
691
               then fields
692
               else
693
                 ("id",
694
                   (((fun (x : Ppx_deriving_runtime.string)  -> `String x))
695
                      arg0.id))
696
                 :: fields
697
                in
698
             `Assoc fields)]
699
      | IsNull  -> `List [`String "IsNull"]
700
      | Time arg0 ->
701
          `List
702
            [`String "Time";
703
            (let fields = []  in
704
             let fields =
705
               if arg0.phy_unit = ""
706
               then fields
707
               else
708
                 ("phy_unit",
709
                   (((fun (x : Ppx_deriving_runtime.string)  -> `String x))
710
                      arg0.phy_unit))
711
                 :: fields
712
                in
713
             let fields =
714
               ("value",
715
                 ((fun (x : Ppx_deriving_runtime.int)  -> `Int x) arg0.value))
716
               :: fields  in
717
             `Assoc fields)]
718
      | Sig arg0 ->
719
          `List
720
            [`String "Sig";
721
            (let fields = []  in
722
             let fields =
723
               if arg0.att = None
724
               then fields
725
               else
726
                 ("att",
727
                   (((function
728
                      | None  -> `Null
729
                      | Some x ->
730
                          ((fun x  -> vhdl_signal_attributes_t_to_yojson x))
731
                            x)) arg0.att))
732
                 :: fields
733
                in
734
             let fields =
735
               ("name", ((fun x  -> vhdl_name_t_to_yojson x) arg0.name)) ::
736
               fields  in
737
             `Assoc fields)]
738
      | SuffixMod arg0 ->
739
          `List
740
            [`String "SuffixMod";
741
            (let fields = []  in
742
             let fields =
743
               ("selection",
744
                 ((fun x  -> vhdl_suffix_selection_t_to_yojson x)
745
                    arg0.selection))
746
               :: fields  in
747
             let fields =
748
               ("expr", ((fun x  -> vhdl_expr_t_to_yojson x) arg0.expr)) ::
749
               fields  in
750
             `Assoc fields)]
751
      | Aggregate arg0 ->
752
          `List
753
            [`String "AGGREGATE";
754
            (let fields = []  in
755
             let fields =
756
               if arg0.elems = []
757
               then fields
758
               else
759
                 ("elems",
760
                   (((fun x  ->
761
                        `List
762
                          (List.map
763
                             (fun x  -> vhdl_element_assoc_t_to_yojson x) x)))
764
                      arg0.elems))
765
                 :: fields
766
                in
767
             `Assoc fields)]
768
      | QualifiedExpression arg0 ->
769
          `List
770
            [`String "QUALIFIED_EXPRESSION";
771
            (let fields = []  in
772
             let fields =
773
               if arg0.expression = None
774
               then fields
775
               else
776
                 ("expression",
777
                   (((function
778
                      | None  -> `Null
779
                      | Some x -> ((fun x  -> vhdl_expr_t_to_yojson x)) x))
780
                      arg0.expression))
781
                 :: fields
782
                in
783
             let fields =
784
               if arg0.aggregate = []
785
               then fields
786
               else
787
                 ("aggregate",
788
                   (((fun x  ->
789
                        `List
790
                          (List.map
791
                             (fun x  -> vhdl_element_assoc_t_to_yojson x) x)))
792
                      arg0.aggregate))
793
                 :: fields
794
                in
795
             let fields =
796
               ("type_mark",
797
                 ((fun x  -> vhdl_name_t_to_yojson x) arg0.type_mark))
798
               :: fields  in
799
             `Assoc fields)]
800
      | Others  -> `List [`String "OTHERS"])
801
  [@ocaml.warning "-A"])
802

    
803
and (vhdl_expr_t_of_yojson :
804
      Yojson.Safe.json -> vhdl_expr_t Ppx_deriving_yojson_runtime.error_or)
805
  =
806
  ((let open! Ppx_deriving_yojson_runtime in
807
      function
808
      | `List ((`String "CALL")::arg0::[]) ->
809
          ((fun x  -> vhdl_name_t_of_yojson x) arg0) >>=
810
            ((fun arg0  -> Result.Ok (Call arg0)))
811
      | `List ((`String "CONSTANT_VALUE")::arg0::[]) ->
812
          ((function
813
            | `Assoc xs ->
814
                let rec loop xs ((arg0,arg1) as _state) =
815
                  match xs with
816
                  | ("value",x)::xs ->
817
                      loop xs
818
                        (((fun x  -> vhdl_cst_val_t_of_yojson x) x), arg1)
819
                  | ("unit_name",x)::xs ->
820
                      loop xs
821
                        (arg0,
822
                          ((function
823
                            | `Null -> Result.Ok None
824
                            | x ->
825
                                ((fun x  -> vhdl_name_t_of_yojson x) x) >>=
826
                                  ((fun x  -> Result.Ok (Some x)))) x))
827
                  | [] ->
828
                      arg1 >>=
829
                        ((fun arg1  ->
830
                            arg0 >>=
831
                              (fun arg0  ->
832
                                 Result.Ok
833
                                   (Cst { value = arg0; unit_name = arg1 }))))
834
                  | _::xs -> loop xs _state  in
835
                loop xs
836
                  ((Result.Error "Vhdl_ast.vhdl_expr_t.value"),
837
                    (Result.Ok None))
838
            | _ -> Result.Error "Vhdl_ast.vhdl_expr_t")) arg0
839
      | `List ((`String "EXPRESSION")::arg0::[]) ->
840
          ((function
841
            | `Assoc xs ->
842
                let rec loop xs ((arg0,arg1) as _state) =
843
                  match xs with
844
                  | ("id",x)::xs ->
845
                      loop xs
846
                        (((function
847
                           | `String x -> Result.Ok x
848
                           | _ -> Result.Error "Vhdl_ast.vhdl_expr_t.id") x),
849
                          arg1)
850
                  | ("args",x)::xs ->
851
                      loop xs
852
                        (arg0,
853
                          ((function
854
                            | `List xs ->
855
                                map_bind (fun x  -> vhdl_expr_t_of_yojson x)
856
                                  [] xs
857
                            | _ -> Result.Error "Vhdl_ast.vhdl_expr_t.args")
858
                             x))
859
                  | [] ->
860
                      arg1 >>=
861
                        ((fun arg1  ->
862
                            arg0 >>=
863
                              (fun arg0  ->
864
                                 Result.Ok (Op { id = arg0; args = arg1 }))))
865
                  | _::xs -> loop xs _state  in
866
                loop xs ((Result.Ok ""), (Result.Ok []))
867
            | _ -> Result.Error "Vhdl_ast.vhdl_expr_t")) arg0
868
      | `List ((`String "IsNull")::[]) -> Result.Ok IsNull
869
      | `List ((`String "Time")::arg0::[]) ->
870
          ((function
871
            | `Assoc xs ->
872
                let rec loop xs ((arg0,arg1) as _state) =
873
                  match xs with
874
                  | ("value",x)::xs ->
875
                      loop xs
876
                        (((function
877
                           | `Int x -> Result.Ok x
878
                           | _ -> Result.Error "Vhdl_ast.vhdl_expr_t.value")
879
                            x), arg1)
880
                  | ("phy_unit",x)::xs ->
881
                      loop xs
882
                        (arg0,
883
                          ((function
884
                            | `String x -> Result.Ok x
885
                            | _ ->
886
                                Result.Error "Vhdl_ast.vhdl_expr_t.phy_unit")
887
                             x))
888
                  | [] ->
889
                      arg1 >>=
890
                        ((fun arg1  ->
891
                            arg0 >>=
892
                              (fun arg0  ->
893
                                 Result.Ok
894
                                   (Time { value = arg0; phy_unit = arg1 }))))
895
                  | _::xs -> loop xs _state  in
896
                loop xs
897
                  ((Result.Error "Vhdl_ast.vhdl_expr_t.value"),
898
                    (Result.Ok ""))
899
            | _ -> Result.Error "Vhdl_ast.vhdl_expr_t")) arg0
900
      | `List ((`String "Sig")::arg0::[]) ->
901
          ((function
902
            | `Assoc xs ->
903
                let rec loop xs ((arg0,arg1) as _state) =
904
                  match xs with
905
                  | ("name",x)::xs ->
906
                      loop xs (((fun x  -> vhdl_name_t_of_yojson x) x), arg1)
907
                  | ("att",x)::xs ->
908
                      loop xs
909
                        (arg0,
910
                          ((function
911
                            | `Null -> Result.Ok None
912
                            | x ->
913
                                ((fun x  ->
914
                                    vhdl_signal_attributes_t_of_yojson x) x)
915
                                  >>= ((fun x  -> Result.Ok (Some x)))) x))
916
                  | [] ->
917
                      arg1 >>=
918
                        ((fun arg1  ->
919
                            arg0 >>=
920
                              (fun arg0  ->
921
                                 Result.Ok (Sig { name = arg0; att = arg1 }))))
922
                  | _::xs -> loop xs _state  in
923
                loop xs
924
                  ((Result.Error "Vhdl_ast.vhdl_expr_t.name"),
925
                    (Result.Ok None))
926
            | _ -> Result.Error "Vhdl_ast.vhdl_expr_t")) arg0
927
      | `List ((`String "SuffixMod")::arg0::[]) ->
928
          ((function
929
            | `Assoc xs ->
930
                let rec loop xs ((arg0,arg1) as _state) =
931
                  match xs with
932
                  | ("expr",x)::xs ->
933
                      loop xs (((fun x  -> vhdl_expr_t_of_yojson x) x), arg1)
934
                  | ("selection",x)::xs ->
935
                      loop xs
936
                        (arg0,
937
                          ((fun x  -> vhdl_suffix_selection_t_of_yojson x) x))
938
                  | [] ->
939
                      arg1 >>=
940
                        ((fun arg1  ->
941
                            arg0 >>=
942
                              (fun arg0  ->
943
                                 Result.Ok
944
                                   (SuffixMod
945
                                      { expr = arg0; selection = arg1 }))))
946
                  | _::xs -> loop xs _state  in
947
                loop xs
948
                  ((Result.Error "Vhdl_ast.vhdl_expr_t.expr"),
949
                    (Result.Error "Vhdl_ast.vhdl_expr_t.selection"))
950
            | _ -> Result.Error "Vhdl_ast.vhdl_expr_t")) arg0
951
      | `List ((`String "AGGREGATE")::arg0::[]) ->
952
          ((function
953
            | `Assoc xs ->
954
                let rec loop xs (arg0 as _state) =
955
                  match xs with
956
                  | ("elems",x)::xs ->
957
                      loop xs
958
                        ((function
959
                          | `List xs ->
960
                              map_bind
961
                                (fun x  -> vhdl_element_assoc_t_of_yojson x)
962
                                [] xs
963
                          | _ -> Result.Error "Vhdl_ast.vhdl_expr_t.elems") x)
964
                  | [] ->
965
                      arg0 >>=
966
                        ((fun arg0  -> Result.Ok (Aggregate { elems = arg0 })))
967
                  | _::xs -> loop xs _state  in
968
                loop xs (Result.Ok [])
969
            | _ -> Result.Error "Vhdl_ast.vhdl_expr_t")) arg0
970
      | `List ((`String "QUALIFIED_EXPRESSION")::arg0::[]) ->
971
          ((function
972
            | `Assoc xs ->
973
                let rec loop xs ((arg0,arg1,arg2) as _state) =
974
                  match xs with
975
                  | ("type_mark",x)::xs ->
976
                      loop xs
977
                        (((fun x  -> vhdl_name_t_of_yojson x) x), arg1, arg2)
978
                  | ("aggregate",x)::xs ->
979
                      loop xs
980
                        (arg0,
981
                          ((function
982
                            | `List xs ->
983
                                map_bind
984
                                  (fun x  -> vhdl_element_assoc_t_of_yojson x)
985
                                  [] xs
986
                            | _ ->
987
                                Result.Error "Vhdl_ast.vhdl_expr_t.aggregate")
988
                             x), arg2)
989
                  | ("expression",x)::xs ->
990
                      loop xs
991
                        (arg0, arg1,
992
                          ((function
993
                            | `Null -> Result.Ok None
994
                            | x ->
995
                                ((fun x  -> vhdl_expr_t_of_yojson x) x) >>=
996
                                  ((fun x  -> Result.Ok (Some x)))) x))
997
                  | [] ->
998
                      arg2 >>=
999
                        ((fun arg2  ->
1000
                            arg1 >>=
1001
                              (fun arg1  ->
1002
                                 arg0 >>=
1003
                                   (fun arg0  ->
1004
                                      Result.Ok
1005
                                        (QualifiedExpression
1006
                                           {
1007
                                             type_mark = arg0;
1008
                                             aggregate = arg1;
1009
                                             expression = arg2
1010
                                           })))))
1011
                  | _::xs -> loop xs _state  in
1012
                loop xs
1013
                  ((Result.Error "Vhdl_ast.vhdl_expr_t.type_mark"),
1014
                    (Result.Ok []), (Result.Ok None))
1015
            | _ -> Result.Error "Vhdl_ast.vhdl_expr_t")) arg0
1016
      | `List ((`String "OTHERS")::[]) -> Result.Ok Others
1017
      | _ -> Result.Error "Vhdl_ast.vhdl_expr_t")
1018
  [@ocaml.warning "-A"])
1019

    
1020
and (vhdl_name_t_to_yojson : vhdl_name_t -> Yojson.Safe.json) =
1021
  ((let open! Ppx_deriving_yojson_runtime in
1022
      function
1023
      | Simple arg0 ->
1024
          `List
1025
            [`String "SIMPLE_NAME";
1026
            ((fun (x : Ppx_deriving_runtime.string)  -> `String x)) arg0]
1027
      | Identifier arg0 ->
1028
          `List
1029
            [`String "IDENTIFIER";
1030
            ((fun (x : Ppx_deriving_runtime.string)  -> `String x)) arg0]
1031
      | Selected arg0 ->
1032
          `List
1033
            [`String "SELECTED_NAME";
1034
            ((fun x  ->
1035
                `List (List.map (fun x  -> vhdl_name_t_to_yojson x) x))) arg0]
1036
      | Index arg0 ->
1037
          `List
1038
            [`String "INDEXED_NAME";
1039
            (let fields = []  in
1040
             let fields =
1041
               ("exprs",
1042
                 ((fun x  ->
1043
                     `List (List.map (fun x  -> vhdl_expr_t_to_yojson x) x))
1044
                    arg0.exprs))
1045
               :: fields  in
1046
             let fields =
1047
               ("id", ((fun x  -> vhdl_name_t_to_yojson x) arg0.id)) ::
1048
               fields  in
1049
             `Assoc fields)]
1050
      | Slice arg0 ->
1051
          `List
1052
            [`String "SLICE_NAME";
1053
            (let fields = []  in
1054
             let fields =
1055
               ("range",
1056
                 ((fun x  -> vhdl_discrete_range_t_to_yojson x) arg0.range))
1057
               :: fields  in
1058
             let fields =
1059
               ("id", ((fun x  -> vhdl_name_t_to_yojson x) arg0.id)) ::
1060
               fields  in
1061
             `Assoc fields)]
1062
      | Attribute arg0 ->
1063
          `List
1064
            [`String "ATTRIBUTE_NAME";
1065
            (let fields = []  in
1066
             let fields =
1067
               if arg0.expr = IsNull
1068
               then fields
1069
               else
1070
                 ("expr", (((fun x  -> vhdl_expr_t_to_yojson x)) arg0.expr))
1071
                 :: fields
1072
                in
1073
             let fields =
1074
               ("designator",
1075
                 ((fun x  -> vhdl_name_t_to_yojson x) arg0.designator))
1076
               :: fields  in
1077
             let fields =
1078
               ("id", ((fun x  -> vhdl_name_t_to_yojson x) arg0.id)) ::
1079
               fields  in
1080
             `Assoc fields)]
1081
      | Function arg0 ->
1082
          `List
1083
            [`String "FUNCTION_CALL";
1084
            (let fields = []  in
1085
             let fields =
1086
               ("assoc_list",
1087
                 ((fun x  ->
1088
                     `List
1089
                       (List.map (fun x  -> vhdl_assoc_element_t_to_yojson x)
1090
                          x)) arg0.assoc_list))
1091
               :: fields  in
1092
             let fields =
1093
               ("id", ((fun x  -> vhdl_name_t_to_yojson x) arg0.id)) ::
1094
               fields  in
1095
             `Assoc fields)]
1096
      | NoName  -> `List [`String "NoName"])
1097
  [@ocaml.warning "-A"])
1098

    
1099
and (vhdl_name_t_of_yojson :
1100
      Yojson.Safe.json -> vhdl_name_t Ppx_deriving_yojson_runtime.error_or)
1101
  =
1102
  ((let open! Ppx_deriving_yojson_runtime in
1103
      function
1104
      | `List ((`String "SIMPLE_NAME")::arg0::[]) ->
1105
          ((function
1106
            | `String x -> Result.Ok x
1107
            | _ -> Result.Error "Vhdl_ast.vhdl_name_t") arg0) >>=
1108
            ((fun arg0  -> Result.Ok (Simple arg0)))
1109
      | `List ((`String "IDENTIFIER")::arg0::[]) ->
1110
          ((function
1111
            | `String x -> Result.Ok x
1112
            | _ -> Result.Error "Vhdl_ast.vhdl_name_t") arg0) >>=
1113
            ((fun arg0  -> Result.Ok (Identifier arg0)))
1114
      | `List ((`String "SELECTED_NAME")::arg0::[]) ->
1115
          ((function
1116
            | `List xs -> map_bind (fun x  -> vhdl_name_t_of_yojson x) [] xs
1117
            | _ -> Result.Error "Vhdl_ast.vhdl_name_t") arg0) >>=
1118
            ((fun arg0  -> Result.Ok (Selected arg0)))
1119
      | `List ((`String "INDEXED_NAME")::arg0::[]) ->
1120
          ((function
1121
            | `Assoc xs ->
1122
                let rec loop xs ((arg0,arg1) as _state) =
1123
                  match xs with
1124
                  | ("id",x)::xs ->
1125
                      loop xs (((fun x  -> vhdl_name_t_of_yojson x) x), arg1)
1126
                  | ("exprs",x)::xs ->
1127
                      loop xs
1128
                        (arg0,
1129
                          ((function
1130
                            | `List xs ->
1131
                                map_bind (fun x  -> vhdl_expr_t_of_yojson x)
1132
                                  [] xs
1133
                            | _ -> Result.Error "Vhdl_ast.vhdl_name_t.exprs")
1134
                             x))
1135
                  | [] ->
1136
                      arg1 >>=
1137
                        ((fun arg1  ->
1138
                            arg0 >>=
1139
                              (fun arg0  ->
1140
                                 Result.Ok
1141
                                   (Index { id = arg0; exprs = arg1 }))))
1142
                  | _::xs -> loop xs _state  in
1143
                loop xs
1144
                  ((Result.Error "Vhdl_ast.vhdl_name_t.id"),
1145
                    (Result.Error "Vhdl_ast.vhdl_name_t.exprs"))
1146
            | _ -> Result.Error "Vhdl_ast.vhdl_name_t")) arg0
1147
      | `List ((`String "SLICE_NAME")::arg0::[]) ->
1148
          ((function
1149
            | `Assoc xs ->
1150
                let rec loop xs ((arg0,arg1) as _state) =
1151
                  match xs with
1152
                  | ("id",x)::xs ->
1153
                      loop xs (((fun x  -> vhdl_name_t_of_yojson x) x), arg1)
1154
                  | ("range",x)::xs ->
1155
                      loop xs
1156
                        (arg0,
1157
                          ((fun x  -> vhdl_discrete_range_t_of_yojson x) x))
1158
                  | [] ->
1159
                      arg1 >>=
1160
                        ((fun arg1  ->
1161
                            arg0 >>=
1162
                              (fun arg0  ->
1163
                                 Result.Ok
1164
                                   (Slice { id = arg0; range = arg1 }))))
1165
                  | _::xs -> loop xs _state  in
1166
                loop xs
1167
                  ((Result.Error "Vhdl_ast.vhdl_name_t.id"),
1168
                    (Result.Error "Vhdl_ast.vhdl_name_t.range"))
1169
            | _ -> Result.Error "Vhdl_ast.vhdl_name_t")) arg0
1170
      | `List ((`String "ATTRIBUTE_NAME")::arg0::[]) ->
1171
          ((function
1172
            | `Assoc xs ->
1173
                let rec loop xs ((arg0,arg1,arg2) as _state) =
1174
                  match xs with
1175
                  | ("id",x)::xs ->
1176
                      loop xs
1177
                        (((fun x  -> vhdl_name_t_of_yojson x) x), arg1, arg2)
1178
                  | ("designator",x)::xs ->
1179
                      loop xs
1180
                        (arg0, ((fun x  -> vhdl_name_t_of_yojson x) x), arg2)
1181
                  | ("expr",x)::xs ->
1182
                      loop xs
1183
                        (arg0, arg1, ((fun x  -> vhdl_expr_t_of_yojson x) x))
1184
                  | [] ->
1185
                      arg2 >>=
1186
                        ((fun arg2  ->
1187
                            arg1 >>=
1188
                              (fun arg1  ->
1189
                                 arg0 >>=
1190
                                   (fun arg0  ->
1191
                                      Result.Ok
1192
                                        (Attribute
1193
                                           {
1194
                                             id = arg0;
1195
                                             designator = arg1;
1196
                                             expr = arg2
1197
                                           })))))
1198
                  | _::xs -> loop xs _state  in
1199
                loop xs
1200
                  ((Result.Error "Vhdl_ast.vhdl_name_t.id"),
1201
                    (Result.Error "Vhdl_ast.vhdl_name_t.designator"),
1202
                    (Result.Ok IsNull))
1203
            | _ -> Result.Error "Vhdl_ast.vhdl_name_t")) arg0
1204
      | `List ((`String "FUNCTION_CALL")::arg0::[]) ->
1205
          ((function
1206
            | `Assoc xs ->
1207
                let rec loop xs ((arg0,arg1) as _state) =
1208
                  match xs with
1209
                  | ("id",x)::xs ->
1210
                      loop xs (((fun x  -> vhdl_name_t_of_yojson x) x), arg1)
1211
                  | ("assoc_list",x)::xs ->
1212
                      loop xs
1213
                        (arg0,
1214
                          ((function
1215
                            | `List xs ->
1216
                                map_bind
1217
                                  (fun x  -> vhdl_assoc_element_t_of_yojson x)
1218
                                  [] xs
1219
                            | _ ->
1220
                                Result.Error
1221
                                  "Vhdl_ast.vhdl_name_t.assoc_list") x))
1222
                  | [] ->
1223
                      arg1 >>=
1224
                        ((fun arg1  ->
1225
                            arg0 >>=
1226
                              (fun arg0  ->
1227
                                 Result.Ok
1228
                                   (Function { id = arg0; assoc_list = arg1 }))))
1229
                  | _::xs -> loop xs _state  in
1230
                loop xs
1231
                  ((Result.Error "Vhdl_ast.vhdl_name_t.id"),
1232
                    (Result.Error "Vhdl_ast.vhdl_name_t.assoc_list"))
1233
            | _ -> Result.Error "Vhdl_ast.vhdl_name_t")) arg0
1234
      | `List ((`String "NoName")::[]) -> Result.Ok NoName
1235
      | _ -> Result.Error "Vhdl_ast.vhdl_name_t")
1236
  [@ocaml.warning "-A"])
1237

    
1238
and (vhdl_assoc_element_t_to_yojson :
1239
      vhdl_assoc_element_t -> Yojson.Safe.json)
1240
  =
1241
  ((let open! Ppx_deriving_yojson_runtime in
1242
      fun x  ->
1243
        let fields = []  in
1244
        let fields =
1245
          if x.actual_expr = None
1246
          then fields
1247
          else
1248
            ("actual_expr",
1249
              (((function
1250
                 | None  -> `Null
1251
                 | Some x -> ((fun x  -> vhdl_expr_t_to_yojson x)) x))
1252
                 x.actual_expr))
1253
            :: fields
1254
           in
1255
        let fields =
1256
          if x.actual_designator = None
1257
          then fields
1258
          else
1259
            ("actual_designator",
1260
              (((function
1261
                 | None  -> `Null
1262
                 | Some x -> ((fun x  -> vhdl_name_t_to_yojson x)) x))
1263
                 x.actual_designator))
1264
            :: fields
1265
           in
1266
        let fields =
1267
          if x.actual_name = None
1268
          then fields
1269
          else
1270
            ("actual_name",
1271
              (((function
1272
                 | None  -> `Null
1273
                 | Some x -> ((fun x  -> vhdl_name_t_to_yojson x)) x))
1274
                 x.actual_name))
1275
            :: fields
1276
           in
1277
        let fields =
1278
          if x.formal_arg = None
1279
          then fields
1280
          else
1281
            ("formal_arg",
1282
              (((function
1283
                 | None  -> `Null
1284
                 | Some x -> ((fun x  -> vhdl_name_t_to_yojson x)) x))
1285
                 x.formal_arg))
1286
            :: fields
1287
           in
1288
        let fields =
1289
          if x.formal_name = None
1290
          then fields
1291
          else
1292
            ("formal_name",
1293
              (((function
1294
                 | None  -> `Null
1295
                 | Some x -> ((fun x  -> vhdl_name_t_to_yojson x)) x))
1296
                 x.formal_name))
1297
            :: fields
1298
           in
1299
        `Assoc fields)
1300
  [@ocaml.warning "-A"])
1301

    
1302
and (vhdl_assoc_element_t_of_yojson :
1303
      Yojson.Safe.json ->
1304
        vhdl_assoc_element_t Ppx_deriving_yojson_runtime.error_or)
1305
  =
1306
  ((let open! Ppx_deriving_yojson_runtime in
1307
      function
1308
      | `Assoc xs ->
1309
          let rec loop xs ((arg0,arg1,arg2,arg3,arg4) as _state) =
1310
            match xs with
1311
            | ("formal_name",x)::xs ->
1312
                loop xs
1313
                  (((function
1314
                     | `Null -> Result.Ok None
1315
                     | x ->
1316
                         ((fun x  -> vhdl_name_t_of_yojson x) x) >>=
1317
                           ((fun x  -> Result.Ok (Some x)))) x), arg1, arg2,
1318
                    arg3, arg4)
1319
            | ("formal_arg",x)::xs ->
1320
                loop xs
1321
                  (arg0,
1322
                    ((function
1323
                      | `Null -> Result.Ok None
1324
                      | x ->
1325
                          ((fun x  -> vhdl_name_t_of_yojson x) x) >>=
1326
                            ((fun x  -> Result.Ok (Some x)))) x), arg2, arg3,
1327
                    arg4)
1328
            | ("actual_name",x)::xs ->
1329
                loop xs
1330
                  (arg0, arg1,
1331
                    ((function
1332
                      | `Null -> Result.Ok None
1333
                      | x ->
1334
                          ((fun x  -> vhdl_name_t_of_yojson x) x) >>=
1335
                            ((fun x  -> Result.Ok (Some x)))) x), arg3, arg4)
1336
            | ("actual_designator",x)::xs ->
1337
                loop xs
1338
                  (arg0, arg1, arg2,
1339
                    ((function
1340
                      | `Null -> Result.Ok None
1341
                      | x ->
1342
                          ((fun x  -> vhdl_name_t_of_yojson x) x) >>=
1343
                            ((fun x  -> Result.Ok (Some x)))) x), arg4)
1344
            | ("actual_expr",x)::xs ->
1345
                loop xs
1346
                  (arg0, arg1, arg2, arg3,
1347
                    ((function
1348
                      | `Null -> Result.Ok None
1349
                      | x ->
1350
                          ((fun x  -> vhdl_expr_t_of_yojson x) x) >>=
1351
                            ((fun x  -> Result.Ok (Some x)))) x))
1352
            | [] ->
1353
                arg4 >>=
1354
                  ((fun arg4  ->
1355
                      arg3 >>=
1356
                        (fun arg3  ->
1357
                           arg2 >>=
1358
                             (fun arg2  ->
1359
                                arg1 >>=
1360
                                  (fun arg1  ->
1361
                                     arg0 >>=
1362
                                       (fun arg0  ->
1363
                                          Result.Ok
1364
                                            {
1365
                                              formal_name = arg0;
1366
                                              formal_arg = arg1;
1367
                                              actual_name = arg2;
1368
                                              actual_designator = arg3;
1369
                                              actual_expr = arg4
1370
                                            }))))))
1371
            | _::xs -> loop xs _state  in
1372
          loop xs
1373
            ((Result.Ok (Some NoName)), (Result.Ok (Some NoName)),
1374
              (Result.Ok (Some NoName)), (Result.Ok (Some NoName)),
1375
              (Result.Ok (Some IsNull)))
1376
      | _ -> Result.Error "Vhdl_ast.vhdl_assoc_element_t")
1377
  [@ocaml.warning "-A"])
1378

    
1379
and (vhdl_element_assoc_t_to_yojson :
1380
      vhdl_element_assoc_t -> Yojson.Safe.json)
1381
  =
1382
  ((let open! Ppx_deriving_yojson_runtime in
1383
      fun x  ->
1384
        let fields = []  in
1385
        let fields = ("expr", ((fun x  -> vhdl_expr_t_to_yojson x) x.expr))
1386
          :: fields  in
1387
        let fields =
1388
          if x.choices = []
1389
          then fields
1390
          else
1391
            ("choices",
1392
              (((fun x  ->
1393
                   `List (List.map (fun x  -> vhdl_expr_t_to_yojson x) x)))
1394
                 x.choices))
1395
            :: fields
1396
           in
1397
        `Assoc fields)
1398
  [@ocaml.warning "-A"])
1399

    
1400
and (vhdl_element_assoc_t_of_yojson :
1401
      Yojson.Safe.json ->
1402
        vhdl_element_assoc_t Ppx_deriving_yojson_runtime.error_or)
1403
  =
1404
  ((let open! Ppx_deriving_yojson_runtime in
1405
      function
1406
      | `Assoc xs ->
1407
          let rec loop xs ((arg0,arg1) as _state) =
1408
            match xs with
1409
            | ("choices",x)::xs ->
1410
                loop xs
1411
                  (((function
1412
                     | `List xs ->
1413
                         map_bind (fun x  -> vhdl_expr_t_of_yojson x) [] xs
1414
                     | _ ->
1415
                         Result.Error "Vhdl_ast.vhdl_element_assoc_t.choices")
1416
                      x), arg1)
1417
            | ("expr",x)::xs ->
1418
                loop xs (arg0, ((fun x  -> vhdl_expr_t_of_yojson x) x))
1419
            | [] ->
1420
                arg1 >>=
1421
                  ((fun arg1  ->
1422
                      arg0 >>=
1423
                        (fun arg0  ->
1424
                           Result.Ok { choices = arg0; expr = arg1 })))
1425
            | _::xs -> loop xs _state  in
1426
          loop xs
1427
            ((Result.Ok []),
1428
              (Result.Error "Vhdl_ast.vhdl_element_assoc_t.expr"))
1429
      | _ -> Result.Error "Vhdl_ast.vhdl_element_assoc_t")
1430
  [@ocaml.warning "-A"])
1431

    
1432
and (vhdl_array_attributes_t_to_yojson :
1433
      vhdl_array_attributes_t -> Yojson.Safe.json)
1434
  =
1435
  ((let open! Ppx_deriving_yojson_runtime in
1436
      function
1437
      | AAttInt arg0 ->
1438
          `List
1439
            [`String "AAttInt";
1440
            (let fields = []  in
1441
             let fields =
1442
               ("arg",
1443
                 ((fun (x : Ppx_deriving_runtime.int)  -> `Int x) arg0.arg))
1444
               :: fields  in
1445
             let fields =
1446
               ("id",
1447
                 ((fun (x : Ppx_deriving_runtime.string)  -> `String x)
1448
                    arg0.id))
1449
               :: fields  in
1450
             `Assoc fields)]
1451
      | AAttAscending  -> `List [`String "AAttAscending"])
1452
  [@ocaml.warning "-A"])
1453

    
1454
and (vhdl_array_attributes_t_of_yojson :
1455
      Yojson.Safe.json ->
1456
        vhdl_array_attributes_t Ppx_deriving_yojson_runtime.error_or)
1457
  =
1458
  ((let open! Ppx_deriving_yojson_runtime in
1459
      function
1460
      | `List ((`String "AAttInt")::arg0::[]) ->
1461
          ((function
1462
            | `Assoc xs ->
1463
                let rec loop xs ((arg0,arg1) as _state) =
1464
                  match xs with
1465
                  | ("id",x)::xs ->
1466
                      loop xs
1467
                        (((function
1468
                           | `String x -> Result.Ok x
1469
                           | _ ->
1470
                               Result.Error
1471
                                 "Vhdl_ast.vhdl_array_attributes_t.id") x),
1472
                          arg1)
1473
                  | ("arg",x)::xs ->
1474
                      loop xs
1475
                        (arg0,
1476
                          ((function
1477
                            | `Int x -> Result.Ok x
1478
                            | _ ->
1479
                                Result.Error
1480
                                  "Vhdl_ast.vhdl_array_attributes_t.arg") x))
1481
                  | [] ->
1482
                      arg1 >>=
1483
                        ((fun arg1  ->
1484
                            arg0 >>=
1485
                              (fun arg0  ->
1486
                                 Result.Ok
1487
                                   (AAttInt { id = arg0; arg = arg1 }))))
1488
                  | _::xs -> loop xs _state  in
1489
                loop xs
1490
                  ((Result.Error "Vhdl_ast.vhdl_array_attributes_t.id"),
1491
                    (Result.Error "Vhdl_ast.vhdl_array_attributes_t.arg"))
1492
            | _ -> Result.Error "Vhdl_ast.vhdl_array_attributes_t")) arg0
1493
      | `List ((`String "AAttAscending")::[]) -> Result.Ok AAttAscending
1494
      | _ -> Result.Error "Vhdl_ast.vhdl_array_attributes_t")
1495
  [@ocaml.warning "-A"])
1496

    
1497
and (vhdl_signal_attributes_t_to_yojson :
1498
      vhdl_signal_attributes_t -> Yojson.Safe.json)
1499
  =
1500
  ((let open! Ppx_deriving_yojson_runtime in
1501
      function
1502
      | SigAtt arg0 ->
1503
          `List
1504
            [`String "SigAtt";
1505
            ((fun (x : Ppx_deriving_runtime.string)  -> `String x)) arg0])
1506
  [@ocaml.warning "-A"])
1507

    
1508
and (vhdl_signal_attributes_t_of_yojson :
1509
      Yojson.Safe.json ->
1510
        vhdl_signal_attributes_t Ppx_deriving_yojson_runtime.error_or)
1511
  =
1512
  ((let open! Ppx_deriving_yojson_runtime in
1513
      function
1514
      | `List ((`String "SigAtt")::arg0::[]) ->
1515
          ((function
1516
            | `String x -> Result.Ok x
1517
            | _ -> Result.Error "Vhdl_ast.vhdl_signal_attributes_t") arg0)
1518
            >>= ((fun arg0  -> Result.Ok (SigAtt arg0)))
1519
      | _ -> Result.Error "Vhdl_ast.vhdl_signal_attributes_t")
1520
  [@ocaml.warning "-A"])
1521

    
1522
and (vhdl_string_attributes_t_to_yojson :
1523
      vhdl_string_attributes_t -> Yojson.Safe.json)
1524
  =
1525
  ((let open! Ppx_deriving_yojson_runtime in
1526
      function
1527
      | StringAtt arg0 ->
1528
          `List
1529
            [`String "StringAtt";
1530
            ((fun (x : Ppx_deriving_runtime.string)  -> `String x)) arg0])
1531
  [@ocaml.warning "-A"])
1532

    
1533
and (vhdl_string_attributes_t_of_yojson :
1534
      Yojson.Safe.json ->
1535
        vhdl_string_attributes_t Ppx_deriving_yojson_runtime.error_or)
1536
  =
1537
  ((let open! Ppx_deriving_yojson_runtime in
1538
      function
1539
      | `List ((`String "StringAtt")::arg0::[]) ->
1540
          ((function
1541
            | `String x -> Result.Ok x
1542
            | _ -> Result.Error "Vhdl_ast.vhdl_string_attributes_t") arg0)
1543
            >>= ((fun arg0  -> Result.Ok (StringAtt arg0)))
1544
      | _ -> Result.Error "Vhdl_ast.vhdl_string_attributes_t")
1545
  [@ocaml.warning "-A"])
1546

    
1547
and (vhdl_suffix_selection_t_to_yojson :
1548
      vhdl_suffix_selection_t -> Yojson.Safe.json)
1549
  =
1550
  ((let open! Ppx_deriving_yojson_runtime in
1551
      function
1552
      | Idx arg0 ->
1553
          `List
1554
            [`String "Idx";
1555
            ((fun (x : Ppx_deriving_runtime.int)  -> `Int x)) arg0]
1556
      | SuffixRange (arg0,arg1) ->
1557
          `List
1558
            [`String "SuffixRange";
1559
            ((fun (x : Ppx_deriving_runtime.int)  -> `Int x)) arg0;
1560
            ((fun (x : Ppx_deriving_runtime.int)  -> `Int x)) arg1])
1561
  [@ocaml.warning "-A"])
1562

    
1563
and (vhdl_suffix_selection_t_of_yojson :
1564
      Yojson.Safe.json ->
1565
        vhdl_suffix_selection_t Ppx_deriving_yojson_runtime.error_or)
1566
  =
1567
  ((let open! Ppx_deriving_yojson_runtime in
1568
      function
1569
      | `List ((`String "Idx")::arg0::[]) ->
1570
          ((function
1571
            | `Int x -> Result.Ok x
1572
            | _ -> Result.Error "Vhdl_ast.vhdl_suffix_selection_t") arg0) >>=
1573
            ((fun arg0  -> Result.Ok (Idx arg0)))
1574
      | `List ((`String "SuffixRange")::arg0::arg1::[]) ->
1575
          ((function
1576
            | `Int x -> Result.Ok x
1577
            | _ -> Result.Error "Vhdl_ast.vhdl_suffix_selection_t") arg1) >>=
1578
            ((fun arg1  ->
1579
                ((function
1580
                  | `Int x -> Result.Ok x
1581
                  | _ -> Result.Error "Vhdl_ast.vhdl_suffix_selection_t")
1582
                   arg0)
1583
                  >>= (fun arg0  -> Result.Ok (SuffixRange (arg0, arg1)))))
1584
      | _ -> Result.Error "Vhdl_ast.vhdl_suffix_selection_t")
1585
  [@ocaml.warning "-A"])
1586

    
1587
let rec vhdl_type_attributes_t_to_yojson :
1588
  'basetype .
1589
    ('basetype -> Yojson.Safe.json) ->
1590
      'basetype vhdl_type_attributes_t -> Yojson.Safe.json
1591
  =
1592
  fun poly_basetype  ->
1593
    ((let open! Ppx_deriving_yojson_runtime in
1594
        function
1595
        | TAttNoArg arg0 ->
1596
            `List
1597
              [`String "TAttNoArg";
1598
              (let fields = []  in
1599
               let fields =
1600
                 ("id",
1601
                   ((fun (x : Ppx_deriving_runtime.string)  -> `String x)
1602
                      arg0.id))
1603
                 :: fields  in
1604
               `Assoc fields)]
1605
        | TAttIntArg arg0 ->
1606
            `List
1607
              [`String "TAttIntArg";
1608
              (let fields = []  in
1609
               let fields =
1610
                 ("arg",
1611
                   ((fun (x : Ppx_deriving_runtime.int)  -> `Int x) arg0.arg))
1612
                 :: fields  in
1613
               let fields =
1614
                 ("id",
1615
                   ((fun (x : Ppx_deriving_runtime.string)  -> `String x)
1616
                      arg0.id))
1617
                 :: fields  in
1618
               `Assoc fields)]
1619
        | TAttValArg arg0 ->
1620
            `List
1621
              [`String "TAttValArg";
1622
              (let fields = []  in
1623
               let fields =
1624
                 ("arg", ((poly_basetype : _ -> Yojson.Safe.json) arg0.arg))
1625
                 :: fields  in
1626
               let fields =
1627
                 ("id",
1628
                   ((fun (x : Ppx_deriving_runtime.string)  -> `String x)
1629
                      arg0.id))
1630
                 :: fields  in
1631
               `Assoc fields)]
1632
        | TAttStringArg arg0 ->
1633
            `List
1634
              [`String "TAttStringArg";
1635
              (let fields = []  in
1636
               let fields =
1637
                 ("arg",
1638
                   ((fun (x : Ppx_deriving_runtime.string)  -> `String x)
1639
                      arg0.arg))
1640
                 :: fields  in
1641
               let fields =
1642
                 ("id",
1643
                   ((fun (x : Ppx_deriving_runtime.string)  -> `String x)
1644
                      arg0.id))
1645
                 :: fields  in
1646
               `Assoc fields)])
1647
    [@ocaml.warning "-A"])
1648

    
1649
and vhdl_type_attributes_t_of_yojson :
1650
  'basetype .
1651
    (Yojson.Safe.json -> 'basetype Ppx_deriving_yojson_runtime.error_or) ->
1652
      Yojson.Safe.json ->
1653
        'basetype vhdl_type_attributes_t Ppx_deriving_yojson_runtime.error_or
1654
  =
1655
  fun poly_basetype  ->
1656
    ((let open! Ppx_deriving_yojson_runtime in
1657
        function
1658
        | `List ((`String "TAttNoArg")::arg0::[]) ->
1659
            ((function
1660
              | `Assoc xs ->
1661
                  let rec loop xs (arg0 as _state) =
1662
                    match xs with
1663
                    | ("id",x)::xs ->
1664
                        loop xs
1665
                          ((function
1666
                            | `String x -> Result.Ok x
1667
                            | _ ->
1668
                                Result.Error
1669
                                  "Vhdl_ast.vhdl_type_attributes_t.id") x)
1670
                    | [] ->
1671
                        arg0 >>=
1672
                          ((fun arg0  -> Result.Ok (TAttNoArg { id = arg0 })))
1673
                    | _::xs -> loop xs _state  in
1674
                  loop xs (Result.Error "Vhdl_ast.vhdl_type_attributes_t.id")
1675
              | _ -> Result.Error "Vhdl_ast.vhdl_type_attributes_t")) arg0
1676
        | `List ((`String "TAttIntArg")::arg0::[]) ->
1677
            ((function
1678
              | `Assoc xs ->
1679
                  let rec loop xs ((arg0,arg1) as _state) =
1680
                    match xs with
1681
                    | ("id",x)::xs ->
1682
                        loop xs
1683
                          (((function
1684
                             | `String x -> Result.Ok x
1685
                             | _ ->
1686
                                 Result.Error
1687
                                   "Vhdl_ast.vhdl_type_attributes_t.id") x),
1688
                            arg1)
1689
                    | ("arg",x)::xs ->
1690
                        loop xs
1691
                          (arg0,
1692
                            ((function
1693
                              | `Int x -> Result.Ok x
1694
                              | _ ->
1695
                                  Result.Error
1696
                                    "Vhdl_ast.vhdl_type_attributes_t.arg") x))
1697
                    | [] ->
1698
                        arg1 >>=
1699
                          ((fun arg1  ->
1700
                              arg0 >>=
1701
                                (fun arg0  ->
1702
                                   Result.Ok
1703
                                     (TAttIntArg { id = arg0; arg = arg1 }))))
1704
                    | _::xs -> loop xs _state  in
1705
                  loop xs
1706
                    ((Result.Error "Vhdl_ast.vhdl_type_attributes_t.id"),
1707
                      (Result.Error "Vhdl_ast.vhdl_type_attributes_t.arg"))
1708
              | _ -> Result.Error "Vhdl_ast.vhdl_type_attributes_t")) arg0
1709
        | `List ((`String "TAttValArg")::arg0::[]) ->
1710
            ((function
1711
              | `Assoc xs ->
1712
                  let rec loop xs ((arg0,arg1) as _state) =
1713
                    match xs with
1714
                    | ("id",x)::xs ->
1715
                        loop xs
1716
                          (((function
1717
                             | `String x -> Result.Ok x
1718
                             | _ ->
1719
                                 Result.Error
1720
                                   "Vhdl_ast.vhdl_type_attributes_t.id") x),
1721
                            arg1)
1722
                    | ("arg",x)::xs ->
1723
                        loop xs
1724
                          (arg0,
1725
                            ((poly_basetype : Yojson.Safe.json -> _ error_or)
1726
                               x))
1727
                    | [] ->
1728
                        arg1 >>=
1729
                          ((fun arg1  ->
1730
                              arg0 >>=
1731
                                (fun arg0  ->
1732
                                   Result.Ok
1733
                                     (TAttValArg { id = arg0; arg = arg1 }))))
1734
                    | _::xs -> loop xs _state  in
1735
                  loop xs
1736
                    ((Result.Error "Vhdl_ast.vhdl_type_attributes_t.id"),
1737
                      (Result.Error "Vhdl_ast.vhdl_type_attributes_t.arg"))
1738
              | _ -> Result.Error "Vhdl_ast.vhdl_type_attributes_t")) arg0
1739
        | `List ((`String "TAttStringArg")::arg0::[]) ->
1740
            ((function
1741
              | `Assoc xs ->
1742
                  let rec loop xs ((arg0,arg1) as _state) =
1743
                    match xs with
1744
                    | ("id",x)::xs ->
1745
                        loop xs
1746
                          (((function
1747
                             | `String x -> Result.Ok x
1748
                             | _ ->
1749
                                 Result.Error
1750
                                   "Vhdl_ast.vhdl_type_attributes_t.id") x),
1751
                            arg1)
1752
                    | ("arg",x)::xs ->
1753
                        loop xs
1754
                          (arg0,
1755
                            ((function
1756
                              | `String x -> Result.Ok x
1757
                              | _ ->
1758
                                  Result.Error
1759
                                    "Vhdl_ast.vhdl_type_attributes_t.arg") x))
1760
                    | [] ->
1761
                        arg1 >>=
1762
                          ((fun arg1  ->
1763
                              arg0 >>=
1764
                                (fun arg0  ->
1765
                                   Result.Ok
1766
                                     (TAttStringArg { id = arg0; arg = arg1 }))))
1767
                    | _::xs -> loop xs _state  in
1768
                  loop xs
1769
                    ((Result.Error "Vhdl_ast.vhdl_type_attributes_t.id"),
1770
                      (Result.Error "Vhdl_ast.vhdl_type_attributes_t.arg"))
1771
              | _ -> Result.Error "Vhdl_ast.vhdl_type_attributes_t")) arg0
1772
        | _ -> Result.Error "Vhdl_ast.vhdl_type_attributes_t")
1773
    [@ocaml.warning "-A"])
1774

    
1775
let rec (vhdl_parameter_t_to_yojson : vhdl_parameter_t -> Yojson.Safe.json) =
1776
  ((let open! Ppx_deriving_yojson_runtime in
1777
      fun x  ->
1778
        let fields = []  in
1779
        let fields =
1780
          if x.init_val = None
1781
          then fields
1782
          else
1783
            ("init_val",
1784
              (((function
1785
                 | None  -> `Null
1786
                 | Some x -> ((fun x  -> vhdl_cst_val_t_to_yojson x)) x))
1787
                 x.init_val))
1788
            :: fields
1789
           in
1790
        let fields =
1791
          ("typ", ((fun x  -> vhdl_subtype_indication_t_to_yojson x) x.typ))
1792
          :: fields  in
1793
        let fields =
1794
          if x.mode = []
1795
          then fields
1796
          else
1797
            ("mode",
1798
              (((fun x  ->
1799
                   `List
1800
                     (List.map
1801
                        (fun (x : Ppx_deriving_runtime.string)  -> `String x)
1802
                        x))) x.mode))
1803
            :: fields
1804
           in
1805
        let fields =
1806
          ("names",
1807
            ((fun x  ->
1808
                `List (List.map (fun x  -> vhdl_name_t_to_yojson x) x))
1809
               x.names))
1810
          :: fields  in
1811
        `Assoc fields)
1812
  [@ocaml.warning "-A"])
1813

    
1814
and (vhdl_parameter_t_of_yojson :
1815
      Yojson.Safe.json ->
1816
        vhdl_parameter_t Ppx_deriving_yojson_runtime.error_or)
1817
  =
1818
  ((let open! Ppx_deriving_yojson_runtime in
1819
      function
1820
      | `Assoc xs ->
1821
          let rec loop xs ((arg0,arg1,arg2,arg3) as _state) =
1822
            match xs with
1823
            | ("names",x)::xs ->
1824
                loop xs
1825
                  (((function
1826
                     | `List xs ->
1827
                         map_bind (fun x  -> vhdl_name_t_of_yojson x) [] xs
1828
                     | _ -> Result.Error "Vhdl_ast.vhdl_parameter_t.names") x),
1829
                    arg1, arg2, arg3)
1830
            | ("mode",x)::xs ->
1831
                loop xs
1832
                  (arg0,
1833
                    ((function
1834
                      | `List xs ->
1835
                          map_bind
1836
                            (function
1837
                             | `String x -> Result.Ok x
1838
                             | _ ->
1839
                                 Result.Error
1840
                                   "Vhdl_ast.vhdl_parameter_t.mode") [] xs
1841
                      | _ -> Result.Error "Vhdl_ast.vhdl_parameter_t.mode") x),
1842
                    arg2, arg3)
1843
            | ("typ",x)::xs ->
1844
                loop xs
1845
                  (arg0, arg1,
1846
                    ((fun x  -> vhdl_subtype_indication_t_of_yojson x) x),
1847
                    arg3)
1848
            | ("init_val",x)::xs ->
1849
                loop xs
1850
                  (arg0, arg1, arg2,
1851
                    ((function
1852
                      | `Null -> Result.Ok None
1853
                      | x ->
1854
                          ((fun x  -> vhdl_cst_val_t_of_yojson x) x) >>=
1855
                            ((fun x  -> Result.Ok (Some x)))) x))
1856
            | [] ->
1857
                arg3 >>=
1858
                  ((fun arg3  ->
1859
                      arg2 >>=
1860
                        (fun arg2  ->
1861
                           arg1 >>=
1862
                             (fun arg1  ->
1863
                                arg0 >>=
1864
                                  (fun arg0  ->
1865
                                     Result.Ok
1866
                                       {
1867
                                         names = arg0;
1868
                                         mode = arg1;
1869
                                         typ = arg2;
1870
                                         init_val = arg3
1871
                                       })))))
1872
            | _::xs -> loop xs _state  in
1873
          loop xs
1874
            ((Result.Error "Vhdl_ast.vhdl_parameter_t.names"),
1875
              (Result.Ok []), (Result.Error "Vhdl_ast.vhdl_parameter_t.typ"),
1876
              (Result.Ok (Some (CstInt 0))))
1877
      | _ -> Result.Error "Vhdl_ast.vhdl_parameter_t")
1878
  [@ocaml.warning "-A"])
1879

    
1880
let rec (vhdl_subprogram_spec_t_to_yojson :
1881
          vhdl_subprogram_spec_t -> Yojson.Safe.json)
1882
  =
1883
  ((let open! Ppx_deriving_yojson_runtime in
1884
      fun x  ->
1885
        let fields = []  in
1886
        let fields =
1887
          if x.isPure = false
1888
          then fields
1889
          else
1890
            ("isPure",
1891
              (((fun (x : Ppx_deriving_runtime.bool)  -> `Bool x)) x.isPure))
1892
            :: fields
1893
           in
1894
        let fields =
1895
          if x.parameters = []
1896
          then fields
1897
          else
1898
            ("parameters",
1899
              (((fun x  ->
1900
                   `List
1901
                     (List.map (fun x  -> vhdl_parameter_t_to_yojson x) x)))
1902
                 x.parameters))
1903
            :: fields
1904
           in
1905
        let fields =
1906
          if x.typeMark = NoName
1907
          then fields
1908
          else
1909
            ("typeMark", (((fun x  -> vhdl_name_t_to_yojson x)) x.typeMark))
1910
            :: fields
1911
           in
1912
        let fields =
1913
          if x.subprogram_type = ""
1914
          then fields
1915
          else
1916
            ("subprogram_type",
1917
              (((fun (x : Ppx_deriving_runtime.string)  -> `String x))
1918
                 x.subprogram_type))
1919
            :: fields
1920
           in
1921
        let fields =
1922
          if x.name = ""
1923
          then fields
1924
          else
1925
            ("name",
1926
              (((fun (x : Ppx_deriving_runtime.string)  -> `String x)) x.name))
1927
            :: fields
1928
           in
1929
        `Assoc fields)
1930
  [@ocaml.warning "-A"])
1931

    
1932
and (vhdl_subprogram_spec_t_of_yojson :
1933
      Yojson.Safe.json ->
1934
        vhdl_subprogram_spec_t Ppx_deriving_yojson_runtime.error_or)
1935
  =
1936
  ((let open! Ppx_deriving_yojson_runtime in
1937
      function
1938
      | `Assoc xs ->
1939
          let rec loop xs ((arg0,arg1,arg2,arg3,arg4) as _state) =
1940
            match xs with
1941
            | ("name",x)::xs ->
1942
                loop xs
1943
                  (((function
1944
                     | `String x -> Result.Ok x
1945
                     | _ ->
1946
                         Result.Error "Vhdl_ast.vhdl_subprogram_spec_t.name")
1947
                      x), arg1, arg2, arg3, arg4)
1948
            | ("subprogram_type",x)::xs ->
1949
                loop xs
1950
                  (arg0,
1951
                    ((function
1952
                      | `String x -> Result.Ok x
1953
                      | _ ->
1954
                          Result.Error
1955
                            "Vhdl_ast.vhdl_subprogram_spec_t.subprogram_type")
1956
                       x), arg2, arg3, arg4)
1957
            | ("typeMark",x)::xs ->
1958
                loop xs
1959
                  (arg0, arg1, ((fun x  -> vhdl_name_t_of_yojson x) x), arg3,
1960
                    arg4)
1961
            | ("parameters",x)::xs ->
1962
                loop xs
1963
                  (arg0, arg1, arg2,
1964
                    ((function
1965
                      | `List xs ->
1966
                          map_bind (fun x  -> vhdl_parameter_t_of_yojson x)
1967
                            [] xs
1968
                      | _ ->
1969
                          Result.Error
1970
                            "Vhdl_ast.vhdl_subprogram_spec_t.parameters") x),
1971
                    arg4)
1972
            | ("isPure",x)::xs ->
1973
                loop xs
1974
                  (arg0, arg1, arg2, arg3,
1975
                    ((function
1976
                      | `Bool x -> Result.Ok x
1977
                      | _ ->
1978
                          Result.Error
1979
                            "Vhdl_ast.vhdl_subprogram_spec_t.isPure") x))
1980
            | [] ->
1981
                arg4 >>=
1982
                  ((fun arg4  ->
1983
                      arg3 >>=
1984
                        (fun arg3  ->
1985
                           arg2 >>=
1986
                             (fun arg2  ->
1987
                                arg1 >>=
1988
                                  (fun arg1  ->
1989
                                     arg0 >>=
1990
                                       (fun arg0  ->
1991
                                          Result.Ok
1992
                                            {
1993
                                              name = arg0;
1994
                                              subprogram_type = arg1;
1995
                                              typeMark = arg2;
1996
                                              parameters = arg3;
1997
                                              isPure = arg4
1998
                                            }))))))
1999
            | _::xs -> loop xs _state  in
2000
          loop xs
2001
            ((Result.Ok ""), (Result.Ok ""), (Result.Ok NoName),
2002
              (Result.Ok []), (Result.Ok false))
2003
      | _ -> Result.Error "Vhdl_ast.vhdl_subprogram_spec_t")
2004
  [@ocaml.warning "-A"])
2005

    
2006
let rec (vhdl_waveform_element_t_to_yojson :
2007
          vhdl_waveform_element_t -> Yojson.Safe.json)
2008
  =
2009
  ((let open! Ppx_deriving_yojson_runtime in
2010
      fun x  ->
2011
        let fields = []  in
2012
        let fields =
2013
          if x.delay = None
2014
          then fields
2015
          else
2016
            ("delay",
2017
              (((function
2018
                 | None  -> `Null
2019
                 | Some x -> ((fun x  -> vhdl_expr_t_to_yojson x)) x))
2020
                 x.delay))
2021
            :: fields
2022
           in
2023
        let fields =
2024
          if x.value = None
2025
          then fields
2026
          else
2027
            ("value",
2028
              (((function
2029
                 | None  -> `Null
2030
                 | Some x -> ((fun x  -> vhdl_expr_t_to_yojson x)) x))
2031
                 x.value))
2032
            :: fields
2033
           in
2034
        `Assoc fields)
2035
  [@ocaml.warning "-A"])
2036

    
2037
and (vhdl_waveform_element_t_of_yojson :
2038
      Yojson.Safe.json ->
2039
        vhdl_waveform_element_t Ppx_deriving_yojson_runtime.error_or)
2040
  =
2041
  ((let open! Ppx_deriving_yojson_runtime in
2042
      function
2043
      | `Assoc xs ->
2044
          let rec loop xs ((arg0,arg1) as _state) =
2045
            match xs with
2046
            | ("value",x)::xs ->
2047
                loop xs
2048
                  (((function
2049
                     | `Null -> Result.Ok None
2050
                     | x ->
2051
                         ((fun x  -> vhdl_expr_t_of_yojson x) x) >>=
2052
                           ((fun x  -> Result.Ok (Some x)))) x), arg1)
2053
            | ("delay",x)::xs ->
2054
                loop xs
2055
                  (arg0,
2056
                    ((function
2057
                      | `Null -> Result.Ok None
2058
                      | x ->
2059
                          ((fun x  -> vhdl_expr_t_of_yojson x) x) >>=
2060
                            ((fun x  -> Result.Ok (Some x)))) x))
2061
            | [] ->
2062
                arg1 >>=
2063
                  ((fun arg1  ->
2064
                      arg0 >>=
2065
                        (fun arg0  ->
2066
                           Result.Ok { value = arg0; delay = arg1 })))
2067
            | _::xs -> loop xs _state  in
2068
          loop xs ((Result.Ok None), (Result.Ok None))
2069
      | _ -> Result.Error "Vhdl_ast.vhdl_waveform_element_t")
2070
  [@ocaml.warning "-A"])
2071

    
2072
let rec (vhdl_sequential_stmt_t_to_yojson :
2073
          vhdl_sequential_stmt_t -> Yojson.Safe.json)
2074
  =
2075
  ((let open! Ppx_deriving_yojson_runtime in
2076
      function
2077
      | VarAssign arg0 ->
2078
          `List
2079
            [`String "VARIABLE_ASSIGNMENT_STATEMENT";
2080
            (let fields = []  in
2081
             let fields =
2082
               ("rhs", ((fun x  -> vhdl_expr_t_to_yojson x) arg0.rhs)) ::
2083
               fields  in
2084
             let fields =
2085
               ("lhs", ((fun x  -> vhdl_name_t_to_yojson x) arg0.lhs)) ::
2086
               fields  in
2087
             let fields =
2088
               if arg0.label = NoName
2089
               then fields
2090
               else
2091
                 ("label",
2092
                   (((fun x  -> vhdl_name_t_to_yojson x)) arg0.label))
2093
                 :: fields
2094
                in
2095
             `Assoc fields)]
2096
      | SigSeqAssign arg0 ->
2097
          `List
2098
            [`String "SIGNAL_ASSIGNMENT_STATEMENT";
2099
            (let fields = []  in
2100
             let fields =
2101
               ("rhs",
2102
                 ((fun x  ->
2103
                     `List
2104
                       (List.map
2105
                          (fun x  -> vhdl_waveform_element_t_to_yojson x) x))
2106
                    arg0.rhs))
2107
               :: fields  in
2108
             let fields =
2109
               ("lhs", ((fun x  -> vhdl_name_t_to_yojson x) arg0.lhs)) ::
2110
               fields  in
2111
             let fields =
2112
               if arg0.label = NoName
2113
               then fields
2114
               else
2115
                 ("label",
2116
                   (((fun x  -> vhdl_name_t_to_yojson x)) arg0.label))
2117
                 :: fields
2118
                in
2119
             `Assoc fields)]
2120
      | If arg0 ->
2121
          `List
2122
            [`String "IF_STATEMENT";
2123
            (let fields = []  in
2124
             let fields =
2125
               if arg0.default = []
2126
               then fields
2127
               else
2128
                 ("default",
2129
                   (((fun x  ->
2130
                        `List
2131
                          (List.map
2132
                             (fun x  -> vhdl_sequential_stmt_t_to_yojson x) x)))
2133
                      arg0.default))
2134
                 :: fields
2135
                in
2136
             let fields =
2137
               ("if_cases",
2138
                 ((fun x  ->
2139
                     `List
2140
                       (List.map (fun x  -> vhdl_if_case_t_to_yojson x) x))
2141
                    arg0.if_cases))
2142
               :: fields  in
2143
             let fields =
2144
               if arg0.label = NoName
2145
               then fields
2146
               else
2147
                 ("label",
2148
                   (((fun x  -> vhdl_name_t_to_yojson x)) arg0.label))
2149
                 :: fields
2150
                in
2151
             `Assoc fields)]
2152
      | Case arg0 ->
2153
          `List
2154
            [`String "CASE_STATEMENT_TREE";
2155
            (let fields = []  in
2156
             let fields =
2157
               ("branches",
2158
                 ((fun x  ->
2159
                     `List
2160
                       (List.map (fun x  -> vhdl_case_item_t_to_yojson x) x))
2161
                    arg0.branches))
2162
               :: fields  in
2163
             let fields =
2164
               ("guard", ((fun x  -> vhdl_expr_t_to_yojson x) arg0.guard)) ::
2165
               fields  in
2166
             let fields =
2167
               if arg0.label = NoName
2168
               then fields
2169
               else
2170
                 ("label",
2171
                   (((fun x  -> vhdl_name_t_to_yojson x)) arg0.label))
2172
                 :: fields
2173
                in
2174
             `Assoc fields)]
2175
      | Exit arg0 ->
2176
          `List
2177
            [`String "EXIT_STATEMENT";
2178
            (let fields = []  in
2179
             let fields =
2180
               if arg0.condition = (Some IsNull)
2181
               then fields
2182
               else
2183
                 ("condition",
2184
                   (((function
2185
                      | None  -> `Null
2186
                      | Some x -> ((fun x  -> vhdl_expr_t_to_yojson x)) x))
2187
                      arg0.condition))
2188
                 :: fields
2189
                in
2190
             let fields =
2191
               if arg0.loop_label = (Some "")
2192
               then fields
2193
               else
2194
                 ("loop_label",
2195
                   (((function
2196
                      | None  -> `Null
2197
                      | Some x ->
2198
                          ((fun (x : Ppx_deriving_runtime.string)  ->
2199
                              `String x)) x)) arg0.loop_label))
2200
                 :: fields
2201
                in
2202
             let fields =
2203
               if arg0.label = NoName
2204
               then fields
2205
               else
2206
                 ("label",
2207
                   (((fun x  -> vhdl_name_t_to_yojson x)) arg0.label))
2208
                 :: fields
2209
                in
2210
             `Assoc fields)]
2211
      | Assert arg0 ->
2212
          `List
2213
            [`String "ASSERTION_STATEMENT";
2214
            (let fields = []  in
2215
             let fields =
2216
               if arg0.severity = IsNull
2217
               then fields
2218
               else
2219
                 ("severity",
2220
                   (((fun x  -> vhdl_expr_t_to_yojson x)) arg0.severity))
2221
                 :: fields
2222
                in
2223
             let fields =
2224
               if arg0.report = IsNull
2225
               then fields
2226
               else
2227
                 ("report",
2228
                   (((fun x  -> vhdl_expr_t_to_yojson x)) arg0.report))
2229
                 :: fields
2230
                in
2231
             let fields =
2232
               ("cond", ((fun x  -> vhdl_expr_t_to_yojson x) arg0.cond)) ::
2233
               fields  in
2234
             let fields =
2235
               if arg0.label = NoName
2236
               then fields
2237
               else
2238
                 ("label",
2239
                   (((fun x  -> vhdl_name_t_to_yojson x)) arg0.label))
2240
                 :: fields
2241
                in
2242
             `Assoc fields)]
2243
      | ProcedureCall arg0 ->
2244
          `List
2245
            [`String "PROCEDURE_CALL_STATEMENT";
2246
            (let fields = []  in
2247
             let fields =
2248
               if arg0.assocs = []
2249
               then fields
2250
               else
2251
                 ("assocs",
2252
                   (((fun x  ->
2253
                        `List
2254
                          (List.map
2255
                             (fun x  -> vhdl_assoc_element_t_to_yojson x) x)))
2256
                      arg0.assocs))
2257
                 :: fields
2258
                in
2259
             let fields =
2260
               ("name", ((fun x  -> vhdl_name_t_to_yojson x) arg0.name)) ::
2261
               fields  in
2262
             let fields =
2263
               if arg0.label = NoName
2264
               then fields
2265
               else
2266
                 ("label",
2267
                   (((fun x  -> vhdl_name_t_to_yojson x)) arg0.label))
2268
                 :: fields
2269
                in
2270
             `Assoc fields)]
2271
      | Wait  -> `List [`String "WAIT_STATEMENT"]
2272
      | Null arg0 ->
2273
          `List
2274
            [`String "NULL_STATEMENT";
2275
            (let fields = []  in
2276
             let fields =
2277
               if arg0.label = NoName
2278
               then fields
2279
               else
2280
                 ("label",
2281
                   (((fun x  -> vhdl_name_t_to_yojson x)) arg0.label))
2282
                 :: fields
2283
                in
2284
             `Assoc fields)]
2285
      | Return arg0 ->
2286
          `List
2287
            [`String "RETURN_STATEMENT";
2288
            (let fields = []  in
2289
             let fields =
2290
               if arg0.expr = None
2291
               then fields
2292
               else
2293
                 ("expr",
2294
                   (((function
2295
                      | None  -> `Null
2296
                      | Some x -> ((fun x  -> vhdl_expr_t_to_yojson x)) x))
2297
                      arg0.expr))
2298
                 :: fields
2299
                in
2300
             let fields =
2301
               if arg0.label = None
2302
               then fields
2303
               else
2304
                 ("label",
2305
                   (((function
2306
                      | None  -> `Null
2307
                      | Some x -> ((fun x  -> vhdl_name_t_to_yojson x)) x))
2308
                      arg0.label))
2309
                 :: fields
2310
                in
2311
             `Assoc fields)])
2312
  [@ocaml.warning "-A"])
2313

    
2314
and (vhdl_sequential_stmt_t_of_yojson :
2315
      Yojson.Safe.json ->
2316
        vhdl_sequential_stmt_t Ppx_deriving_yojson_runtime.error_or)
2317
  =
2318
  ((let open! Ppx_deriving_yojson_runtime in
2319
      function
2320
      | `List ((`String "VARIABLE_ASSIGNMENT_STATEMENT")::arg0::[]) ->
2321
          ((function
2322
            | `Assoc xs ->
2323
                let rec loop xs ((arg0,arg1,arg2) as _state) =
2324
                  match xs with
2325
                  | ("label",x)::xs ->
2326
                      loop xs
2327
                        (((fun x  -> vhdl_name_t_of_yojson x) x), arg1, arg2)
2328
                  | ("lhs",x)::xs ->
2329
                      loop xs
2330
                        (arg0, ((fun x  -> vhdl_name_t_of_yojson x) x), arg2)
2331
                  | ("rhs",x)::xs ->
2332
                      loop xs
2333
                        (arg0, arg1, ((fun x  -> vhdl_expr_t_of_yojson x) x))
2334
                  | [] ->
2335
                      arg2 >>=
2336
                        ((fun arg2  ->
2337
                            arg1 >>=
2338
                              (fun arg1  ->
2339
                                 arg0 >>=
2340
                                   (fun arg0  ->
2341
                                      Result.Ok
2342
                                        (VarAssign
2343
                                           {
2344
                                             label = arg0;
2345
                                             lhs = arg1;
2346
                                             rhs = arg2
2347
                                           })))))
2348
                  | _::xs -> loop xs _state  in
2349
                loop xs
2350
                  ((Result.Ok NoName),
2351
                    (Result.Error "Vhdl_ast.vhdl_sequential_stmt_t.lhs"),
2352
                    (Result.Error "Vhdl_ast.vhdl_sequential_stmt_t.rhs"))
2353
            | _ -> Result.Error "Vhdl_ast.vhdl_sequential_stmt_t")) arg0
2354
      | `List ((`String "SIGNAL_ASSIGNMENT_STATEMENT")::arg0::[]) ->
2355
          ((function
2356
            | `Assoc xs ->
2357
                let rec loop xs ((arg0,arg1,arg2) as _state) =
2358
                  match xs with
2359
                  | ("label",x)::xs ->
2360
                      loop xs
2361
                        (((fun x  -> vhdl_name_t_of_yojson x) x), arg1, arg2)
2362
                  | ("lhs",x)::xs ->
2363
                      loop xs
2364
                        (arg0, ((fun x  -> vhdl_name_t_of_yojson x) x), arg2)
2365
                  | ("rhs",x)::xs ->
2366
                      loop xs
2367
                        (arg0, arg1,
2368
                          ((function
2369
                            | `List xs ->
2370
                                map_bind
2371
                                  (fun x  ->
2372
                                     vhdl_waveform_element_t_of_yojson x) []
2373
                                  xs
2374
                            | _ ->
2375
                                Result.Error
2376
                                  "Vhdl_ast.vhdl_sequential_stmt_t.rhs") x))
2377
                  | [] ->
2378
                      arg2 >>=
2379
                        ((fun arg2  ->
2380
                            arg1 >>=
2381
                              (fun arg1  ->
2382
                                 arg0 >>=
2383
                                   (fun arg0  ->
2384
                                      Result.Ok
2385
                                        (SigSeqAssign
2386
                                           {
2387
                                             label = arg0;
2388
                                             lhs = arg1;
2389
                                             rhs = arg2
2390
                                           })))))
2391
                  | _::xs -> loop xs _state  in
2392
                loop xs
2393
                  ((Result.Ok NoName),
2394
                    (Result.Error "Vhdl_ast.vhdl_sequential_stmt_t.lhs"),
2395
                    (Result.Error "Vhdl_ast.vhdl_sequential_stmt_t.rhs"))
2396
            | _ -> Result.Error "Vhdl_ast.vhdl_sequential_stmt_t")) arg0
2397
      | `List ((`String "IF_STATEMENT")::arg0::[]) ->
2398
          ((function
2399
            | `Assoc xs ->
2400
                let rec loop xs ((arg0,arg1,arg2) as _state) =
2401
                  match xs with
2402
                  | ("label",x)::xs ->
2403
                      loop xs
2404
                        (((fun x  -> vhdl_name_t_of_yojson x) x), arg1, arg2)
2405
                  | ("if_cases",x)::xs ->
2406
                      loop xs
2407
                        (arg0,
2408
                          ((function
2409
                            | `List xs ->
2410
                                map_bind
2411
                                  (fun x  -> vhdl_if_case_t_of_yojson x) []
2412
                                  xs
2413
                            | _ ->
2414
                                Result.Error
2415
                                  "Vhdl_ast.vhdl_sequential_stmt_t.if_cases")
2416
                             x), arg2)
2417
                  | ("default",x)::xs ->
2418
                      loop xs
2419
                        (arg0, arg1,
2420
                          ((function
2421
                            | `List xs ->
2422
                                map_bind
2423
                                  (fun x  ->
2424
                                     vhdl_sequential_stmt_t_of_yojson x) []
2425
                                  xs
2426
                            | _ ->
2427
                                Result.Error
2428
                                  "Vhdl_ast.vhdl_sequential_stmt_t.default")
2429
                             x))
2430
                  | [] ->
2431
                      arg2 >>=
2432
                        ((fun arg2  ->
2433
                            arg1 >>=
2434
                              (fun arg1  ->
2435
                                 arg0 >>=
2436
                                   (fun arg0  ->
2437
                                      Result.Ok
2438
                                        (If
2439
                                           {
2440
                                             label = arg0;
2441
                                             if_cases = arg1;
2442
                                             default = arg2
2443
                                           })))))
2444
                  | _::xs -> loop xs _state  in
2445
                loop xs
2446
                  ((Result.Ok NoName),
2447
                    (Result.Error "Vhdl_ast.vhdl_sequential_stmt_t.if_cases"),
2448
                    (Result.Ok []))
2449
            | _ -> Result.Error "Vhdl_ast.vhdl_sequential_stmt_t")) arg0
2450
      | `List ((`String "CASE_STATEMENT_TREE")::arg0::[]) ->
2451
          ((function
2452
            | `Assoc xs ->
2453
                let rec loop xs ((arg0,arg1,arg2) as _state) =
2454
                  match xs with
2455
                  | ("label",x)::xs ->
2456
                      loop xs
2457
                        (((fun x  -> vhdl_name_t_of_yojson x) x), arg1, arg2)
2458
                  | ("guard",x)::xs ->
2459
                      loop xs
2460
                        (arg0, ((fun x  -> vhdl_expr_t_of_yojson x) x), arg2)
2461
                  | ("branches",x)::xs ->
2462
                      loop xs
2463
                        (arg0, arg1,
2464
                          ((function
2465
                            | `List xs ->
2466
                                map_bind
2467
                                  (fun x  -> vhdl_case_item_t_of_yojson x) []
2468
                                  xs
2469
                            | _ ->
2470
                                Result.Error
2471
                                  "Vhdl_ast.vhdl_sequential_stmt_t.branches")
2472
                             x))
2473
                  | [] ->
2474
                      arg2 >>=
2475
                        ((fun arg2  ->
2476
                            arg1 >>=
2477
                              (fun arg1  ->
2478
                                 arg0 >>=
2479
                                   (fun arg0  ->
2480
                                      Result.Ok
2481
                                        (Case
2482
                                           {
2483
                                             label = arg0;
2484
                                             guard = arg1;
2485
                                             branches = arg2
2486
                                           })))))
2487
                  | _::xs -> loop xs _state  in
2488
                loop xs
2489
                  ((Result.Ok NoName),
2490
                    (Result.Error "Vhdl_ast.vhdl_sequential_stmt_t.guard"),
2491
                    (Result.Error "Vhdl_ast.vhdl_sequential_stmt_t.branches"))
2492
            | _ -> Result.Error "Vhdl_ast.vhdl_sequential_stmt_t")) arg0
2493
      | `List ((`String "EXIT_STATEMENT")::arg0::[]) ->
2494
          ((function
2495
            | `Assoc xs ->
2496
                let rec loop xs ((arg0,arg1,arg2) as _state) =
2497
                  match xs with
2498
                  | ("label",x)::xs ->
2499
                      loop xs
2500
                        (((fun x  -> vhdl_name_t_of_yojson x) x), arg1, arg2)
2501
                  | ("loop_label",x)::xs ->
2502
                      loop xs
2503
                        (arg0,
2504
                          ((function
2505
                            | `Null -> Result.Ok None
2506
                            | x ->
2507
                                ((function
2508
                                  | `String x -> Result.Ok x
2509
                                  | _ ->
2510
                                      Result.Error
2511
                                        "Vhdl_ast.vhdl_sequential_stmt_t.loop_label")
2512
                                   x)
2513
                                  >>= ((fun x  -> Result.Ok (Some x)))) x),
2514
                          arg2)
2515
                  | ("condition",x)::xs ->
2516
                      loop xs
2517
                        (arg0, arg1,
2518
                          ((function
2519
                            | `Null -> Result.Ok None
2520
                            | x ->
2521
                                ((fun x  -> vhdl_expr_t_of_yojson x) x) >>=
2522
                                  ((fun x  -> Result.Ok (Some x)))) x))
2523
                  | [] ->
2524
                      arg2 >>=
2525
                        ((fun arg2  ->
2526
                            arg1 >>=
2527
                              (fun arg1  ->
2528
                                 arg0 >>=
2529
                                   (fun arg0  ->
2530
                                      Result.Ok
2531
                                        (Exit
2532
                                           {
2533
                                             label = arg0;
2534
                                             loop_label = arg1;
2535
                                             condition = arg2
2536
                                           })))))
2537
                  | _::xs -> loop xs _state  in
2538
                loop xs
2539
                  ((Result.Ok NoName), (Result.Ok (Some "")),
2540
                    (Result.Ok (Some IsNull)))
2541
            | _ -> Result.Error "Vhdl_ast.vhdl_sequential_stmt_t")) arg0
2542
      | `List ((`String "ASSERTION_STATEMENT")::arg0::[]) ->
2543
          ((function
2544
            | `Assoc xs ->
2545
                let rec loop xs ((arg0,arg1,arg2,arg3) as _state) =
2546
                  match xs with
2547
                  | ("label",x)::xs ->
2548
                      loop xs
2549
                        (((fun x  -> vhdl_name_t_of_yojson x) x), arg1, arg2,
2550
                          arg3)
2551
                  | ("cond",x)::xs ->
2552
                      loop xs
2553
                        (arg0, ((fun x  -> vhdl_expr_t_of_yojson x) x), arg2,
2554
                          arg3)
2555
                  | ("report",x)::xs ->
2556
                      loop xs
2557
                        (arg0, arg1, ((fun x  -> vhdl_expr_t_of_yojson x) x),
2558
                          arg3)
2559
                  | ("severity",x)::xs ->
2560
                      loop xs
2561
                        (arg0, arg1, arg2,
2562
                          ((fun x  -> vhdl_expr_t_of_yojson x) x))
2563
                  | [] ->
2564
                      arg3 >>=
2565
                        ((fun arg3  ->
2566
                            arg2 >>=
2567
                              (fun arg2  ->
2568
                                 arg1 >>=
2569
                                   (fun arg1  ->
2570
                                      arg0 >>=
2571
                                        (fun arg0  ->
2572
                                           Result.Ok
2573
                                             (Assert
2574
                                                {
2575
                                                  label = arg0;
2576
                                                  cond = arg1;
2577
                                                  report = arg2;
2578
                                                  severity = arg3
2579
                                                }))))))
2580
                  | _::xs -> loop xs _state  in
2581
                loop xs
2582
                  ((Result.Ok NoName),
2583
                    (Result.Error "Vhdl_ast.vhdl_sequential_stmt_t.cond"),
2584
                    (Result.Ok IsNull), (Result.Ok IsNull))
2585
            | _ -> Result.Error "Vhdl_ast.vhdl_sequential_stmt_t")) arg0
2586
      | `List ((`String "PROCEDURE_CALL_STATEMENT")::arg0::[]) ->
2587
          ((function
2588
            | `Assoc xs ->
2589
                let rec loop xs ((arg0,arg1,arg2) as _state) =
2590
                  match xs with
2591
                  | ("label",x)::xs ->
2592
                      loop xs
2593
                        (((fun x  -> vhdl_name_t_of_yojson x) x), arg1, arg2)
2594
                  | ("name",x)::xs ->
2595
                      loop xs
2596
                        (arg0, ((fun x  -> vhdl_name_t_of_yojson x) x), arg2)
2597
                  | ("assocs",x)::xs ->
2598
                      loop xs
2599
                        (arg0, arg1,
2600
                          ((function
2601
                            | `List xs ->
2602
                                map_bind
2603
                                  (fun x  -> vhdl_assoc_element_t_of_yojson x)
2604
                                  [] xs
2605
                            | _ ->
2606
                                Result.Error
2607
                                  "Vhdl_ast.vhdl_sequential_stmt_t.assocs") x))
2608
                  | [] ->
2609
                      arg2 >>=
2610
                        ((fun arg2  ->
2611
                            arg1 >>=
2612
                              (fun arg1  ->
2613
                                 arg0 >>=
2614
                                   (fun arg0  ->
2615
                                      Result.Ok
2616
                                        (ProcedureCall
2617
                                           {
2618
                                             label = arg0;
2619
                                             name = arg1;
2620
                                             assocs = arg2
2621
                                           })))))
2622
                  | _::xs -> loop xs _state  in
2623
                loop xs
2624
                  ((Result.Ok NoName),
2625
                    (Result.Error "Vhdl_ast.vhdl_sequential_stmt_t.name"),
2626
                    (Result.Ok []))
2627
            | _ -> Result.Error "Vhdl_ast.vhdl_sequential_stmt_t")) arg0
2628
      | `List ((`String "WAIT_STATEMENT")::[]) -> Result.Ok Wait
2629
      | `List ((`String "NULL_STATEMENT")::arg0::[]) ->
2630
          ((function
2631
            | `Assoc xs ->
2632
                let rec loop xs (arg0 as _state) =
2633
                  match xs with
2634
                  | ("label",x)::xs ->
2635
                      loop xs ((fun x  -> vhdl_name_t_of_yojson x) x)
2636
                  | [] ->
2637
                      arg0 >>=
2638
                        ((fun arg0  -> Result.Ok (Null { label = arg0 })))
2639
                  | _::xs -> loop xs _state  in
2640
                loop xs (Result.Ok NoName)
2641
            | _ -> Result.Error "Vhdl_ast.vhdl_sequential_stmt_t")) arg0
2642
      | `List ((`String "RETURN_STATEMENT")::arg0::[]) ->
2643
          ((function
2644
            | `Assoc xs ->
2645
                let rec loop xs ((arg0,arg1) as _state) =
2646
                  match xs with
2647
                  | ("label",x)::xs ->
2648
                      loop xs
2649
                        (((function
2650
                           | `Null -> Result.Ok None
2651
                           | x ->
2652
                               ((fun x  -> vhdl_name_t_of_yojson x) x) >>=
2653
                                 ((fun x  -> Result.Ok (Some x)))) x), arg1)
2654
                  | ("expr",x)::xs ->
2655
                      loop xs
2656
                        (arg0,
2657
                          ((function
2658
                            | `Null -> Result.Ok None
2659
                            | x ->
2660
                                ((fun x  -> vhdl_expr_t_of_yojson x) x) >>=
2661
                                  ((fun x  -> Result.Ok (Some x)))) x))
2662
                  | [] ->
2663
                      arg1 >>=
2664
                        ((fun arg1  ->
2665
                            arg0 >>=
2666
                              (fun arg0  ->
2667
                                 Result.Ok
2668
                                   (Return { label = arg0; expr = arg1 }))))
2669
                  | _::xs -> loop xs _state  in
2670
                loop xs ((Result.Ok None), (Result.Ok None))
2671
            | _ -> Result.Error "Vhdl_ast.vhdl_sequential_stmt_t")) arg0
2672
      | _ -> Result.Error "Vhdl_ast.vhdl_sequential_stmt_t")
2673
  [@ocaml.warning "-A"])
2674

    
2675
and (vhdl_if_case_t_to_yojson : vhdl_if_case_t -> Yojson.Safe.json) =
2676
  ((let open! Ppx_deriving_yojson_runtime in
2677
      fun x  ->
2678
        let fields = []  in
2679
        let fields =
2680
          ("if_block",
2681
            ((fun x  ->
2682
                `List
2683
                  (List.map (fun x  -> vhdl_sequential_stmt_t_to_yojson x) x))
2684
               x.if_block))
2685
          :: fields  in
2686
        let fields =
2687
          ("if_cond", ((fun x  -> vhdl_expr_t_to_yojson x) x.if_cond)) ::
2688
          fields  in
2689
        `Assoc fields)
2690
  [@ocaml.warning "-A"])
2691

    
2692
and (vhdl_if_case_t_of_yojson :
2693
      Yojson.Safe.json -> vhdl_if_case_t Ppx_deriving_yojson_runtime.error_or)
2694
  =
2695
  ((let open! Ppx_deriving_yojson_runtime in
2696
      function
2697
      | `Assoc xs ->
2698
          let rec loop xs ((arg0,arg1) as _state) =
2699
            match xs with
2700
            | ("if_cond",x)::xs ->
2701
                loop xs (((fun x  -> vhdl_expr_t_of_yojson x) x), arg1)
2702
            | ("if_block",x)::xs ->
2703
                loop xs
2704
                  (arg0,
2705
                    ((function
2706
                      | `List xs ->
2707
                          map_bind
2708
                            (fun x  -> vhdl_sequential_stmt_t_of_yojson x) []
2709
                            xs
2710
                      | _ -> Result.Error "Vhdl_ast.vhdl_if_case_t.if_block")
2711
                       x))
2712
            | [] ->
2713
                arg1 >>=
2714
                  ((fun arg1  ->
2715
                      arg0 >>=
2716
                        (fun arg0  ->
2717
                           Result.Ok { if_cond = arg0; if_block = arg1 })))
2718
            | _::xs -> loop xs _state  in
2719
          loop xs
2720
            ((Result.Error "Vhdl_ast.vhdl_if_case_t.if_cond"),
2721
              (Result.Error "Vhdl_ast.vhdl_if_case_t.if_block"))
2722
      | _ -> Result.Error "Vhdl_ast.vhdl_if_case_t")
2723
  [@ocaml.warning "-A"])
2724

    
2725
and (vhdl_case_item_t_to_yojson : vhdl_case_item_t -> Yojson.Safe.json) =
2726
  ((let open! Ppx_deriving_yojson_runtime in
2727
      fun x  ->
2728
        let fields = []  in
2729
        let fields =
2730
          ("when_stmt",
2731
            ((fun x  ->
2732
                `List
2733
                  (List.map (fun x  -> vhdl_sequential_stmt_t_to_yojson x) x))
2734
               x.when_stmt))
2735
          :: fields  in
2736
        let fields =
2737
          ("when_cond",
2738
            ((fun x  ->
2739
                `List (List.map (fun x  -> vhdl_expr_t_to_yojson x) x))
2740
               x.when_cond))
2741
          :: fields  in
2742
        `Assoc fields)
2743
  [@ocaml.warning "-A"])
2744

    
2745
and (vhdl_case_item_t_of_yojson :
2746
      Yojson.Safe.json ->
2747
        vhdl_case_item_t Ppx_deriving_yojson_runtime.error_or)
2748
  =
2749
  ((let open! Ppx_deriving_yojson_runtime in
2750
      function
2751
      | `Assoc xs ->
2752
          let rec loop xs ((arg0,arg1) as _state) =
2753
            match xs with
2754
            | ("when_cond",x)::xs ->
2755
                loop xs
2756
                  (((function
2757
                     | `List xs ->
2758
                         map_bind (fun x  -> vhdl_expr_t_of_yojson x) [] xs
2759
                     | _ ->
2760
                         Result.Error "Vhdl_ast.vhdl_case_item_t.when_cond")
2761
                      x), arg1)
2762
            | ("when_stmt",x)::xs ->
2763
                loop xs
2764
                  (arg0,
2765
                    ((function
2766
                      | `List xs ->
2767
                          map_bind
2768
                            (fun x  -> vhdl_sequential_stmt_t_of_yojson x) []
2769
                            xs
2770
                      | _ ->
2771
                          Result.Error "Vhdl_ast.vhdl_case_item_t.when_stmt")
2772
                       x))
2773
            | [] ->
2774
                arg1 >>=
2775
                  ((fun arg1  ->
2776
                      arg0 >>=
2777
                        (fun arg0  ->
2778
                           Result.Ok { when_cond = arg0; when_stmt = arg1 })))
2779
            | _::xs -> loop xs _state  in
2780
          loop xs
2781
            ((Result.Error "Vhdl_ast.vhdl_case_item_t.when_cond"),
2782
              (Result.Error "Vhdl_ast.vhdl_case_item_t.when_stmt"))
2783
      | _ -> Result.Error "Vhdl_ast.vhdl_case_item_t")
2784
  [@ocaml.warning "-A"])
2785

    
2786
let rec (vhdl_port_mode_t_to_yojson : vhdl_port_mode_t -> Yojson.Safe.json) =
2787
  ((let open! Ppx_deriving_yojson_runtime in
2788
      function
2789
      | InPort  -> `List [`String "in"]
2790
      | OutPort  -> `List [`String "out"]
2791
      | InoutPort  -> `List [`String "inout"]
2792
      | BufferPort  -> `List [`String "buffer"])
2793
  [@ocaml.warning "-A"])
2794

    
2795
and (vhdl_port_mode_t_of_yojson :
2796
      Yojson.Safe.json ->
2797
        vhdl_port_mode_t Ppx_deriving_yojson_runtime.error_or)
2798
  =
2799
  ((let open! Ppx_deriving_yojson_runtime in
2800
      function
2801
      | `List ((`String "in")::[]) -> Result.Ok InPort
2802
      | `List ((`String "out")::[]) -> Result.Ok OutPort
2803
      | `List ((`String "inout")::[]) -> Result.Ok InoutPort
2804
      | `List ((`String "buffer")::[]) -> Result.Ok BufferPort
2805
      | _ -> Result.Error "Vhdl_ast.vhdl_port_mode_t")
2806
  [@ocaml.warning "-A"])
2807

    
2808
let rec (vhdl_port_t_to_yojson : vhdl_port_t -> Yojson.Safe.json) =
2809
  ((let open! Ppx_deriving_yojson_runtime in
2810
      fun x  ->
2811
        let fields = []  in
2812
        let fields =
2813
          if x.expr = IsNull
2814
          then fields
2815
          else ("expr", (((fun x  -> vhdl_expr_t_to_yojson x)) x.expr)) ::
2816
            fields
2817
           in
2818
        let fields =
2819
          ("typ", ((fun x  -> vhdl_subtype_indication_t_to_yojson x) x.typ))
2820
          :: fields  in
2821
        let fields =
2822
          if x.mode = InPort
2823
          then fields
2824
          else ("mode", (((fun x  -> vhdl_port_mode_t_to_yojson x)) x.mode))
2825
            :: fields
2826
           in
2827
        let fields =
2828
          if x.names = []
2829
          then fields
2830
          else
2831
            ("names",
2832
              (((fun x  ->
2833
                   `List (List.map (fun x  -> vhdl_name_t_to_yojson x) x)))
2834
                 x.names))
2835
            :: fields
2836
           in
2837
        `Assoc fields)
2838
  [@ocaml.warning "-A"])
2839

    
2840
and (vhdl_port_t_of_yojson :
2841
      Yojson.Safe.json -> vhdl_port_t Ppx_deriving_yojson_runtime.error_or)
2842
  =
2843
  ((let open! Ppx_deriving_yojson_runtime in
2844
      function
2845
      | `Assoc xs ->
2846
          let rec loop xs ((arg0,arg1,arg2,arg3) as _state) =
2847
            match xs with
2848
            | ("names",x)::xs ->
2849
                loop xs
2850
                  (((function
2851
                     | `List xs ->
2852
                         map_bind (fun x  -> vhdl_name_t_of_yojson x) [] xs
2853
                     | _ -> Result.Error "Vhdl_ast.vhdl_port_t.names") x),
2854
                    arg1, arg2, arg3)
2855
            | ("mode",x)::xs ->
2856
                loop xs
2857
                  (arg0, ((fun x  -> vhdl_port_mode_t_of_yojson x) x), arg2,
2858
                    arg3)
2859
            | ("typ",x)::xs ->
2860
                loop xs
2861
                  (arg0, arg1,
2862
                    ((fun x  -> vhdl_subtype_indication_t_of_yojson x) x),
2863
                    arg3)
2864
            | ("expr",x)::xs ->
2865
                loop xs
2866
                  (arg0, arg1, arg2, ((fun x  -> vhdl_expr_t_of_yojson x) x))
2867
            | [] ->
2868
                arg3 >>=
2869
                  ((fun arg3  ->
2870
                      arg2 >>=
2871
                        (fun arg2  ->
2872
                           arg1 >>=
2873
                             (fun arg1  ->
2874
                                arg0 >>=
2875
                                  (fun arg0  ->
2876
                                     Result.Ok
2877
                                       {
2878
                                         names = arg0;
2879
                                         mode = arg1;
2880
                                         typ = arg2;
2881
                                         expr = arg3
2882
                                       })))))
2883
            | _::xs -> loop xs _state  in
2884
          loop xs
2885
            ((Result.Ok []), (Result.Ok InPort),
2886
              (Result.Error "Vhdl_ast.vhdl_port_t.typ"), (Result.Ok IsNull))
2887
      | _ -> Result.Error "Vhdl_ast.vhdl_port_t")
2888
  [@ocaml.warning "-A"])
2889

    
2890
let rec (vhdl_declaration_t_to_yojson :
2891
          vhdl_declaration_t -> Yojson.Safe.json)
2892
  =
2893
  ((let open! Ppx_deriving_yojson_runtime in
2894
      function
2895
      | VarDecl arg0 ->
2896
          `List
2897
            [`String "VARIABLE_DECLARATION";
2898
            (let fields = []  in
2899
             let fields =
2900
               if arg0.init_val = IsNull
2901
               then fields
2902
               else
2903
                 ("init_val",
2904
                   (((fun x  -> vhdl_expr_t_to_yojson x)) arg0.init_val))
2905
                 :: fields
2906
                in
2907
             let fields =
2908
               ("typ",
2909
                 ((fun x  -> vhdl_subtype_indication_t_to_yojson x) arg0.typ))
2910
               :: fields  in
2911
             let fields =
2912
               ("names",
2913
                 ((fun x  ->
2914
                     `List (List.map (fun x  -> vhdl_name_t_to_yojson x) x))
2915
                    arg0.names))
2916
               :: fields  in
2917
             `Assoc fields)]
2918
      | CstDecl arg0 ->
2919
          `List
2920
            [`String "CONSTANT_DECLARATION";
2921
            (let fields = []  in
2922
             let fields =
2923
               ("init_val",
2924
                 ((fun x  -> vhdl_expr_t_to_yojson x) arg0.init_val))
2925
               :: fields  in
2926
             let fields =
2927
               ("typ",
2928
                 ((fun x  -> vhdl_subtype_indication_t_to_yojson x) arg0.typ))
2929
               :: fields  in
2930
             let fields =
2931
               ("names",
2932
                 ((fun x  ->
2933
                     `List (List.map (fun x  -> vhdl_name_t_to_yojson x) x))
2934
                    arg0.names))
2935
               :: fields  in
2936
             `Assoc fields)]
2937
      | SigDecl arg0 ->
2938
          `List
2939
            [`String "SIGNAL_DECLARATION";
2940
            (let fields = []  in
2941
             let fields =
2942
               if arg0.init_val = IsNull
2943
               then fields
2944
               else
2945
                 ("init_val",
2946
                   (((fun x  -> vhdl_expr_t_to_yojson x)) arg0.init_val))
2947
                 :: fields
2948
                in
2949
             let fields =
2950
               ("typ",
2951
                 ((fun x  -> vhdl_subtype_indication_t_to_yojson x) arg0.typ))
2952
               :: fields  in
2953
             let fields =
2954
               ("names",
2955
                 ((fun x  ->
2956
                     `List (List.map (fun x  -> vhdl_name_t_to_yojson x) x))
2957
                    arg0.names))
2958
               :: fields  in
2959
             `Assoc fields)]
2960
      | ComponentDecl arg0 ->
2961
          `List
2962
            [`String "COMPONENT_DECLARATION";
2963
            (let fields = []  in
2964
             let fields =
2965
               if arg0.ports = []
2966
               then fields
2967
               else
2968
                 ("ports",
2969
                   (((fun x  ->
2970
                        `List
2971
                          (List.map (fun x  -> vhdl_port_t_to_yojson x) x)))
2972
                      arg0.ports))
2973
                 :: fields
2974
                in
2975
             let fields =
2976
               if arg0.generics = []
2977
               then fields
2978
               else
2979
                 ("generics",
2980
                   (((fun x  ->
2981
                        `List
2982
                          (List.map (fun x  -> vhdl_port_t_to_yojson x) x)))
2983
                      arg0.generics))
2984
                 :: fields
2985
                in
2986
             let fields =
2987
               if arg0.name = NoName
2988
               then fields
2989
               else
2990
                 ("name", (((fun x  -> vhdl_name_t_to_yojson x)) arg0.name))
2991
                 :: fields
2992
                in
2993
             `Assoc fields)]
2994
      | Subprogram arg0 ->
2995
          `List
2996
            [`String "SUBPROGRAM_BODY";
2997
            (let fields = []  in
2998
             let fields =
2999
               if arg0.stmts = []
3000
               then fields
3001
               else
3002
                 ("stmts",
3003
                   (((fun x  ->
3004
                        `List
3005
                          (List.map
3006
                             (fun x  -> vhdl_sequential_stmt_t_to_yojson x) x)))
3007
                      arg0.stmts))
3008
                 :: fields
3009
                in
3010
             let fields =
3011
               if arg0.decl_part = []
3012
               then fields
3013
               else
3014
                 ("decl_part",
3015
                   (((fun x  ->
3016
                        `List
3017
                          (List.map
3018
                             (fun x  -> vhdl_declaration_t_to_yojson x) x)))
3019
                      arg0.decl_part))
3020
                 :: fields
3021
                in
3022
             let fields =
3023
               ("spec",
3024
                 ((fun x  -> vhdl_subprogram_spec_t_to_yojson x) arg0.spec))
3025
               :: fields  in
3026
             `Assoc fields)])
3027
  [@ocaml.warning "-A"])
3028

    
3029
and (vhdl_declaration_t_of_yojson :
3030
      Yojson.Safe.json ->
3031
        vhdl_declaration_t Ppx_deriving_yojson_runtime.error_or)
3032
  =
3033
  ((let open! Ppx_deriving_yojson_runtime in
3034
      function
3035
      | `List ((`String "VARIABLE_DECLARATION")::arg0::[]) ->
3036
          ((function
3037
            | `Assoc xs ->
3038
                let rec loop xs ((arg0,arg1,arg2) as _state) =
3039
                  match xs with
3040
                  | ("names",x)::xs ->
3041
                      loop xs
3042
                        (((function
3043
                           | `List xs ->
3044
                               map_bind (fun x  -> vhdl_name_t_of_yojson x)
3045
                                 [] xs
3046
                           | _ ->
3047
                               Result.Error
3048
                                 "Vhdl_ast.vhdl_declaration_t.names") x),
3049
                          arg1, arg2)
3050
                  | ("typ",x)::xs ->
3051
                      loop xs
3052
                        (arg0,
3053
                          ((fun x  -> vhdl_subtype_indication_t_of_yojson x)
3054
                             x), arg2)
3055
                  | ("init_val",x)::xs ->
3056
                      loop xs
3057
                        (arg0, arg1, ((fun x  -> vhdl_expr_t_of_yojson x) x))
3058
                  | [] ->
3059
                      arg2 >>=
3060
                        ((fun arg2  ->
3061
                            arg1 >>=
3062
                              (fun arg1  ->
3063
                                 arg0 >>=
3064
                                   (fun arg0  ->
3065
                                      Result.Ok
3066
                                        (VarDecl
3067
                                           {
3068
                                             names = arg0;
3069
                                             typ = arg1;
3070
                                             init_val = arg2
3071
                                           })))))
3072
                  | _::xs -> loop xs _state  in
3073
                loop xs
3074
                  ((Result.Error "Vhdl_ast.vhdl_declaration_t.names"),
3075
                    (Result.Error "Vhdl_ast.vhdl_declaration_t.typ"),
3076
                    (Result.Ok IsNull))
3077
            | _ -> Result.Error "Vhdl_ast.vhdl_declaration_t")) arg0
3078
      | `List ((`String "CONSTANT_DECLARATION")::arg0::[]) ->
3079
          ((function
3080
            | `Assoc xs ->
3081
                let rec loop xs ((arg0,arg1,arg2) as _state) =
3082
                  match xs with
3083
                  | ("names",x)::xs ->
3084
                      loop xs
3085
                        (((function
3086
                           | `List xs ->
3087
                               map_bind (fun x  -> vhdl_name_t_of_yojson x)
3088
                                 [] xs
3089
                           | _ ->
3090
                               Result.Error
3091
                                 "Vhdl_ast.vhdl_declaration_t.names") x),
3092
                          arg1, arg2)
3093
                  | ("typ",x)::xs ->
3094
                      loop xs
3095
                        (arg0,
3096
                          ((fun x  -> vhdl_subtype_indication_t_of_yojson x)
3097
                             x), arg2)
3098
                  | ("init_val",x)::xs ->
3099
                      loop xs
3100
                        (arg0, arg1, ((fun x  -> vhdl_expr_t_of_yojson x) x))
3101
                  | [] ->
3102
                      arg2 >>=
3103
                        ((fun arg2  ->
3104
                            arg1 >>=
3105
                              (fun arg1  ->
3106
                                 arg0 >>=
3107
                                   (fun arg0  ->
3108
                                      Result.Ok
3109
                                        (CstDecl
3110
                                           {
3111
                                             names = arg0;
3112
                                             typ = arg1;
3113
                                             init_val = arg2
3114
                                           })))))
3115
                  | _::xs -> loop xs _state  in
3116
                loop xs
3117
                  ((Result.Error "Vhdl_ast.vhdl_declaration_t.names"),
3118
                    (Result.Error "Vhdl_ast.vhdl_declaration_t.typ"),
3119
                    (Result.Error "Vhdl_ast.vhdl_declaration_t.init_val"))
3120
            | _ -> Result.Error "Vhdl_ast.vhdl_declaration_t")) arg0
3121
      | `List ((`String "SIGNAL_DECLARATION")::arg0::[]) ->
3122
          ((function
3123
            | `Assoc xs ->
3124
                let rec loop xs ((arg0,arg1,arg2) as _state) =
3125
                  match xs with
3126
                  | ("names",x)::xs ->
3127
                      loop xs
3128
                        (((function
3129
                           | `List xs ->
3130
                               map_bind (fun x  -> vhdl_name_t_of_yojson x)
3131
                                 [] xs
3132
                           | _ ->
3133
                               Result.Error
3134
                                 "Vhdl_ast.vhdl_declaration_t.names") x),
3135
                          arg1, arg2)
3136
                  | ("typ",x)::xs ->
3137
                      loop xs
3138
                        (arg0,
3139
                          ((fun x  -> vhdl_subtype_indication_t_of_yojson x)
3140
                             x), arg2)
3141
                  | ("init_val",x)::xs ->
3142
                      loop xs
3143
                        (arg0, arg1, ((fun x  -> vhdl_expr_t_of_yojson x) x))
3144
                  | [] ->
3145
                      arg2 >>=
3146
                        ((fun arg2  ->
3147
                            arg1 >>=
3148
                              (fun arg1  ->
3149
                                 arg0 >>=
3150
                                   (fun arg0  ->
3151
                                      Result.Ok
3152
                                        (SigDecl
3153
                                           {
3154
                                             names = arg0;
3155
                                             typ = arg1;
3156
                                             init_val = arg2
3157
                                           })))))
3158
                  | _::xs -> loop xs _state  in
3159
                loop xs
3160
                  ((Result.Error "Vhdl_ast.vhdl_declaration_t.names"),
3161
                    (Result.Error "Vhdl_ast.vhdl_declaration_t.typ"),
3162
                    (Result.Ok IsNull))
3163
            | _ -> Result.Error "Vhdl_ast.vhdl_declaration_t")) arg0
3164
      | `List ((`String "COMPONENT_DECLARATION")::arg0::[]) ->
3165
          ((function
3166
            | `Assoc xs ->
3167
                let rec loop xs ((arg0,arg1,arg2) as _state) =
3168
                  match xs with
3169
                  | ("name",x)::xs ->
3170
                      loop xs
3171
                        (((fun x  -> vhdl_name_t_of_yojson x) x), arg1, arg2)
3172
                  | ("generics",x)::xs ->
3173
                      loop xs
3174
                        (arg0,
3175
                          ((function
3176
                            | `List xs ->
3177
                                map_bind (fun x  -> vhdl_port_t_of_yojson x)
3178
                                  [] xs
3179
                            | _ ->
3180
                                Result.Error
3181
                                  "Vhdl_ast.vhdl_declaration_t.generics") x),
3182
                          arg2)
3183
                  | ("ports",x)::xs ->
3184
                      loop xs
3185
                        (arg0, arg1,
3186
                          ((function
3187
                            | `List xs ->
3188
                                map_bind (fun x  -> vhdl_port_t_of_yojson x)
3189
                                  [] xs
3190
                            | _ ->
3191
                                Result.Error
3192
                                  "Vhdl_ast.vhdl_declaration_t.ports") x))
3193
                  | [] ->
3194
                      arg2 >>=
3195
                        ((fun arg2  ->
3196
                            arg1 >>=
3197
                              (fun arg1  ->
3198
                                 arg0 >>=
3199
                                   (fun arg0  ->
3200
                                      Result.Ok
3201
                                        (ComponentDecl
3202
                                           {
3203
                                             name = arg0;
3204
                                             generics = arg1;
3205
                                             ports = arg2
3206
                                           })))))
3207
                  | _::xs -> loop xs _state  in
3208
                loop xs ((Result.Ok NoName), (Result.Ok []), (Result.Ok []))
3209
            | _ -> Result.Error "Vhdl_ast.vhdl_declaration_t")) arg0
3210
      | `List ((`String "SUBPROGRAM_BODY")::arg0::[]) ->
3211
          ((function
3212
            | `Assoc xs ->
3213
                let rec loop xs ((arg0,arg1,arg2) as _state) =
3214
                  match xs with
3215
                  | ("spec",x)::xs ->
3216
                      loop xs
3217
                        (((fun x  -> vhdl_subprogram_spec_t_of_yojson x) x),
3218
                          arg1, arg2)
3219
                  | ("decl_part",x)::xs ->
3220
                      loop xs
3221
                        (arg0,
3222
                          ((function
3223
                            | `List xs ->
3224
                                map_bind
3225
                                  (fun x  -> vhdl_declaration_t_of_yojson x)
3226
                                  [] xs
3227
                            | _ ->
3228
                                Result.Error
3229
                                  "Vhdl_ast.vhdl_declaration_t.decl_part") x),
3230
                          arg2)
3231
                  | ("stmts",x)::xs ->
3232
                      loop xs
3233
                        (arg0, arg1,
3234
                          ((function
3235
                            | `List xs ->
3236
                                map_bind
3237
                                  (fun x  ->
3238
                                     vhdl_sequential_stmt_t_of_yojson x) []
3239
                                  xs
3240
                            | _ ->
3241
                                Result.Error
3242
                                  "Vhdl_ast.vhdl_declaration_t.stmts") x))
3243
                  | [] ->
3244
                      arg2 >>=
3245
                        ((fun arg2  ->
3246
                            arg1 >>=
3247
                              (fun arg1  ->
3248
                                 arg0 >>=
3249
                                   (fun arg0  ->
3250
                                      Result.Ok
3251
                                        (Subprogram
3252
                                           {
3253
                                             spec = arg0;
3254
                                             decl_part = arg1;
3255
                                             stmts = arg2
3256
                                           })))))
3257
                  | _::xs -> loop xs _state  in
3258
                loop xs
3259
                  ((Result.Error "Vhdl_ast.vhdl_declaration_t.spec"),
3260
                    (Result.Ok []), (Result.Ok []))
3261
            | _ -> Result.Error "Vhdl_ast.vhdl_declaration_t")) arg0
3262
      | _ -> Result.Error "Vhdl_ast.vhdl_declaration_t")
3263
  [@ocaml.warning "-A"])
3264

    
3265
let rec (vhdl_load_t_to_yojson : vhdl_load_t -> Yojson.Safe.json) =
3266
  ((let open! Ppx_deriving_yojson_runtime in
3267
      function
3268
      | Library arg0 ->
3269
          `List
3270
            [`String "LIBRARY_CLAUSE";
3271
            ((fun x  ->
3272
                `List (List.map (fun x  -> vhdl_name_t_to_yojson x) x))) arg0]
3273
      | Use arg0 ->
3274
          `List
3275
            [`String "USE_CLAUSE";
3276
            ((fun x  ->
3277
                `List (List.map (fun x  -> vhdl_name_t_to_yojson x) x))) arg0])
3278
  [@ocaml.warning "-A"])
3279

    
3280
and (vhdl_load_t_of_yojson :
3281
      Yojson.Safe.json -> vhdl_load_t Ppx_deriving_yojson_runtime.error_or)
3282
  =
3283
  ((let open! Ppx_deriving_yojson_runtime in
3284
      function
3285
      | `List ((`String "LIBRARY_CLAUSE")::arg0::[]) ->
3286
          ((function
3287
            | `List xs -> map_bind (fun x  -> vhdl_name_t_of_yojson x) [] xs
3288
            | _ -> Result.Error "Vhdl_ast.vhdl_load_t") arg0) >>=
3289
            ((fun arg0  -> Result.Ok (Library arg0)))
3290
      | `List ((`String "USE_CLAUSE")::arg0::[]) ->
3291
          ((function
3292
            | `List xs -> map_bind (fun x  -> vhdl_name_t_of_yojson x) [] xs
3293
            | _ -> Result.Error "Vhdl_ast.vhdl_load_t") arg0) >>=
3294
            ((fun arg0  -> Result.Ok (Use arg0)))
3295
      | _ -> Result.Error "Vhdl_ast.vhdl_load_t")
3296
  [@ocaml.warning "-A"])
3297

    
3298
let rec (vhdl_declarative_item_t_to_yojson :
3299
          vhdl_declarative_item_t -> Yojson.Safe.json)
3300
  =
3301
  ((let open! Ppx_deriving_yojson_runtime in
3302
      fun x  ->
3303
        let fields = []  in
3304
        let fields =
3305
          if x.definition = None
3306
          then fields
3307
          else
3308
            ("definition",
3309
              (((function
3310
                 | None  -> `Null
3311
                 | Some x -> ((fun x  -> vhdl_definition_t_to_yojson x)) x))
3312
                 x.definition))
3313
            :: fields
3314
           in
3315
        let fields =
3316
          if x.declaration = None
3317
          then fields
3318
          else
3319
            ("declaration",
3320
              (((function
3321
                 | None  -> `Null
3322
                 | Some x -> ((fun x  -> vhdl_declaration_t_to_yojson x)) x))
3323
                 x.declaration))
3324
            :: fields
3325
           in
3326
        let fields =
3327
          if x.use_clause = None
3328
          then fields
3329
          else
3330
            ("use_clause",
3331
              (((function
3332
                 | None  -> `Null
3333
                 | Some x -> ((fun x  -> vhdl_load_t_to_yojson x)) x))
3334
                 x.use_clause))
3335
            :: fields
3336
           in
3337
        `Assoc fields)
3338
  [@ocaml.warning "-A"])
3339

    
3340
and (vhdl_declarative_item_t_of_yojson :
3341
      Yojson.Safe.json ->
3342
        vhdl_declarative_item_t Ppx_deriving_yojson_runtime.error_or)
3343
  =
3344
  ((let open! Ppx_deriving_yojson_runtime in
3345
      function
3346
      | `Assoc xs ->
3347
          let rec loop xs ((arg0,arg1,arg2) as _state) =
3348
            match xs with
3349
            | ("use_clause",x)::xs ->
3350
                loop xs
3351
                  (((function
3352
                     | `Null -> Result.Ok None
3353
                     | x ->
3354
                         ((fun x  -> vhdl_load_t_of_yojson x) x) >>=
3355
                           ((fun x  -> Result.Ok (Some x)))) x), arg1, arg2)
3356
            | ("declaration",x)::xs ->
3357
                loop xs
3358
                  (arg0,
3359
                    ((function
3360
                      | `Null -> Result.Ok None
3361
                      | x ->
3362
                          ((fun x  -> vhdl_declaration_t_of_yojson x) x) >>=
3363
                            ((fun x  -> Result.Ok (Some x)))) x), arg2)
3364
            | ("definition",x)::xs ->
3365
                loop xs
3366
                  (arg0, arg1,
3367
                    ((function
3368
                      | `Null -> Result.Ok None
3369
                      | x ->
3370
                          ((fun x  -> vhdl_definition_t_of_yojson x) x) >>=
3371
                            ((fun x  -> Result.Ok (Some x)))) x))
3372
            | [] ->
3373
                arg2 >>=
3374
                  ((fun arg2  ->
3375
                      arg1 >>=
3376
                        (fun arg1  ->
3377
                           arg0 >>=
3378
                             (fun arg0  ->
3379
                                Result.Ok
3380
                                  {
3381
                                    use_clause = arg0;
3382
                                    declaration = arg1;
3383
                                    definition = arg2
3384
                                  }))))
3385
            | _::xs -> loop xs _state  in
3386
          loop xs ((Result.Ok None), (Result.Ok None), (Result.Ok None))
3387
      | _ -> Result.Error "Vhdl_ast.vhdl_declarative_item_t")
3388
  [@ocaml.warning "-A"])
3389

    
3390
let rec (vhdl_signal_condition_t_to_yojson :
3391