Project

General

Profile

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

    
3
let _ = fun (_ : vhdl_cst_val_t)  -> () 
4
let _ = fun (_ : vhdl_type_t)  -> () 
5
let _ = fun (_ : vhdl_element_declaration_t)  -> () 
6
let _ = fun (_ : vhdl_subtype_indication_t)  -> () 
7
let _ = fun (_ : vhdl_discrete_range_t)  -> () 
8
let _ = fun (_ : vhdl_constraint_t)  -> () 
9
let _ = fun (_ : vhdl_definition_t)  -> () 
10
let _ = fun (_ : vhdl_expr_t)  -> () 
11
let _ = fun (_ : vhdl_name_t)  -> () 
12
let _ = fun (_ : vhdl_assoc_element_t)  -> () 
13
let _ = fun (_ : vhdl_element_assoc_t)  -> () 
14
let _ = fun (_ : vhdl_array_attributes_t)  -> () 
15
let _ = fun (_ : vhdl_signal_attributes_t)  -> () 
16
let _ = fun (_ : vhdl_string_attributes_t)  -> () 
17
let _ = fun (_ : vhdl_suffix_selection_t)  -> () 
18
(*let _ = fun (_ : 'basetype vhdl_type_attributes_t)  -> ()  *)
19
let _ = fun (_ : vhdl_parameter_t)  -> () 
20
let _ = fun (_ : vhdl_subprogram_spec_t)  -> () 
21
let _ = fun (_ : vhdl_sequential_stmt_t)  -> () 
22
let _ = fun (_ : vhdl_if_case_t)  -> () 
23
let _ = fun (_ : vhdl_case_item_t)  -> () 
24
let _ = fun (_ : vhdl_declaration_t)  -> () 
25
let _ = fun (_ : vhdl_signal_selection_t)  -> () 
26
let _ = fun (_ : vhdl_declarative_item_t)  -> () 
27
let _ = fun (_ : vhdl_waveform_element_t)  -> ()
28
let _ = fun (_ : vhdl_signal_condition_t)  -> () 
29
let _ = fun (_ : vhdl_conditional_signal_t)  -> () 
30
let _ = fun (_ : vhdl_process_t)  -> () 
31
let _ = fun (_ : vhdl_selected_signal_t)  -> () 
32
let _ = fun (_ : vhdl_port_mode_t)  -> () 
33
let _ = fun (_ : vhdl_component_instantiation_t)  -> ()
34
let _ = fun (_ : vhdl_concurrent_stmt_t)  -> () 
35
let _ = fun (_ : vhdl_port_t)  -> () 
36
let _ = fun (_ : vhdl_entity_t)  -> () 
37
let _ = fun (_ : vhdl_package_t)  -> () 
38
let _ = fun (_ : vhdl_load_t)  -> () 
39
let _ = fun (_ : vhdl_architecture_t)  -> () 
40
let _ = fun (_ : vhdl_configuration_t)  -> () 
41
let _ = fun (_ : vhdl_library_unit_t)  -> () 
42
let _ = fun (_ : vhdl_design_unit_t)  -> () 
43
let _ = fun (_ : vhdl_design_file_t)  -> () 
44
let _ = fun (_ : vhdl_file_t)  -> () 
45

    
46
class virtual vhdl_map =
47
  object (self)
48
    method virtual  string : string -> string
49
    method virtual  list : 'a . ('a -> 'a) -> 'a list -> 'a list
50
    method virtual  unit : unit -> unit
51
    method virtual  bool : bool -> bool
52
    method virtual  option : 'a . ('a -> 'a) -> 'a option -> 'a option
53
    method virtual  int : int -> int
54
    method virtual  vhdl_name_t : vhdl_name_t -> vhdl_name_t
55
    method virtual  vhdl_definition_t : vhdl_definition_t -> vhdl_definition_t
56
    method virtual  vhdl_port_t : vhdl_port_t -> vhdl_port_t
57
    method virtual  vhdl_expr_t : vhdl_expr_t -> vhdl_expr_t
58
    method virtual  vhdl_port_mode_t : vhdl_port_mode_t -> vhdl_port_mode_t
59
    method virtual  vhdl_element_declaration_t : vhdl_element_declaration_t -> vhdl_element_declaration_t
60
    method virtual  vhdl_subtype_indication_t : vhdl_subtype_indication_t -> vhdl_subtype_indication_t
61
    method virtual  vhdl_conditional_signal_t : vhdl_conditional_signal_t -> vhdl_conditional_signal_t
62
    method virtual  vhdl_process_t : vhdl_process_t -> vhdl_process_t
63
    method virtual  vhdl_selected_signal_t : vhdl_selected_signal_t -> vhdl_selected_signal_t
64
    method virtual  vhdl_signal_selection_t : vhdl_signal_selection_t -> vhdl_signal_selection_t
65
    method virtual  vhdl_suffix_selection_t : vhdl_suffix_selection_t -> vhdl_suffix_selection_t
66
    method virtual  vhdl_declaration_t : vhdl_declaration_t -> vhdl_declaration_t
67
    method virtual  vhdl_sequential_stmt_t : vhdl_sequential_stmt_t -> vhdl_sequential_stmt_t
68
    method virtual  vhdl_declarative_item_t : vhdl_declarative_item_t -> vhdl_declarative_item_t
69
    method virtual  vhdl_waveform_element_t : vhdl_waveform_element_t -> vhdl_waveform_element_t
70
    method virtual  vhdl_signal_condition_t : vhdl_signal_condition_t -> vhdl_signal_condition_t
71
    method virtual  vhdl_cst_val_t : vhdl_cst_val_t -> vhdl_cst_val_t
72
    method virtual  vhdl_subprogram_spec_t : vhdl_subprogram_spec_t -> vhdl_subprogram_spec_t
73
    method virtual  vhdl_discrete_range_t : vhdl_discrete_range_t -> vhdl_discrete_range_t
74
    method virtual  vhdl_parameter_t : vhdl_parameter_t -> vhdl_parameter_t
75
    method virtual  vhdl_component_instantiation_t : vhdl_component_instantiation_t -> vhdl_component_instantiation_t
76
    method virtual  vhdl_concurrent_stmt_t : vhdl_concurrent_stmt_t -> vhdl_concurrent_stmt_t
77
    method virtual  vhdl_declaration_t : vhdl_declaration_t -> vhdl_declaration_t
78
    method virtual  vhdl_architecture_t : vhdl_architecture_t -> vhdl_architecture_t
79
    method virtual  vhdl_configuration_t : vhdl_configuration_t -> vhdl_configuration_t
80
    method virtual  vhdl_entity_t : vhdl_entity_t -> vhdl_entity_t
81
    method virtual  vhdl_package_t : vhdl_package_t -> vhdl_package_t
82
    method virtual  vhdl_library_unit_t : vhdl_library_unit_t -> vhdl_library_unit_t
83
    method virtual  vhdl_load_t : vhdl_load_t -> vhdl_load_t
84
    method virtual  vhdl_design_unit_t : vhdl_design_unit_t -> vhdl_design_unit_t
85
    method virtual  vhdl_design_file_t : vhdl_design_file_t -> vhdl_design_file_t
86

    
87
    method vhdl_cst_val_t : vhdl_cst_val_t -> vhdl_cst_val_t=
88
      fun x  ->
89
        match x with
90
        | CstInt a -> let a = self#int a  in CstInt a
91
        | CstStdLogic a -> let a = self#string a  in CstStdLogic a
92
        | CstLiteral a -> let a = self#string a  in CstLiteral a
93

    
94
    method vhdl_type_t : vhdl_type_t -> vhdl_type_t=
95
      fun x  ->
96
        match x with
97
        | Base a -> let a = self#string a  in Base a
98
        | Range (a,b,c) ->
99
            let a = self#option self#string a  in
100
            let b = self#int b  in let c = self#int c  in Range (a, b, c)
101
        | Bit_vector (a,b) ->
102
            let a = self#int a  in let b = self#int b  in Bit_vector (a, b)
103
        | Array { indexes; const; definition } ->
104
            let indexes = self#list self#vhdl_name_t indexes  in
105
            let const = self#option self#vhdl_constraint_t const  in
106
            let definition = self#vhdl_subtype_indication_t definition  in
107
            Array { indexes; const; definition }
108
        | Record a ->
109
            let a = self#list self#vhdl_element_declaration_t a  in Record a
110
        | Enumerated a ->
111
            let a = self#list self#vhdl_name_t a  in Enumerated a
112
        | Void  -> Void
113
    method vhdl_element_declaration_t :
114
      vhdl_element_declaration_t -> vhdl_element_declaration_t=
115
      fun { ed_names; definition }  ->
116
        let ed_names = self#list self#vhdl_name_t ed_names  in
117
        let definition = self#vhdl_subtype_indication_t definition  in
118
        { ed_names; definition }
119
    method vhdl_subtype_indication_t :
120
      vhdl_subtype_indication_t -> vhdl_subtype_indication_t=
121
      fun { si_name; functionName; const }  ->
122
        let si_name = self#vhdl_name_t si_name  in
123
        let functionName = self#vhdl_name_t functionName  in
124
        let const = self#vhdl_constraint_t const  in
125
        { si_name; functionName; const }
126
    method vhdl_discrete_range_t :
127
      vhdl_discrete_range_t -> vhdl_discrete_range_t=
128
      fun x  ->
129
        match x with
130
        | SubDiscreteRange a ->
131
            let a = self#vhdl_subtype_indication_t a  in SubDiscreteRange a
132
        | NamedRange a -> let a = self#vhdl_name_t a  in NamedRange a
133
        | DirectedRange { direction; from; _to } ->
134
            let direction = self#string direction  in
135
            let from = self#vhdl_expr_t from  in
136
            let _to = self#vhdl_expr_t _to  in
137
            DirectedRange { direction; from; _to }
138

    
139
    method vhdl_constraint_t : vhdl_constraint_t -> vhdl_constraint_t=
140
      fun x  ->
141
        match x with
142
        | RefConstraint { ref_name } ->
143
            let ref_name = self#vhdl_name_t ref_name  in
144
            RefConstraint { ref_name }
145
        | RangeConstraint { range } ->
146
            let range = self#vhdl_discrete_range_t range  in
147
            RangeConstraint { range }
148
        | IndexConstraint { ranges } ->
149
            let ranges = self#list self#vhdl_discrete_range_t ranges  in
150
            IndexConstraint { ranges }
151
        | ArrayConstraint { ranges; sub } ->
152
            let ranges = self#list self#vhdl_discrete_range_t ranges  in
153
            let sub = self#vhdl_constraint_t sub  in
154
            ArrayConstraint { ranges; sub }
155
        | RecordConstraint  -> RecordConstraint
156
        | NoConstraint  -> NoConstraint
157

    
158
    method vhdl_definition_t : vhdl_definition_t -> vhdl_definition_t=
159
      fun x  ->
160
        match x with
161
        | Type { name; definition } ->
162
            let name = self#vhdl_name_t name  in
163
            let definition = self#vhdl_type_t definition  in
164
            Type { name; definition }
165
        | Subtype { name; typ } ->
166
            let name = self#vhdl_name_t name  in
167
            let typ = self#vhdl_subtype_indication_t typ  in
168
            Subtype { name; typ }
169
    method vhdl_expr_t : vhdl_expr_t -> vhdl_expr_t=
170
      fun x  ->
171
        match x with
172
        | Call a -> let a = self#vhdl_name_t a  in Call a
173
        | Cst { value; unit_name } ->
174
            let value = self#vhdl_cst_val_t value  in
175
            let unit_name = self#option self#vhdl_name_t unit_name  in
176
            Cst { value; unit_name }
177
        | Op { id; args } ->
178
            let id = self#string id  in
179
            let args = self#list self#vhdl_expr_t args  in Op { id; args }
180
        | IsNull  -> IsNull
181
        | Time { value; phy_unit } ->
182
            let value = self#int value  in
183
            let phy_unit = self#string phy_unit  in Time { value; phy_unit }
184
        | Sig { name; att } ->
185
            let name = self#vhdl_name_t name  in
186
            let att = self#option self#vhdl_signal_attributes_t att  in
187
            Sig { name; att }
188
        | SuffixMod { expr; selection } ->
189
            let expr = self#vhdl_expr_t expr  in
190
            let selection = self#vhdl_suffix_selection_t selection  in
191
            SuffixMod { expr; selection }
192
        | Aggregate { elems } ->
193
            let elems = self#list self#vhdl_element_assoc_t elems  in
194
            Aggregate { elems }
195
        | QualifiedExpression { type_mark; aggregate; expression } ->
196
            let type_mark = self#vhdl_name_t type_mark  in
197
            let aggregate = self#list self#vhdl_element_assoc_t aggregate  in
198
            let expression = self#option self#vhdl_expr_t expression  in
199
            QualifiedExpression { type_mark; aggregate; expression }
200
        | Others  -> Others
201
    method vhdl_name_t : vhdl_name_t -> vhdl_name_t=
202
      fun x  ->
203
        match x with
204
        | Simple a -> let a = self#string a  in Simple a
205
        | Identifier a -> let a = self#string a  in Identifier a
206
        | Selected a -> let a = self#list self#vhdl_name_t a  in Selected a
207
        | Index { id; exprs } ->
208
            let id = self#vhdl_name_t id  in
209
            let exprs = self#list self#vhdl_expr_t exprs  in
210
            Index { id; exprs }
211
        | Slice { id; range } ->
212
            let id = self#vhdl_name_t id  in
213
            let range = self#vhdl_discrete_range_t range  in
214
            Slice { id; range }
215
        | Attribute { id; designator; expr } ->
216
            let id = self#vhdl_name_t id  in
217
            let designator = self#vhdl_name_t designator  in
218
            let expr = self#vhdl_expr_t expr  in
219
            Attribute { id; designator; expr }
220
        | Function { id; assoc_list } ->
221
            let id = self#vhdl_name_t id  in
222
            let assoc_list = self#list self#vhdl_assoc_element_t assoc_list
223
               in
224
            Function { id; assoc_list }
225
        | Open -> Open
226
        | NoName  -> NoName
227
    method vhdl_assoc_element_t :
228
      vhdl_assoc_element_t -> vhdl_assoc_element_t=
229
      fun
230
        { formal_name; formal_arg; actual_name; actual_designator;
231
          actual_expr }
232
         ->
233
        let formal_name = self#option self#vhdl_name_t formal_name  in
234
        let formal_arg = self#option self#vhdl_name_t formal_arg  in
235
        let actual_name = self#option self#vhdl_name_t actual_name  in
236
        let actual_designator =
237
          self#option self#vhdl_name_t actual_designator  in
238
        let actual_expr = self#option self#vhdl_expr_t actual_expr  in
239
        {
240
          formal_name;
241
          formal_arg;
242
          actual_name;
243
          actual_designator;
244
          actual_expr
245
        }
246
    method vhdl_element_assoc_t :
247
      vhdl_element_assoc_t -> vhdl_element_assoc_t=
248
      fun { choices; expr }  ->
249
        let choices = self#list self#vhdl_expr_t choices  in
250
        let expr = self#vhdl_expr_t expr  in { choices; expr }
251
    method vhdl_array_attributes_t :
252
      vhdl_array_attributes_t -> vhdl_array_attributes_t=
253
      fun x  ->
254
        match x with
255
        | AAttInt { id; arg } ->
256
            let id = self#string id  in
257
            let arg = self#int arg  in AAttInt { id; arg }
258
        | AAttAscending  -> AAttAscending
259
    method vhdl_signal_attributes_t :
260
      vhdl_signal_attributes_t -> vhdl_signal_attributes_t=
261
      fun x  -> match x with | SigAtt a -> let a = self#string a  in SigAtt a
262
    method vhdl_string_attributes_t :
263
      vhdl_string_attributes_t -> vhdl_string_attributes_t=
264
      fun x  ->
265
        match x with | StringAtt a -> let a = self#string a  in StringAtt a
266
    method vhdl_suffix_selection_t : vhdl_suffix_selection_t -> vhdl_suffix_selection_t=
267
      fun x  ->
268
        match x with
269
        | Idx a -> let a = self#int a  in Idx a
270
        | SuffixRange (a,b) ->
271
            let a = self#int a  in let b = self#int b  in SuffixRange (a, b)
272

    
273
(*    method vhdl_type_attributes_t :
274
      'a .
275
        ('a -> 'a) -> 'a vhdl_type_attributes_t -> 'a vhdl_type_attributes_t=
276
      fun _basetype  ->
277
        fun x  ->
278
          match x with
279
          | TAttNoArg { id } -> let id = self#string id  in TAttNoArg { id }
280
          | TAttIntArg { id; arg } ->
281
              let id = self#string id  in
282
              let arg = self#int arg  in TAttIntArg { id; arg }
283
          | TAttValArg { id; arg } ->
284
              let id = self#string id  in
285
              let arg = _basetype arg  in TAttValArg { id; arg }
286
          | TAttStringArg { id; arg } ->
287
              let id = self#string id  in
288
              let arg = self#string arg  in TAttStringArg { id; arg } *)
289

    
290
    method vhdl_parameter_t : vhdl_parameter_t -> vhdl_parameter_t=
291
      fun { parameter_names; parameter_mode; parameter_typ; init_val }  ->
292
        let parameter_names = self#list self#vhdl_name_t parameter_names  in
293
        let parameter_mode = self#list self#string parameter_mode  in
294
        let parameter_typ = self#vhdl_subtype_indication_t parameter_typ  in
295
        let init_val = self#option self#vhdl_cst_val_t init_val  in
296
        { parameter_names; parameter_mode; parameter_typ; init_val }
297

    
298
    method vhdl_subprogram_spec_t :
299
      vhdl_subprogram_spec_t -> vhdl_subprogram_spec_t=
300
      fun { ss_name; subprogram_type; typeMark; parameters; isPure }  ->
301
        let ss_name = self#string ss_name  in
302
        let subprogram_type = self#string subprogram_type  in
303
        let typeMark = self#vhdl_name_t typeMark  in
304
        let parameters = self#list self#vhdl_parameter_t parameters  in
305
        let isPure = self#bool isPure  in
306
        { ss_name; subprogram_type; typeMark; parameters; isPure }
307

    
308
    method vhdl_sequential_stmt_t :
309
      vhdl_sequential_stmt_t -> vhdl_sequential_stmt_t=
310
      fun x  ->
311
        match x with
312
        | VarAssign { label; seqs_lhs; rhs } ->
313
            let label = self#vhdl_name_t label  in
314
            let seqs_lhs = self#vhdl_name_t seqs_lhs  in
315
            let rhs = self#vhdl_expr_t rhs  in VarAssign { label; seqs_lhs; rhs }
316
        | SigSeqAssign { label; seqs_lhs; rhs } ->
317
            let label = self#vhdl_name_t label  in
318
            let seqs_lhs = self#vhdl_name_t seqs_lhs  in
319
            let rhs = self#list self#vhdl_waveform_element_t rhs  in
320
            SigSeqAssign { label; seqs_lhs; rhs }
321
        | If { label; if_cases; default } ->
322
            let label = self#vhdl_name_t label  in
323
            let if_cases = self#list self#vhdl_if_case_t if_cases  in
324
            let default = self#list self#vhdl_sequential_stmt_t default  in
325
            If { label; if_cases; default }
326
        | Case { label; guard; branches } ->
327
            let label = self#vhdl_name_t label  in
328
            let guard = self#vhdl_expr_t guard  in
329
            let branches = self#list self#vhdl_case_item_t branches  in
330
            Case { label; guard; branches }
331
        | Exit { label; loop_label; condition } ->
332
            let label = self#vhdl_name_t label  in
333
            let loop_label = self#option self#string loop_label  in
334
            let condition = self#option self#vhdl_expr_t condition  in
335
            Exit { label; loop_label; condition }
336
        | Assert { label; cond; report; severity } ->
337
            let label = self#vhdl_name_t label  in
338
            let cond = self#vhdl_expr_t cond  in
339
            let report = self#vhdl_expr_t report  in
340
            let severity = self#vhdl_expr_t severity  in
341
            Assert { label; cond; report; severity }
342
        | ProcedureCall { label; name; assocs } ->
343
            let label = self#vhdl_name_t label  in
344
            let name = self#vhdl_name_t name  in
345
            let assocs = self#list self#vhdl_assoc_element_t assocs  in
346
            ProcedureCall { label; name; assocs }
347
        | Wait  -> Wait
348
        | Null { label } ->
349
            let label = self#vhdl_name_t label  in Null { label }
350
        | Return { label; expr } ->
351
            let label = self#option self#vhdl_name_t label  in
352
            let expr = self#option self#vhdl_expr_t expr in
353
            Return { label; expr }
354
    method vhdl_if_case_t : vhdl_if_case_t -> vhdl_if_case_t=
355
      fun { if_cond; if_block }  ->
356
        let if_cond = self#vhdl_expr_t if_cond  in
357
        let if_block = self#list self#vhdl_sequential_stmt_t if_block  in
358
        { if_cond; if_block }
359
    method vhdl_case_item_t : vhdl_case_item_t -> vhdl_case_item_t=
360
      fun { when_cond; when_stmt }  ->
361
        let when_cond = self#list self#vhdl_expr_t when_cond  in
362
        let when_stmt = self#list self#vhdl_sequential_stmt_t when_stmt  in
363
        { when_cond; when_stmt }
364

    
365
    method vhdl_declaration_t : vhdl_declaration_t -> vhdl_declaration_t=
366
      fun x  ->
367
        match x with
368
        | VarDecl { names; typ; init_val } ->
369
            let names = self#list self#vhdl_name_t names  in
370
            let typ = self#vhdl_subtype_indication_t typ  in
371
            let init_val = self#vhdl_expr_t init_val  in
372
            VarDecl { names; typ; init_val }
373
        | CstDecl { names; typ; init_val } ->
374
            let names = self#list self#vhdl_name_t names  in
375
            let typ = self#vhdl_subtype_indication_t typ  in
376
            let init_val = self#vhdl_expr_t init_val  in
377
            CstDecl { names; typ; init_val }
378
        | SigDecl { names; typ; init_val } ->
379
            let names = self#list self#vhdl_name_t names  in
380
            let typ = self#vhdl_subtype_indication_t typ  in
381
            let init_val = self#vhdl_expr_t init_val  in
382
            SigDecl { names; typ; init_val }
383
        | ComponentDecl { name; generics; ports } ->
384
            let name = self#vhdl_name_t name  in
385
            let generics = self#list self#vhdl_port_t generics  in
386
            let ports = self#list self#vhdl_port_t ports  in
387
            ComponentDecl { name; generics; ports }
388
        | Subprogram { spec; decl_part; stmts } ->
389
            let spec = self#vhdl_subprogram_spec_t spec  in
390
            let decl_part = self#list self#vhdl_declaration_t decl_part  in
391
            let stmts = self#list self#vhdl_sequential_stmt_t stmts  in
392
            Subprogram { spec; decl_part; stmts }
393

    
394
    method vhdl_declarative_item_t :
395
      vhdl_declarative_item_t -> vhdl_declarative_item_t=
396
      fun { use_clause; di_declaration; di_definition }  ->
397
        let use_clause = self#option self#vhdl_load_t use_clause  in
398
        let di_declaration = self#option self#vhdl_declaration_t di_declaration  in
399
        let di_definition = self#option self#vhdl_definition_t di_definition  in
400
        { use_clause; di_declaration; di_definition }
401

    
402
    method vhdl_waveform_element_t :
403
      vhdl_waveform_element_t -> vhdl_waveform_element_t=
404
      fun { value; we_delay }  ->
405
        let value = self#option self#vhdl_expr_t value  in
406
        let we_delay = self#option self#vhdl_expr_t we_delay  in { value; we_delay }
407

    
408
    method vhdl_signal_condition_t :
409
      vhdl_signal_condition_t -> vhdl_signal_condition_t=
410
      fun { sc_expr; cond }  ->
411
        let sc_expr = self#list self#vhdl_waveform_element_t sc_expr  in
412
        let cond = self#option self#vhdl_expr_t cond  in { sc_expr; cond }
413

    
414
    method vhdl_signal_selection_t :
415
      vhdl_signal_selection_t -> vhdl_signal_selection_t=
416
      fun { ss_expr; when_sel }  ->
417
        let ss_expr = self#list self#vhdl_waveform_element_t ss_expr  in
418
        let when_sel = self#list self#vhdl_expr_t when_sel  in
419
        { ss_expr; when_sel }
420

    
421
    method vhdl_conditional_signal_t :
422
      vhdl_conditional_signal_t -> vhdl_conditional_signal_t=
423
      fun { cs_postponed; cs_label; cs_lhs; rhs; cs_delay }  ->
424
        let cs_postponed = self#bool cs_postponed  in
425
        let cs_label = self#vhdl_name_t cs_label  in
426
        let cs_lhs = self#vhdl_name_t cs_lhs  in
427
        let rhs = self#list self#vhdl_signal_condition_t rhs  in
428
        let cs_delay = self#vhdl_expr_t cs_delay  in
429
        { cs_postponed; cs_label; cs_lhs; rhs; cs_delay }
430

    
431
    method vhdl_process_t : vhdl_process_t -> vhdl_process_t=
432
      fun { id; p_declarations; active_sigs; p_body }  ->
433
        let id = self#vhdl_name_t id  in
434
        let p_declarations = self#list self#vhdl_declarative_item_t p_declarations  in
435
        let active_sigs = self#list self#vhdl_name_t active_sigs  in
436
        let p_body = self#list self#vhdl_sequential_stmt_t p_body  in
437
        { id; p_declarations; active_sigs; p_body }
438

    
439
    method vhdl_selected_signal_t :
440
      vhdl_selected_signal_t -> vhdl_selected_signal_t=
441
      fun { ss_postponed; ss_label; ss_lhs; sel; branches; ss_delay }  ->
442
        let ss_postponed = self#bool ss_postponed  in
443
        let ss_label = self#vhdl_name_t ss_label  in
444
        let ss_lhs = self#vhdl_name_t ss_lhs  in
445
        let sel = self#vhdl_expr_t sel  in
446
        let branches = self#list self#vhdl_signal_selection_t branches  in
447
        let ss_delay = self#option self#vhdl_expr_t ss_delay  in
448
        { ss_postponed; ss_label; ss_lhs; sel; branches; ss_delay }
449

    
450
    method vhdl_port_mode_t : vhdl_port_mode_t -> vhdl_port_mode_t=
451
      fun x  -> x
452

    
453
    method vhdl_component_instantiation_t :
454
      vhdl_component_instantiation_t -> vhdl_component_instantiation_t=
455
        fun { ci_name; inst_unit; inst_unit_type; archi_name; generic_map; port_map }  ->
456
        let ci_name = self#vhdl_name_t ci_name  in
457
        let inst_unit = self#vhdl_name_t inst_unit  in
458
        let inst_unit_type = self#string inst_unit_type  in
459
        let archi_name = self#option self#vhdl_name_t archi_name  in
460
        let generic_map = self#list self#vhdl_assoc_element_t generic_map  in
461
        let port_map = self#list self#vhdl_assoc_element_t port_map  in
462
        { ci_name; inst_unit; inst_unit_type; archi_name; generic_map; port_map }
463

    
464
    method vhdl_concurrent_stmt_t :
465
      vhdl_concurrent_stmt_t -> vhdl_concurrent_stmt_t=
466
      fun x  ->
467
        match x with
468
        | SigAssign a -> let a = self#vhdl_conditional_signal_t a  in SigAssign a
469
        | Process a -> let a = self#vhdl_process_t a  in Process a
470
        | SelectedSig a -> let a = self#vhdl_selected_signal_t a  in SelectedSig a
471
        | ComponentInst a -> let a = self#vhdl_component_instantiation_t a  in ComponentInst a 
472

    
473
    method vhdl_port_t : vhdl_port_t -> vhdl_port_t=
474
      fun { port_names; port_mode; port_typ; port_expr }  ->
475
        let port_names = self#list self#vhdl_name_t port_names  in
476
        let port_mode = self#vhdl_port_mode_t port_mode  in
477
        let port_typ = self#vhdl_subtype_indication_t port_typ  in
478
        let port_expr = self#vhdl_expr_t port_expr  in { port_names; port_mode; port_typ; port_expr }
479

    
480
    method vhdl_entity_t : vhdl_entity_t -> vhdl_entity_t=
481
      fun { e_name; generics; ports; e_declaration; stmts }  ->
482
        let e_name = self#vhdl_name_t e_name  in
483
        let generics = self#list self#vhdl_port_t generics  in
484
        let ports = self#list self#vhdl_port_t ports  in
485
        let e_declaration = self#list self#vhdl_declarative_item_t e_declaration
486
           in
487
        let stmts = self#list self#vhdl_concurrent_stmt_t stmts  in
488
        { e_name; generics; ports; e_declaration; stmts }
489

    
490
    method vhdl_package_t : vhdl_package_t -> vhdl_package_t=
491
      fun { p_name; shared_defs; shared_decls; shared_uses }  ->
492
        let p_name = self#vhdl_name_t p_name  in
493
        let shared_defs = self#list self#vhdl_definition_t shared_defs  in
494
        let shared_decls = self#list self#vhdl_declaration_t shared_decls  in
495
        let shared_uses = self#list self#vhdl_load_t shared_uses  in
496
        { p_name; shared_defs; shared_decls; shared_uses }
497

    
498
    method vhdl_load_t : vhdl_load_t -> vhdl_load_t=
499
      fun x  ->
500
        match x with
501
        | Library a -> let a = self#list self#vhdl_name_t a  in Library a
502
        | Use a -> let a = self#list self#vhdl_name_t a  in Use a
503

    
504
    method vhdl_architecture_t : vhdl_architecture_t -> vhdl_architecture_t=
505
      fun { a_name; entity; a_declarations; a_body }  ->
506
        let a_name = self#vhdl_name_t a_name  in
507
        let entity = self#vhdl_name_t entity  in
508
        let a_declarations = self#list self#vhdl_declarative_item_t a_declarations  in
509
        let a_body = self#list self#vhdl_concurrent_stmt_t a_body  in
510
        { a_name; entity; a_declarations; a_body }
511

    
512
    method vhdl_configuration_t :
513
      vhdl_configuration_t -> vhdl_configuration_t= self#unit
514

    
515
    method vhdl_library_unit_t : vhdl_library_unit_t -> vhdl_library_unit_t=
516
      fun x  ->
517
        match x with
518
        | Package a -> let a = self#vhdl_package_t a  in Package a
519
        | Entities a -> let a = self#vhdl_entity_t a  in Entities a
520
        | Architecture a ->
521
            let a = self#vhdl_architecture_t a  in Architecture a
522
        | Configuration a ->
523
            let a = self#vhdl_configuration_t a  in Configuration a
524

    
525
    method vhdl_design_unit_t : vhdl_design_unit_t -> vhdl_design_unit_t=
526
      fun { contexts; library }  ->
527
        let contexts = self#list self#vhdl_load_t contexts  in
528
        let library = self#vhdl_library_unit_t library  in
529
        { contexts; library }
530

    
531
    method vhdl_design_file_t : vhdl_design_file_t -> vhdl_design_file_t=
532
      fun { design_units }  ->
533
        let design_units = self#list self#vhdl_design_unit_t design_units  in
534
        { design_units }
535

    
536
    method vhdl_file_t : vhdl_file_t -> vhdl_file_t=
537
      fun { design_file }  ->
538
        let design_file = self#vhdl_design_file_t design_file  in
539
        { design_file }
540
  end
(7-7/12)