1

open Vhdl_ast_deriving

2

open Lustre_types

3

open Utils

4


5

let _ = fun (_ : vhdl_cst_val_t) > ()

6

let _ = fun (_ : vhdl_type_t) > ()

7

let _ = fun (_ : vhdl_element_declaration_t) > ()

8

let _ = fun (_ : vhdl_subtype_indication_t) > ()

9

let _ = fun (_ : vhdl_discrete_range_t) > ()

10

let _ = fun (_ : vhdl_constraint_t) > ()

11

let _ = fun (_ : vhdl_definition_t) > ()

12

let _ = fun (_ : vhdl_expr_t) > ()

13

let _ = fun (_ : vhdl_name_t) > ()

14

let _ = fun (_ : vhdl_assoc_element_t) > ()

15

let _ = fun (_ : vhdl_element_assoc_t) > ()

16

let _ = fun (_ : vhdl_array_attributes_t) > ()

17

let _ = fun (_ : vhdl_signal_attributes_t) > ()

18

let _ = fun (_ : vhdl_string_attributes_t) > ()

19

let _ = fun (_ : vhdl_suffix_selection_t) > ()

20

let _ = fun (_ : 'basetype vhdl_type_attributes_t) > ()

21

let _ = fun (_ : vhdl_parameter_t) > ()

22

let _ = fun (_ : vhdl_subprogram_spec_t) > ()

23

let _ = fun (_ : vhdl_sequential_stmt_t) > ()

24

let _ = fun (_ : vhdl_if_case_t) > ()

25

let _ = fun (_ : vhdl_case_item_t) > ()

26

let _ = fun (_ : vhdl_declaration_t) > ()

27

let _ = fun (_ : vhdl_signal_selection_t) > ()

28

let _ = fun (_ : vhdl_declarative_item_t) > ()

29

let _ = fun (_ : vhdl_waveform_element_t) > ()

30

let _ = fun (_ : vhdl_signal_condition_t) > ()

31

let _ = fun (_ : vhdl_conditional_signal_t) > ()

32

let _ = fun (_ : vhdl_process_t) > ()

33

let _ = fun (_ : vhdl_selected_signal_t) > ()

34

let _ = fun (_ : vhdl_port_mode_t) > ()

35

let _ = fun (_ : vhdl_component_instantiation_t) > ()

36

let _ = fun (_ : vhdl_concurrent_stmt_t) > ()

37

let _ = fun (_ : vhdl_port_t) > ()

38

let _ = fun (_ : vhdl_entity_t) > ()

39

let _ = fun (_ : vhdl_package_t) > ()

40

let _ = fun (_ : vhdl_load_t) > ()

41

let _ = fun (_ : vhdl_architecture_t) > ()

42

let _ = fun (_ : vhdl_configuration_t) > ()

43

let _ = fun (_ : vhdl_library_unit_t) > ()

44

let _ = fun (_ : vhdl_design_unit_t) > ()

45

let _ = fun (_ : vhdl_design_file_t) > ()

46

let _ = fun (_ : vhdl_file_t) > ()

47


48

class virtual vhdl_to_lustre_map =

49

object (self)

50

method virtual string : string > string

51

method virtual list : 'a . ('a > 'a) > 'a list > 'a list

52

method virtual unit : unit > unit

53

method virtual bool : bool > bool

54

method virtual option : 'a . ('a > 'a) > 'a option > 'a option

55

method virtual int : int > int

56

method virtual vhdl_name_t : vhdl_name_t > vhdl_name_t

57

method virtual vhdl_definition_t : vhdl_definition_t > vhdl_definition_t

58

method virtual vhdl_port_t : vhdl_port_t > vhdl_port_t

59

method virtual vhdl_expr_t : vhdl_expr_t > vhdl_expr_t

60

method virtual vhdl_port_mode_t : vhdl_port_mode_t > vhdl_port_mode_t

61

method virtual vhdl_element_declaration_t : vhdl_element_declaration_t > vhdl_element_declaration_t

62

method virtual vhdl_subtype_indication_t : vhdl_subtype_indication_t > vhdl_subtype_indication_t

63

method virtual vhdl_conditional_signal_t : vhdl_conditional_signal_t > vhdl_conditional_signal_t

64

method virtual vhdl_process_t : vhdl_process_t > vhdl_process_t

65

method virtual vhdl_selected_signal_t : vhdl_selected_signal_t > vhdl_selected_signal_t

66

method virtual vhdl_signal_selection_t : vhdl_signal_selection_t > vhdl_signal_selection_t

67

method virtual vhdl_suffix_selection_t : vhdl_suffix_selection_t > vhdl_suffix_selection_t

68

method virtual vhdl_declaration_t : vhdl_declaration_t > vhdl_declaration_t

69

method virtual vhdl_sequential_stmt_t : vhdl_sequential_stmt_t > vhdl_sequential_stmt_t

70

method virtual vhdl_declarative_item_t : vhdl_declarative_item_t > vhdl_declarative_item_t

71

method virtual vhdl_waveform_element_t : vhdl_waveform_element_t > vhdl_waveform_element_t

72

method virtual vhdl_signal_condition_t : vhdl_signal_condition_t > vhdl_signal_condition_t

73

method virtual vhdl_cst_val_t : vhdl_cst_val_t > vhdl_cst_val_t

74

method virtual vhdl_subprogram_spec_t : vhdl_subprogram_spec_t > vhdl_subprogram_spec_t

75

method virtual vhdl_discrete_range_t : vhdl_discrete_range_t > vhdl_discrete_range_t

76

method virtual vhdl_parameter_t : vhdl_parameter_t > vhdl_parameter_t

77

method virtual vhdl_component_instantiation_t : vhdl_component_instantiation_t > vhdl_component_instantiation_t

78

method virtual vhdl_concurrent_stmt_t : vhdl_concurrent_stmt_t > vhdl_concurrent_stmt_t

79

method virtual vhdl_declaration_t : vhdl_declaration_t > vhdl_declaration_t

80

method virtual vhdl_architecture_t : vhdl_architecture_t > vhdl_architecture_t

81

method virtual vhdl_configuration_t : vhdl_configuration_t > vhdl_configuration_t

82

method virtual vhdl_entity_t : vhdl_entity_t > vhdl_entity_t

83

method virtual vhdl_package_t : vhdl_package_t > vhdl_package_t

84

method virtual vhdl_library_unit_t : vhdl_library_unit_t > vhdl_library_unit_t

85

method virtual vhdl_load_t : vhdl_load_t > vhdl_load_t

86

method virtual vhdl_design_unit_t : vhdl_design_unit_t > vhdl_design_unit_t

87

method virtual vhdl_design_file_t : vhdl_design_file_t > vhdl_design_file_t

88


89

method vhdl_cst_val_t : vhdl_cst_val_t > vhdl_cst_val_t =

90

fun x >

91

match x with

92

 CstInt a > let a = self#int a in CstInt a

93

 CstStdLogic a > let a = self#string a in CstStdLogic a

94

 CstLiteral a > let a = self#string a in CstLiteral a

95


96

method vhdl_type_t : vhdl_type_t > vhdl_type_t=

97

fun x >

98

match x with

99

 Base a > let a = self#string a in Base a

100

 Range (a,b,c) >

101

let a = self#option self#string a in

102

let b = self#int b in let c = self#int c in Range (a, b, c)

103

 Bit_vector (a,b) >

104

let a = self#int a in let b = self#int b in Bit_vector (a, b)

105

 Array { indexes; const; definition } >

106

let indexes = self#list self#vhdl_name_t indexes in

107

let const = self#option self#vhdl_constraint_t const in

108

let definition = self#vhdl_subtype_indication_t definition in

109

Array { indexes; const; definition }

110

 Record a >

111

let a = self#list self#vhdl_element_declaration_t a in Record a

112

 Enumerated a >

113

let a = self#list self#vhdl_name_t a in Enumerated a

114

 Void > Void

115

method vhdl_element_declaration_t :

116

vhdl_element_declaration_t > vhdl_element_declaration_t=

117

fun { names; definition } >

118

let names = self#list self#vhdl_name_t names in

119

let definition = self#vhdl_subtype_indication_t definition in

120

{ names; definition }

121

method vhdl_subtype_indication_t :

122

vhdl_subtype_indication_t > vhdl_subtype_indication_t=

123

fun { name; functionName; const } >

124

let name = self#vhdl_name_t name in

125

let functionName = self#vhdl_name_t functionName in

126

let const = self#vhdl_constraint_t const in

127

{ name; functionName; const }

128

method vhdl_discrete_range_t :

129

vhdl_discrete_range_t > vhdl_discrete_range_t=

130

fun x >

131

match x with

132

 SubDiscreteRange a >

133

let a = self#vhdl_subtype_indication_t a in SubDiscreteRange a

134

 NamedRange a > let a = self#vhdl_name_t a in NamedRange a

135

 DirectedRange { direction; from; _to } >

136

let direction = self#string direction in

137

let from = self#vhdl_expr_t from in

138

let _to = self#vhdl_expr_t _to in

139

DirectedRange { direction; from; _to }

140


141

method vhdl_constraint_t : vhdl_constraint_t > vhdl_constraint_t=

142

fun x >

143

match x with

144

 RefConstraint { ref_name } >

145

let ref_name = self#vhdl_name_t ref_name in

146

RefConstraint { ref_name }

147

 RangeConstraint { range } >

148

let range = self#vhdl_discrete_range_t range in

149

RangeConstraint { range }

150

 IndexConstraint { ranges } >

151

let ranges = self#list self#vhdl_discrete_range_t ranges in

152

IndexConstraint { ranges }

153

 ArrayConstraint { ranges; sub } >

154

let ranges = self#list self#vhdl_discrete_range_t ranges in

155

let sub = self#vhdl_constraint_t sub in

156

ArrayConstraint { ranges; sub }

157

 RecordConstraint > RecordConstraint

158

 NoConstraint > NoConstraint

159


160

method vhdl_definition_t : vhdl_definition_t > vhdl_definition_t=

161

fun x >

162

match x with

163

 Type { name; definition } >

164

let name = self#vhdl_name_t name in

165

let definition = self#vhdl_type_t definition in

166

Type { name; definition }

167

 Subtype { name; typ } >

168

let name = self#vhdl_name_t name in

169

let typ = self#vhdl_subtype_indication_t typ in

170

Subtype { name; typ }

171

method vhdl_expr_t : vhdl_expr_t > vhdl_expr_t=

172

fun x >

173

match x with

174

 Call a > let a = self#vhdl_name_t a in Call a

175

 Cst { value; unit_name } >

176

let value = self#vhdl_cst_val_t value in

177

let unit_name = self#option self#vhdl_name_t unit_name in

178

Cst { value; unit_name }

179

 Op { id; args } >

180

let id = self#string id in

181

let args = self#list self#vhdl_expr_t args in Op { id; args }

182

 IsNull > IsNull

183

 Time { value; phy_unit } >

184

let value = self#int value in

185

let phy_unit = self#string phy_unit in Time { value; phy_unit }

186

 Sig { name; att } >

187

let name = self#vhdl_name_t name in

188

let att = self#option self#vhdl_signal_attributes_t att in

189

Sig { name; att }

190

 SuffixMod { expr; selection } >

191

let expr = self#vhdl_expr_t expr in

192

let selection = self#vhdl_suffix_selection_t selection in

193

SuffixMod { expr; selection }

194

 Aggregate { elems } >

195

let elems = self#list self#vhdl_element_assoc_t elems in

196

Aggregate { elems }

197

 Others > Others

198

method vhdl_name_t : vhdl_name_t > vhdl_name_t=

199

fun x >

200

match x with

201

 Simple a > let a = self#string a in Simple a

202

 Identifier a > let a = self#string a in Identifier a

203

 Selected a > let a = self#list self#vhdl_name_t a in Selected a

204

 Index { id; exprs } >

205

let id = self#vhdl_name_t id in

206

let exprs = self#list self#vhdl_expr_t exprs in

207

Index { id; exprs }

208

 Slice { id; range } >

209

let id = self#vhdl_name_t id in

210

let range = self#vhdl_discrete_range_t range in

211

Slice { id; range }

212

 Attribute { id; designator; expr } >

213

let id = self#vhdl_name_t id in

214

let designator = self#vhdl_name_t designator in

215

let expr = self#vhdl_expr_t expr in

216

Attribute { id; designator; expr }

217

 Function { id; assoc_list } >

218

let id = self#vhdl_name_t id in

219

let assoc_list = self#list self#vhdl_assoc_element_t assoc_list

220

in

221

Function { id; assoc_list }

222

 NoName > NoName

223

method vhdl_assoc_element_t :

224

vhdl_assoc_element_t > vhdl_assoc_element_t=

225

fun

226

{ formal_name; formal_arg; actual_name; actual_designator;

227

actual_expr }

228

>

229

let formal_name = self#option self#vhdl_name_t formal_name in

230

let formal_arg = self#option self#vhdl_name_t formal_arg in

231

let actual_name = self#option self#vhdl_name_t actual_name in

232

let actual_designator =

233

self#option self#vhdl_name_t actual_designator in

234

let actual_expr = self#option self#vhdl_expr_t actual_expr in

235

{

236

formal_name;

237

formal_arg;

238

actual_name;

239

actual_designator;

240

actual_expr

241

}

242

method vhdl_element_assoc_t :

243

vhdl_element_assoc_t > vhdl_element_assoc_t=

244

fun { choices; expr } >

245

let choices = self#list self#vhdl_expr_t choices in

246

let expr = self#vhdl_expr_t expr in { choices; expr }

247

method vhdl_array_attributes_t :

248

vhdl_array_attributes_t > vhdl_array_attributes_t=

249

fun x >

250

match x with

251

 AAttInt { id; arg } >

252

let id = self#string id in

253

let arg = self#int arg in AAttInt { id; arg }

254

 AAttAscending > AAttAscending

255

method vhdl_signal_attributes_t :

256

vhdl_signal_attributes_t > vhdl_signal_attributes_t=

257

fun x > match x with  SigAtt a > let a = self#string a in SigAtt a

258

method vhdl_string_attributes_t :

259

vhdl_string_attributes_t > vhdl_string_attributes_t=

260

fun x >

261

match x with  StringAtt a > let a = self#string a in StringAtt a

262

method vhdl_suffix_selection_t : vhdl_suffix_selection_t > vhdl_suffix_selection_t=

263

fun x >

264

match x with

265

 Idx a > let a = self#int a in Idx a

266

 SuffixRange (a,b) >

267

let a = self#int a in let b = self#int b in SuffixRange (a, b)

268


269

method vhdl_type_attributes_t :

270

'a .

271

('a > 'a) > 'a vhdl_type_attributes_t > 'a vhdl_type_attributes_t=

272

fun _basetype >

273

fun x >

274

match x with

275

 TAttNoArg { id } > let id = self#string id in TAttNoArg { id }

276

 TAttIntArg { id; arg } >

277

let id = self#string id in

278

let arg = self#int arg in TAttIntArg { id; arg }

279

 TAttValArg { id; arg } >

280

let id = self#string id in

281

let arg = _basetype arg in TAttValArg { id; arg }

282

 TAttStringArg { id; arg } >

283

let id = self#string id in

284

let arg = self#string arg in TAttStringArg { id; arg }

285


286

method vhdl_parameter_t : vhdl_parameter_t > vhdl_parameter_t=

287

fun { names; mode; typ; init_val } >

288

let names = self#list self#vhdl_name_t names in

289

let mode = self#list self#string mode in

290

let typ = self#vhdl_subtype_indication_t typ in

291

let init_val = self#option self#vhdl_cst_val_t init_val in

292

{ names; mode; typ; init_val }

293


294

method vhdl_subprogram_spec_t :

295

vhdl_subprogram_spec_t > vhdl_subprogram_spec_t=

296

fun { name; subprogram_type; typeMark; parameters; isPure } >

297

let name = self#string name in

298

let subprogram_type = self#string subprogram_type in

299

let typeMark = self#vhdl_name_t typeMark in

300

let parameters = self#list self#vhdl_parameter_t parameters in

301

let isPure = self#bool isPure in

302

{ name; subprogram_type; typeMark; parameters; isPure }

303


304

method vhdl_sequential_stmt_t :

305

vhdl_sequential_stmt_t > vhdl_sequential_stmt_t=

306

fun x >

307

match x with

308

 VarAssign { label; lhs; rhs } >

309

let label = self#vhdl_name_t label in

310

let lhs = self#vhdl_name_t lhs in

311

let rhs = self#vhdl_expr_t rhs in VarAssign { label; lhs; rhs }

312

 SigSeqAssign { label; lhs; rhs } >

313

let label = self#vhdl_name_t label in

314

let lhs = self#vhdl_name_t lhs in

315

let rhs = self#list self#vhdl_waveform_element_t rhs in

316

SigSeqAssign { label; lhs; rhs }

317

 If { label; if_cases; default } >

318

let label = self#vhdl_name_t label in

319

let if_cases = self#list self#vhdl_if_case_t if_cases in

320

let default = self#list self#vhdl_sequential_stmt_t default in

321

If { label; if_cases; default }

322

 Case { label; guard; branches } >

323

let label = self#vhdl_name_t label in

324

let guard = self#vhdl_expr_t guard in

325

let branches = self#list self#vhdl_case_item_t branches in

326

Case { label; guard; branches }

327

 Exit { label; loop_label; condition } >

328

let label = self#vhdl_name_t label in

329

let loop_label = self#option self#string loop_label in

330

let condition = self#option self#vhdl_expr_t condition in

331

Exit { label; loop_label; condition }

332

 Assert { label; cond; report; severity } >

333

let label = self#vhdl_name_t label in

334

let cond = self#vhdl_expr_t cond in

335

let report = self#vhdl_expr_t report in

336

let severity = self#vhdl_expr_t severity in

337

Assert { label; cond; report; severity }

338

 ProcedureCall { label; name; assocs } >

339

let label = self#vhdl_name_t label in

340

let name = self#vhdl_name_t name in

341

let assocs = self#list self#vhdl_assoc_element_t assocs in

342

ProcedureCall { label; name; assocs }

343

 Wait > Wait

344

 Null { label } >

345

let label = self#vhdl_name_t label in Null { label }

346

 Return { label } >

347

let label = self#vhdl_name_t label in Return { label }

348

method vhdl_if_case_t : vhdl_if_case_t > vhdl_if_case_t=

349

fun { if_cond; if_block } >

350

let if_cond = self#vhdl_expr_t if_cond in

351

let if_block = self#list self#vhdl_sequential_stmt_t if_block in

352

{ if_cond; if_block }

353

method vhdl_case_item_t : vhdl_case_item_t > vhdl_case_item_t=

354

fun { when_cond; when_stmt } >

355

let when_cond = self#list self#vhdl_expr_t when_cond in

356

let when_stmt = self#list self#vhdl_sequential_stmt_t when_stmt in

357

{ when_cond; when_stmt }

358


359

method vhdl_declaration_t : vhdl_declaration_t > vhdl_declaration_t=

360

fun x >

361

match x with

362

 VarDecl { names; typ; init_val } >

363

let names = self#list self#vhdl_name_t names in

364

let typ = self#vhdl_subtype_indication_t typ in

365

let init_val = self#vhdl_expr_t init_val in

366

VarDecl { names; typ; init_val }

367

 CstDecl { names; typ; init_val } >

368

let names = self#list self#vhdl_name_t names in

369

let typ = self#vhdl_subtype_indication_t typ in

370

let init_val = self#vhdl_expr_t init_val in

371

CstDecl { names; typ; init_val }

372

 SigDecl { names; typ; init_val } >

373

let names = self#list self#vhdl_name_t names in

374

let typ = self#vhdl_subtype_indication_t typ in

375

let init_val = self#vhdl_expr_t init_val in

376

SigDecl { names; typ; init_val }

377

 ComponentDecl { name; generics; ports } >

378

let name = self#vhdl_name_t name in

379

let generics = self#list self#vhdl_port_t generics in

380

let ports = self#list self#vhdl_port_t ports in

381

ComponentDecl { name; generics; ports }

382

 Subprogram { spec; decl_part; stmts } >

383

let spec = self#vhdl_subprogram_spec_t spec in

384

let decl_part = self#list self#vhdl_declaration_t decl_part in

385

let stmts = self#list self#vhdl_sequential_stmt_t stmts in

386

Subprogram { spec; decl_part; stmts }

387


388

method vhdl_declarative_item_t :

389

vhdl_declarative_item_t > vhdl_declarative_item_t=

390

fun { use_clause; declaration; definition } >

391

let use_clause = self#option self#vhdl_load_t use_clause in

392

let declaration = self#option self#vhdl_declaration_t declaration in

393

let definition = self#option self#vhdl_definition_t definition in

394

{ use_clause; declaration; definition }

395


396

method vhdl_waveform_element_t :

397

vhdl_waveform_element_t > vhdl_waveform_element_t=

398

fun { value; delay } >

399

let value = self#option self#vhdl_expr_t value in

400

let delay = self#option self#vhdl_expr_t delay in { value; delay }

401


402

method vhdl_signal_condition_t :

403

vhdl_signal_condition_t > vhdl_signal_condition_t=

404

fun { expr; cond } >

405

let expr = self#list self#vhdl_waveform_element_t expr in

406

let cond = self#vhdl_expr_t cond in { expr; cond }

407


408

method vhdl_signal_selection_t :

409

vhdl_signal_selection_t > vhdl_signal_selection_t=

410

fun { expr; when_sel } >

411

let expr = self#list self#vhdl_waveform_element_t expr in

412

let when_sel = self#list self#vhdl_expr_t when_sel in

413

{ expr; when_sel }

414


415

method vhdl_conditional_signal_t :

416

vhdl_conditional_signal_t > vhdl_conditional_signal_t=

417

fun { postponed; label; lhs; rhs; cond; delay } >

418

let postponed = self#bool postponed in

419

let label = self#vhdl_name_t label in

420

let lhs = self#vhdl_name_t lhs in

421

let rhs = self#list self#vhdl_signal_condition_t rhs in

422

let cond = self#vhdl_expr_t cond in

423

let delay = self#vhdl_expr_t delay in

424

{ postponed; label; lhs; rhs; cond; delay }

425


426

method vhdl_process_t : vhdl_process_t > vhdl_process_t=

427

fun { id; declarations; active_sigs; body } >

428

let id = self#vhdl_name_t id in

429

let declarations = self#list self#vhdl_declarative_item_t declarations in

430

let active_sigs = self#list self#vhdl_name_t active_sigs in

431

let body = self#list self#vhdl_sequential_stmt_t body in

432

{ id; declarations; active_sigs; body }

433


434

method vhdl_selected_signal_t :

435

vhdl_selected_signal_t > vhdl_selected_signal_t=

436

fun { postponed; label; lhs; sel; branches; delay } >

437

let postponed = self#bool postponed in

438

let label = self#vhdl_name_t label in

439

let lhs = self#vhdl_name_t lhs in

440

let sel = self#vhdl_expr_t sel in

441

let branches = self#list self#vhdl_signal_selection_t branches in

442

let delay = self#option self#vhdl_expr_t delay in

443

{ postponed; label; lhs; sel; branches; delay }

444


445

method vhdl_port_mode_t : vhdl_port_mode_t > vhdl_port_mode_t=

446

fun x > x

447


448

method vhdl_component_instantiation_t :

449

vhdl_component_instantiation_t > vhdl_component_instantiation_t=

450

fun { name; inst_unit; archi_name; generic_map; port_map } >

451

let name = self#vhdl_name_t name in

452

let inst_unit = self#vhdl_name_t inst_unit in

453

let archi_name = self#option self#vhdl_name_t archi_name in

454

let generic_map = self#list self#vhdl_assoc_element_t generic_map in

455

let port_map = self#list self#vhdl_assoc_element_t port_map in

456

{ name; inst_unit; archi_name; generic_map; port_map }

457


458

method vhdl_concurrent_stmt_t :

459

vhdl_concurrent_stmt_t > vhdl_concurrent_stmt_t=

460

fun x >

461

match x with

462

 SigAssign a > let a = self#vhdl_conditional_signal_t a in SigAssign a

463

 Process a > let a = self#vhdl_process_t a in Process a

464

 SelectedSig a > let a = self#vhdl_selected_signal_t a in SelectedSig a

465

 ComponentInst a > let a = self#vhdl_component_instantiation_t a in ComponentInst a

466


467

method vhdl_port_t : vhdl_port_t > vhdl_port_t=

468

fun { names; mode; typ; expr } >

469

let names = self#list self#vhdl_name_t names in

470

let mode = self#vhdl_port_mode_t mode in

471

let typ = self#vhdl_subtype_indication_t typ in

472

let expr = self#vhdl_expr_t expr in { names; mode; typ; expr }

473


474

method vhdl_entity_t : vhdl_entity_t > vhdl_entity_t=

475

fun { name; generics; ports; declaration; stmts } >

476

let name = self#vhdl_name_t name in

477

let generics = self#list self#vhdl_port_t generics in

478

let ports = self#list self#vhdl_port_t ports in

479

let declaration = self#list self#vhdl_declarative_item_t declaration

480

in

481

let stmts = self#list self#vhdl_concurrent_stmt_t stmts in

482

{ name; generics; ports; declaration; stmts }

483


484

method vhdl_package_t : vhdl_package_t > vhdl_package_t=

485

fun { name; shared_defs; shared_decls } >

486

let name = self#vhdl_name_t name in

487

let shared_defs = self#list self#vhdl_definition_t shared_defs in

488

let shared_decls = self#list self#vhdl_declaration_t shared_decls in

489

{ name; shared_defs; shared_decls }

490


491

method vhdl_load_t : vhdl_load_t > vhdl_load_t=

492

fun x >

493

match x with

494

 Library a > let a = self#list self#vhdl_name_t a in Library a

495

 Use a > let a = self#list self#vhdl_name_t a in Use a

496


497

method vhdl_architecture_t : vhdl_architecture_t > vhdl_architecture_t=

498

fun { name; entity; declarations; body } >

499

let name = self#vhdl_name_t name in

500

let entity = self#vhdl_name_t entity in

501

let declarations = self#list self#vhdl_declarative_item_t declarations in

502

let body = self#list self#vhdl_concurrent_stmt_t body in

503

{ name; entity; declarations; body }

504


505

method vhdl_configuration_t :

506

vhdl_configuration_t > vhdl_configuration_t= self#unit

507


508

method vhdl_library_unit_t : vhdl_library_unit_t > vhdl_library_unit_t=

509

fun x >

510

match x with

511

 Package a > let a = self#vhdl_package_t a in Package a

512

 Entities a > let a = self#vhdl_entity_t a in Entities a

513

 Architecture a >

514

let a = self#vhdl_architecture_t a in Architecture a

515

 Configuration a >

516

let a = self#vhdl_configuration_t a in Configuration a

517


518

method vhdl_design_unit_t : vhdl_design_unit_t > vhdl_design_unit_t=

519

fun { contexts; library } >

520

let contexts = self#list self#vhdl_load_t contexts in

521

let library = self#vhdl_library_unit_t library in

522

{ contexts; library }

523


524

method vhdl_design_file_t : vhdl_design_file_t > vhdl_design_file_t=

525

fun { design_units } >

526

let design_units = self#list self#vhdl_design_unit_t design_units in

527

{ design_units }

528


529

method vhdl_file_t : vhdl_file_t > vhdl_file_t=

530

fun { design_file } >

531

let design_file = self#vhdl_design_file_t design_file in

532

{ design_file }

533

end
