Project

General

Profile

Revision 1f593d5d

View differences:

src/backends/VHDL/vhdl_ast.ml
254 254
type vhdl_signal_condition_t =
255 255
  {                            
256 256
    expr: vhdl_waveform_element_t list [@default []];              (* when expression *)
257
    cond: vhdl_expr_t [@default IsNull];  (* optional else case expression. 
257
    cond: vhdl_expr_t option [@default None];  (* optional else case expression. 
258 258
                                             If None, could be a latch  *)
259 259
  }
260 260
[@@deriving show { with_path = false }, yojson {strict = false}];;
......
272 272
    label: vhdl_name_t [@default NoName];
273 273
    lhs: vhdl_name_t;        (* assigned signal = target*)
274 274
    rhs: vhdl_signal_condition_t list;                   (* expression *)
275
    cond: vhdl_expr_t [@default IsNull];
276 275
    delay: vhdl_expr_t [@default IsNull];
277 276
  }
278 277
[@@deriving show { with_path = false }, yojson {strict = false}];;
src/backends/VHDL/vhdl_ast_deriving.ml
440 440
and show_vhdl_definition_t : vhdl_definition_t -> Ppx_deriving_runtime.string
441 441
  = fun x  -> Format.asprintf "%a" pp_vhdl_definition_t x
442 442

  
443
(* TODO adapt for Op, Time, Sig, suffixMod *)
443
(* TODO adapt for Op (more than 2 operand), Time, Sig, suffixMod *)
444 444
and pp_vhdl_expr_t :
445 445
  Format.formatter -> vhdl_expr_t -> Ppx_deriving_runtime.unit =
446 446
  let __11 () = pp_vhdl_expr_t
......
2650 2650
  typ: vhdl_subtype_indication_t ;
2651 2651
  init_val: vhdl_cst_val_t option [@default None]}
2652 2652

  
2653
(* TODO *)
2654 2653
let rec pp_vhdl_parameter_t :
2655 2654
  Format.formatter -> vhdl_parameter_t -> Ppx_deriving_runtime.unit =
2656 2655
  let __2 () = pp_vhdl_cst_val_t
......
2662 2661
  ((let open! Ppx_deriving_runtime in
2663 2662
      fun fmt  ->
2664 2663
        fun x  ->
2665
          Format.fprintf fmt "@[<2>{ ";
2666
          ((((Format.fprintf fmt "@[%s =@ " "names";
2667
              ((fun x  ->
2668
                  Format.fprintf fmt "@[<2>[";
2669
                  ignore
2670
                    (List.fold_left
2671
                       (fun sep  ->
2672
                          fun x  ->
2673
                            if sep then Format.fprintf fmt ";@ ";
2674
                            ((__0 ()) fmt) x;
2675
                            true) false x);
2676
                  Format.fprintf fmt "@,]@]")) x.names;
2677
              Format.fprintf fmt "@]");
2678
             Format.fprintf fmt ";@ ";
2679
             Format.fprintf fmt "@[%s =@ " "mode";
2680
             ((fun x  ->
2681
                 Format.fprintf fmt "@[<2>[";
2682
                 ignore
2683
                   (List.fold_left
2684
                      (fun sep  ->
2685
                         fun x  ->
2686
                           if sep then Format.fprintf fmt ";@ ";
2687
                           (Format.fprintf fmt "%S") x;
2688
                           true) false x);
2689
                 Format.fprintf fmt "@,]@]")) x.mode;
2690
             Format.fprintf fmt "@]");
2691
            Format.fprintf fmt ";@ ";
2692
            Format.fprintf fmt "@[%s =@ " "typ";
2693
            ((__1 ()) fmt) x.typ;
2694
            Format.fprintf fmt "@]");
2695
           Format.fprintf fmt ";@ ";
2696
           Format.fprintf fmt "@[%s =@ " "init_val";
2697
           ((function
2698
             | None  -> Format.pp_print_string fmt "None"
2699
             | Some x ->
2700
                 (Format.pp_print_string fmt "(Some ";
2701
                  ((__2 ()) fmt) x;
2702
                  Format.pp_print_string fmt ")"))) x.init_val;
2703
           Format.fprintf fmt "@]");
2704
          Format.fprintf fmt "@ }@]")
2664
          ((fun x  ->
2665
             ignore
2666
               (List.fold_left
2667
                 (fun sep  ->
2668
                   fun x  ->
2669
                     if sep then Format.fprintf fmt ", ";
2670
                       ((__0 ()) fmt) x;
2671
                       true) false x))) x.names;
2672
          ((fun x  ->
2673
             ignore
2674
               (List.fold_left
2675
                 (fun sep  ->
2676
                   fun x  ->
2677
                     if sep then Format.fprintf fmt "";
2678
                       Format.fprintf fmt ": %s" x;
2679
                       true) false x))) x.mode;
2680
          ((__1 ()) fmt) x.typ;
2681
          (match x.init_val with
2682
           | None  -> Format.pp_print_string fmt ""
2683
           | Some x ->
2684
                 (Format.pp_print_string fmt " := ";
2685
                 ((__2 ()) fmt) x));)
2705 2686
    [@ocaml.warning "-A"])
2706 2687

  
2707 2688
and show_vhdl_parameter_t : vhdl_parameter_t -> Ppx_deriving_runtime.string =
......
2820 2801
  parameters: vhdl_parameter_t list ;
2821 2802
  isPure: bool [@default false]}
2822 2803

  
2823
(* TODO *)
2824 2804
let rec pp_vhdl_subprogram_spec_t :
2825 2805
  Format.formatter -> vhdl_subprogram_spec_t -> Ppx_deriving_runtime.unit =
2826 2806
  let __1 () = pp_vhdl_parameter_t
......
2833 2813
          (match x.subprogram_type with
2834 2814
          | "function" -> 
2835 2815
              if (x.isPure) then
2836
                Format.fprintf fmt "pure %s" x.subprogram_type
2816
                Format.fprintf fmt "pure %s %s" x.subprogram_type x.name
2837 2817
              else
2838
                Format.fprintf fmt "impure %s" x.subprogram_type
2818
                Format.fprintf fmt "impure %s %s" x.subprogram_type x.name
2839 2819
          | "procedure" ->
2840 2820
              Format.fprintf fmt "%s %s" x.subprogram_type x.name);
2841 2821
          (match x.parameters with
......
2854 2834
          (match x.typeMark with
2855 2835
          | NoName -> Format.fprintf fmt "";
2856 2836
          | _ -> 
2857
              Format.fprintf fmt "returns ";
2837
              Format.fprintf fmt "return ";
2858 2838
              ((__0 ()) fmt) x.typeMark))
2859 2839
   [@ocaml.warning "-A"])
2860 2840

  
......
3260 3240
               (List.fold_left
3261 3241
                 (fun sep  ->
3262 3242
                   fun x  ->
3263
                           if sep then Format.fprintf fmt "@;elseif";
3243
                           if sep then Format.fprintf fmt "@;elsif";
3264 3244
                                ((__7 ()) fmt) x;
3265 3245
                                true
3266 3246
                 ) false x);
......
3276 3256
                                fun x  ->
3277 3257
                                        if sep then Format.fprintf fmt "";
3278 3258
                          ((__8 ()) fmt) x;
3259
                          Format.fprintf fmt ";";
3279 3260
                          true) false x))) adefault));
3280 3261
            Format.fprintf fmt "@;end if@]"
3281 3262
        | Case { label = alabel; guard = aguard; branches = abranches } ->
......
3308 3289
            Format.fprintf fmt "exit";
3309 3290
            (match aloop_label with
3310 3291
               | None  -> Format.pp_print_string fmt ""
3311
               | Some x -> (Format.fprintf fmt "@ %s@ ") x);
3292
               | Some x -> (Format.fprintf fmt "@ %s@ ") x);
3312 3293
            ((function
3313 3294
               | None  -> Format.pp_print_string fmt ""
3314 3295
               | Some x ->
......
3397 3378
                     fun x  ->
3398 3379
                             if sep then Format.fprintf fmt "@;<0 2>";
3399 3380
                       ((__1 ()) fmt) x;
3381
                       Format.fprintf fmt ";";
3400 3382
                       true) false x);
3401 3383
          )) x.if_block;)
3402 3384
    [@ocaml.warning "-A"])
......
3422 3404
                          if sep then Format.fprintf fmt "@ |@ ";
3423 3405
                          ((__0 ()) fmt) x;
3424 3406
                          true) false x);)) x.when_cond;
3425
           Format.fprintf fmt " => ";
3407
           Format.fprintf fmt " => ";
3426 3408
           (fun x  ->
3427 3409
               ignore
3428 3410
                 (List.fold_left
......
4384 4366
                              if sep then Format.fprintf fmt ",";
4385 4367
                              ((__3 ()) fmt) x;
4386 4368
                              true) false x);)) anames;
4387
               Format.fprintf fmt " : ";
4388
               ((__4 ()) fmt) atyp;
4389
              Format.fprintf fmt ":=";
4369
              Format.fprintf fmt " : ";
4370
              ((__4 ()) fmt) atyp;
4371
              Format.fprintf fmt " := ";
4390 4372
              ((__5 ()) fmt) ainit_val)))
4391 4373
        | SigDecl { names = anames; typ = atyp; init_val = ainit_val } ->
4392 4374
            (Format.fprintf fmt "signal ";
......
4863 4845
                         fun x  ->
4864 4846
                           if sep then Format.fprintf fmt ".";
4865 4847
                           ((__0 ()) fmt) x;
4866
                           true) false x))) a0;
4867
             Format.fprintf fmt ":")
4848
                           true) false x))) a0);
4868 4849
        | Use a0 ->
4869 4850
            (Format.fprintf fmt "use ";
4870 4851
             ((fun x  ->
......
5048 5029

  
5049 5030
type vhdl_signal_condition_t =
5050 5031
  {
5051
  expr: vhdl_waveform_element_t list [@default []];
5052
  cond: vhdl_expr_t [@default IsNull]}[@@deriving
5053
                                        ((show { with_path = false }),
5054
                                          (yojson { strict = false }))]
5055

  
5032
    expr: vhdl_waveform_element_t list [@default []];
5033
  cond: vhdl_expr_t option [@default None]}[@@deriving
5034
                                             ((show { with_path = false }),
5035
                                               (yojson { strict = false }))]
5056 5036
let rec pp_vhdl_signal_condition_t :
5057 5037
  Format.formatter -> vhdl_signal_condition_t -> Ppx_deriving_runtime.unit =
5058 5038
  let __1 () = pp_vhdl_expr_t
......
5063 5043
      fun fmt  ->
5064 5044
        fun x  ->
5065 5045
          ((fun x  ->
5066
              ignore
5067
                (List.fold_left
5068
                   (fun sep  ->
5069
                      fun x  ->
5070
                        if sep then Format.fprintf fmt ";@ ";
5071
                        ((__0 ()) fmt) x;
5072
                        true) false x))) x.expr;
5046
                ignore
5047
                  (List.fold_left
5048
                     (fun sep  ->
5049
                        fun x  ->
5050
                          if sep then Format.fprintf fmt " else ";
5051
                          ((__0 ()) fmt) x;
5052
                          true) false x))) x.expr;
5073 5053
          (match x.cond with
5074
          | IsNull -> Format.fprintf fmt "";
5075
          | _ -> Format.fprintf fmt "when ";
5076
                 ((__1 ()) fmt) x.cond);)
5054
          | None -> Format.fprintf fmt "";
5055
          | Some e -> Format.fprintf fmt " when ";
5056
                 ((__1 ()) fmt) e);)
5077 5057
    [@ocaml.warning "-A"])
5078 5058

  
5079 5059
and show_vhdl_signal_condition_t :
......
5087 5067
      fun x  ->
5088 5068
        let fields = []  in
5089 5069
        let fields =
5090
          if x.cond = IsNull
5070
          if x.cond = None
5091 5071
          then fields
5092
          else ("cond", (((fun x  -> vhdl_expr_t_to_yojson x)) x.cond)) ::
5093
            fields
5072
          else
5073
            ("cond",
5074
              (((function
5075
                 | None  -> `Null
5076
                 | Some x -> ((fun x  -> vhdl_expr_t_to_yojson x)) x)) 
5077
                 x.cond))
5078
            :: fields
5094 5079
           in
5095 5080
        let fields =
5096 5081
          if x.expr = []
......
5127 5112
                         Result.Error "Vhdl_ast.vhdl_signal_condition_t.expr")
5128 5113
                      x), arg1)
5129 5114
            | ("cond",x)::xs ->
5130
                loop xs (arg0, ((fun x  -> vhdl_expr_t_of_yojson x) x))
5115
                loop xs
5116
                  (arg0,
5117
                    ((function
5118
                      | `Null -> Result.Ok None
5119
                      | x ->
5120
                          ((fun x  -> vhdl_expr_t_of_yojson x) x) >>=
5121
                            ((fun x  -> Result.Ok (Some x)))) x))
5131 5122
            | [] ->
5132 5123
                arg1 >>=
5133 5124
                  ((fun arg1  ->
5134 5125
                      arg0 >>=
5135 5126
                        (fun arg0  -> Result.Ok { expr = arg0; cond = arg1 })))
5136 5127
            | _::xs -> loop xs _state  in
5137
          loop xs ((Result.Ok []), (Result.Ok IsNull))
5128
          loop xs ((Result.Ok []), (Result.Ok None))
5138 5129
      | _ -> Result.Error "Vhdl_ast.vhdl_signal_condition_t")
5139 5130
  [@ocaml.warning "-A"])
5140 5131

  
......
5253 5244
  label: vhdl_name_t [@default NoName];
5254 5245
  lhs: vhdl_name_t ;
5255 5246
  rhs: vhdl_signal_condition_t list ;
5256
  cond: vhdl_expr_t [@default IsNull];
5257
  delay: vhdl_expr_t [@default IsNull]}
5258

  
5247
  delay: vhdl_expr_t [@default IsNull]}[@@deriving
5248
                                         ((show { with_path = false }),
5249
                                           (yojson { strict = false }))]
5259 5250
let rec pp_vhdl_conditional_signal_t :
5260 5251
  Format.formatter -> vhdl_conditional_signal_t -> Ppx_deriving_runtime.unit
5261 5252
  =
5262
  let __4 () = pp_vhdl_expr_t
5263
  
5264
  and __3 () = pp_vhdl_expr_t
5253
  let __3 () = pp_vhdl_expr_t
5265 5254
  
5266 5255
  and __2 () = pp_vhdl_signal_condition_t
5267 5256
  
......
5282 5271
          Format.fprintf fmt " <= ";
5283 5272
          (match x.delay with
5284 5273
            | IsNull -> Format.fprintf fmt "";
5285
            | _ -> ((__4 ()) fmt) x.delay;
5274
            | _ -> ((__3 ()) fmt) x.delay;
5286 5275
                   Format.fprintf fmt " ");
5287 5276
          ((fun x  ->
5288 5277
             Format.fprintf fmt "@[";
......
5290 5279
               (List.fold_left
5291 5280
                 (fun sep  ->
5292 5281
                   fun x  ->
5293
                     if sep then Format.fprintf fmt "";
5282
                     if sep then Format.fprintf fmt " else ";
5294 5283
                      ((__2 ()) fmt) x;
5295
                      Format.fprintf fmt ";";
5296 5284
                      true) false x);
5297 5285
          Format.fprintf fmt "@]")) x.rhs;
5298
          (match x.cond with
5299
            | IsNull -> Format.fprintf fmt "";
5300
            | _ -> Format.fprintf fmt "when (";
5301
                   ((__3 ()) fmt) x.cond;
5302
                   Format.fprintf fmt ")"))
5286
          Format.fprintf fmt ";")
5303 5287
   [@ocaml.warning "-A"])
5304 5288

  
5305 5289
and show_vhdl_conditional_signal_t :
......
5319 5303
            fields
5320 5304
           in
5321 5305
        let fields =
5322
          if x.cond = IsNull
5323
          then fields
5324
          else ("cond", (((fun x  -> vhdl_expr_t_to_yojson x)) x.cond)) ::
5325
            fields
5326
           in
5327
        let fields =
5328 5306
          ("rhs",
5329 5307
            ((fun x  ->
5330 5308
                `List
......
5358 5336
  ((let open! Ppx_deriving_yojson_runtime in
5359 5337
      function
5360 5338
      | `Assoc xs ->
5361
          let rec loop xs ((arg0,arg1,arg2,arg3,arg4,arg5) as _state) =
5339
          let rec loop xs ((arg0,arg1,arg2,arg3,arg4) as _state) =
5362 5340
            match xs with
5363 5341
            | ("postponed",x)::xs ->
5364 5342
                loop xs
......
5367 5345
                     | _ ->
5368 5346
                         Result.Error
5369 5347
                           "Vhdl_ast.vhdl_conditional_signal_t.postponed") x),
5370
                    arg1, arg2, arg3, arg4, arg5)
5348
                    arg1, arg2, arg3, arg4)
5371 5349
            | ("label",x)::xs ->
5372 5350
                loop xs
5373 5351
                  (arg0, ((fun x  -> vhdl_name_t_of_yojson x) x), arg2, arg3,
5374
                    arg4, arg5)
5352
                    arg4)
5375 5353
            | ("lhs",x)::xs ->
5376 5354
                loop xs
5377 5355
                  (arg0, arg1, ((fun x  -> vhdl_name_t_of_yojson x) x), arg3,
5378
                    arg4, arg5)
5356
                    arg4)
5379 5357
            | ("rhs",x)::xs ->
5380 5358
                loop xs
5381 5359
                  (arg0, arg1, arg2,
......
5387 5365
                      | _ ->
5388 5366
                          Result.Error
5389 5367
                            "Vhdl_ast.vhdl_conditional_signal_t.rhs") x),
5390
                    arg4, arg5)
5391
            | ("cond",x)::xs ->
5392
                loop xs
5393
                  (arg0, arg1, arg2, arg3,
5394
                    ((fun x  -> vhdl_expr_t_of_yojson x) x), arg5)
5368
                    arg4)
5395 5369
            | ("delay",x)::xs ->
5396 5370
                loop xs
5397
                  (arg0, arg1, arg2, arg3, arg4,
5371
                  (arg0, arg1, arg2, arg3,
5398 5372
                    ((fun x  -> vhdl_expr_t_of_yojson x) x))
5399 5373
            | [] ->
5400
                arg5 >>=
5401
                  ((fun arg5  ->
5402
                      arg4 >>=
5403
                        (fun arg4  ->
5404
                           arg3 >>=
5405
                             (fun arg3  ->
5406
                                arg2 >>=
5407
                                  (fun arg2  ->
5408
                                     arg1 >>=
5409
                                       (fun arg1  ->
5410
                                          arg0 >>=
5411
                                            (fun arg0  ->
5412
                                               Result.Ok
5413
                                                 {
5414
                                                   postponed = arg0;
5415
                                                   label = arg1;
5416
                                                   lhs = arg2;
5417
                                                   rhs = arg3;
5418
                                                   cond = arg4;
5419
                                                   delay = arg5
5420
                                                 })))))))
5374
                arg4 >>=
5375
                  ((fun arg4  ->
5376
                      arg3 >>=
5377
                        (fun arg3  ->
5378
                           arg2 >>=
5379
                             (fun arg2  ->
5380
                                arg1 >>=
5381
                                  (fun arg1  ->
5382
                                     arg0 >>=
5383
                                       (fun arg0  ->
5384
                                          Result.Ok
5385
                                            {
5386
                                              postponed = arg0;
5387
                                              label = arg1;
5388
                                              lhs = arg2;
5389
                                              rhs = arg3;
5390
                                              delay = arg4
5391
                                            }))))))
5421 5392
            | _::xs -> loop xs _state  in
5422 5393
          loop xs
5423 5394
            ((Result.Ok false), (Result.Ok NoName),
5424 5395
              (Result.Error "Vhdl_ast.vhdl_conditional_signal_t.lhs"),
5425 5396
              (Result.Error "Vhdl_ast.vhdl_conditional_signal_t.rhs"),
5426
              (Result.Ok IsNull), (Result.Ok IsNull))
5397
              (Result.Ok IsNull))
5427 5398
      | _ -> Result.Error "Vhdl_ast.vhdl_conditional_signal_t")
5428 5399
  [@ocaml.warning "-A"])
5429 5400

  
......
5488 5459
                         ((__3 ()) fmt) x;
5489 5460
                         Format.fprintf fmt ";";
5490 5461
                         true) false x);)) x.body;
5491
          Format.fprintf fmt "@]@;end process;@;";
5492
          Format.fprintf fmt "@]";)
5462
          Format.fprintf fmt "@]@;end process;@;")
5493 5463
    [@ocaml.warning "-A"])
5494 5464

  
5495 5465
and show_vhdl_process_t : vhdl_process_t -> Ppx_deriving_runtime.string =
......
5652 5622
                    if sep then Format.fprintf fmt ",@ ";
5653 5623
                      ((__3 ()) fmt) x;
5654 5624
                      true) false x))) x.branches;
5655
          Format.fprintf fmt "@]";)
5625
          Format.fprintf fmt ";@]";)
5656 5626
    [@ocaml.warning "-A"])
5657 5627

  
5658 5628
and show_vhdl_selected_signal_t :
......
6496 6466
                         if sep then Format.fprintf fmt "@;";
6497 6467
                         ((__3 ()) fmt) x;
6498 6468
                         true) false x))) x.body;
6499
           Format.fprintf fmt "@]@;end;"))
6469
           Format.fprintf fmt "@;"))
6500 6470
    [@ocaml.warning "-A"])
6501 6471

  
6502 6472
and show_vhdl_architecture_t :
......
6658 6628
      fun fmt  ->
6659 6629
        function
6660 6630
        | Package a0 ->
6661
            (Format.fprintf fmt "@[<v 2>package ";
6631
            (Format.fprintf fmt "@[<v 2>package ";
6662 6632
             ((__0 ()) fmt) a0;
6663 6633
             Format.fprintf fmt "@.end;@]")
6664 6634
        | Entities a0 ->
......
6747 6717
                        fun x  ->
6748 6718
                          if sep then Format.fprintf fmt "@.";
6749 6719
                          ((__0 ()) fmt) x;
6720
                          Format.fprintf fmt ";";
6750 6721
                          true) false x);
6751 6722
                )) x.contexts;
6752 6723
           Format.fprintf fmt "@.";);
src/backends/VHDL/vhdl_ast_map.ml
406 406
      vhdl_signal_condition_t -> vhdl_signal_condition_t=
407 407
      fun { expr; cond }  ->
408 408
        let expr = self#list self#vhdl_waveform_element_t expr  in
409
        let cond = self#vhdl_expr_t cond  in { expr; cond }
409
        let cond = self#option self#vhdl_expr_t cond  in { expr; cond }
410 410

  
411 411
    method vhdl_signal_selection_t :
412 412
      vhdl_signal_selection_t -> vhdl_signal_selection_t=
......
417 417

  
418 418
    method vhdl_conditional_signal_t :
419 419
      vhdl_conditional_signal_t -> vhdl_conditional_signal_t=
420
      fun { postponed; label; lhs; rhs; cond; delay }  ->
420
      fun { postponed; label; lhs; rhs; delay }  ->
421 421
        let postponed = self#bool postponed  in
422 422
        let label = self#vhdl_name_t label  in
423 423
        let lhs = self#vhdl_name_t lhs  in
424 424
        let rhs = self#list self#vhdl_signal_condition_t rhs  in
425
        let cond = self#vhdl_expr_t cond  in
426 425
        let delay = self#vhdl_expr_t delay  in
427
        { postponed; label; lhs; rhs; cond; delay }
428

  
426
        { postponed; label; lhs; rhs; delay }
429 427

  
430 428
    method vhdl_process_t : vhdl_process_t -> vhdl_process_t=
431 429
      fun { id; declarations; active_sigs; body }  ->
src/tools/importer/vhdl_to_lustre.ml
408 408
      vhdl_signal_condition_t -> vhdl_signal_condition_t=
409 409
      fun { expr; cond }  ->
410 410
        let expr = self#list self#vhdl_waveform_element_t expr  in
411
        let cond = self#vhdl_expr_t cond  in { expr; cond }
411
        let cond = self#option self#vhdl_expr_t cond  in { expr; cond }
412 412

  
413 413
    method vhdl_signal_selection_t :
414 414
      vhdl_signal_selection_t -> vhdl_signal_selection_t=
......
419 419

  
420 420
    method vhdl_conditional_signal_t :
421 421
      vhdl_conditional_signal_t -> vhdl_conditional_signal_t=
422
      fun { postponed; label; lhs; rhs; cond; delay }  ->
422
      fun { postponed; label; lhs; rhs; delay }  ->
423 423
        let postponed = self#bool postponed  in
424 424
        let label = self#vhdl_name_t label  in
425 425
        let lhs = self#vhdl_name_t lhs  in
426 426
        let rhs = self#list self#vhdl_signal_condition_t rhs  in
427
        let cond = self#vhdl_expr_t cond  in
428 427
        let delay = self#vhdl_expr_t delay  in
429
        { postponed; label; lhs; rhs; cond; delay }
428
        { postponed; label; lhs; rhs; delay }
430 429

  
431 430
    method vhdl_process_t : vhdl_process_t -> vhdl_process_t=
432 431
      fun { id; declarations; active_sigs; body }  ->

Also available in: Unified diff