## lustrec / src / backends / VHDL / vhdl_ast_map.ml @ ab6312e7

History | View | Annotate | Download (23.8 KB)

1 | 40364f53 | Arnaud Dieumegard | open Vhdl_ast_deriving |
---|---|---|---|

2 | d3f0059e | Arnaud Dieumegard | |

3 | e1102543 | Arnaud Dieumegard | let _ = fun (_ : vhdl_cst_val_t) -> () |

4 | d3f0059e | Arnaud Dieumegard | let _ = fun (_ : vhdl_type_t) -> () |

5 | 248eb65e | Arnaud Dieumegard | let _ = fun (_ : vhdl_element_declaration_t) -> () |

6 | d3f0059e | Arnaud Dieumegard | 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_signal_condition_t) -> () |
||

27 | let _ = fun (_ : vhdl_conditional_signal_t) -> () |
||

28 | let _ = fun (_ : vhdl_process_t) -> () |
||

29 | let _ = fun (_ : vhdl_selected_signal_t) -> () |
||

30 | let _ = fun (_ : vhdl_port_mode_t) -> () |
||

31 | 27332198 | Arnaud Dieumegard | let _ = fun (_ : vhdl_component_instantiation_t) -> () |

32 | d3f0059e | Arnaud Dieumegard | let _ = fun (_ : vhdl_concurrent_stmt_t) -> () |

33 | let _ = fun (_ : vhdl_port_t) -> () |
||

34 | let _ = fun (_ : vhdl_entity_t) -> () |
||

35 | let _ = fun (_ : vhdl_package_t) -> () |
||

36 | let _ = fun (_ : vhdl_load_t) -> () |
||

37 | let _ = fun (_ : vhdl_architecture_t) -> () |
||

38 | let _ = fun (_ : vhdl_configuration_t) -> () |
||

39 | let _ = fun (_ : vhdl_library_unit_t) -> () |
||

40 | let _ = fun (_ : vhdl_design_unit_t) -> () |
||

41 | let _ = fun (_ : vhdl_design_file_t) -> () |
||

42 | let _ = fun (_ : vhdl_file_t) -> () |
||

43 | |||

44 | class virtual vhdl_map = |
||

45 | object (self) |
||

46 | method virtual string : string -> string |
||

47 | method virtual list : 'a . ('a -> 'a) -> 'a list -> 'a list |
||

48 | method virtual unit : unit -> unit |
||

49 | method virtual bool : bool -> bool |
||

50 | method virtual option : 'a . ('a -> 'a) -> 'a option -> 'a option |
||

51 | method virtual int : int -> int |
||

52 | method virtual vhdl_name_t : vhdl_name_t -> vhdl_name_t |
||

53 | method virtual vhdl_definition_t : vhdl_definition_t -> vhdl_definition_t |
||

54 | method virtual vhdl_port_t : vhdl_port_t -> vhdl_port_t |
||

55 | method virtual vhdl_expr_t : vhdl_expr_t -> vhdl_expr_t |
||

56 | method virtual vhdl_port_mode_t : vhdl_port_mode_t -> vhdl_port_mode_t |
||

57 | 248eb65e | Arnaud Dieumegard | method virtual vhdl_element_declaration_t : vhdl_element_declaration_t -> vhdl_element_declaration_t |

58 | d3f0059e | Arnaud Dieumegard | method virtual vhdl_subtype_indication_t : vhdl_subtype_indication_t -> vhdl_subtype_indication_t |

59 | method virtual vhdl_conditional_signal_t : vhdl_conditional_signal_t -> vhdl_conditional_signal_t |
||

60 | method virtual vhdl_process_t : vhdl_process_t -> vhdl_process_t |
||

61 | method virtual vhdl_selected_signal_t : vhdl_selected_signal_t -> vhdl_selected_signal_t |
||

62 | method virtual vhdl_signal_selection_t : vhdl_signal_selection_t -> vhdl_signal_selection_t |
||

63 | method virtual vhdl_suffix_selection_t : vhdl_suffix_selection_t -> vhdl_suffix_selection_t |
||

64 | method virtual vhdl_declaration_t : vhdl_declaration_t -> vhdl_declaration_t |
||

65 | method virtual vhdl_sequential_stmt_t : vhdl_sequential_stmt_t -> vhdl_sequential_stmt_t |
||

66 | method virtual vhdl_signal_condition_t : vhdl_signal_condition_t -> vhdl_signal_condition_t |
||

67 | e1102543 | Arnaud Dieumegard | method virtual vhdl_cst_val_t : vhdl_cst_val_t -> vhdl_cst_val_t |

68 | d3f0059e | Arnaud Dieumegard | method virtual vhdl_subprogram_spec_t : vhdl_subprogram_spec_t -> vhdl_subprogram_spec_t |

69 | method virtual vhdl_discrete_range_t : vhdl_discrete_range_t -> vhdl_discrete_range_t |
||

70 | method virtual vhdl_parameter_t : vhdl_parameter_t -> vhdl_parameter_t |
||

71 | 27332198 | Arnaud Dieumegard | method virtual vhdl_component_instantiation_t : vhdl_component_instantiation_t -> vhdl_component_instantiation_t |

72 | d3f0059e | Arnaud Dieumegard | method virtual vhdl_concurrent_stmt_t : vhdl_concurrent_stmt_t -> vhdl_concurrent_stmt_t |

73 | method virtual vhdl_declaration_t : vhdl_declaration_t -> vhdl_declaration_t |
||

74 | method virtual vhdl_architecture_t : vhdl_architecture_t -> vhdl_architecture_t |
||

75 | method virtual vhdl_configuration_t : vhdl_configuration_t -> vhdl_configuration_t |
||

76 | method virtual vhdl_entity_t : vhdl_entity_t -> vhdl_entity_t |
||

77 | method virtual vhdl_package_t : vhdl_package_t -> vhdl_package_t |
||

78 | method virtual vhdl_library_unit_t : vhdl_library_unit_t -> vhdl_library_unit_t |
||

79 | method virtual vhdl_load_t : vhdl_load_t -> vhdl_load_t |
||

80 | method virtual vhdl_design_unit_t : vhdl_design_unit_t -> vhdl_design_unit_t |
||

81 | method virtual vhdl_design_file_t : vhdl_design_file_t -> vhdl_design_file_t |
||

82 | |||

83 | e1102543 | Arnaud Dieumegard | method vhdl_cst_val_t : vhdl_cst_val_t -> vhdl_cst_val_t= |

84 | d3f0059e | Arnaud Dieumegard | fun x -> |

85 | match x with |
||

86 | | CstInt a -> let a = self#int a in CstInt a |
||

87 | | CstStdLogic a -> let a = self#string a in CstStdLogic a |
||

88 | | CstLiteral a -> let a = self#string a in CstLiteral a |
||

89 | |||

90 | method vhdl_type_t : vhdl_type_t -> vhdl_type_t= |
||

91 | fun x -> |
||

92 | match x with |
||

93 | | Base a -> let a = self#string a in Base a |
||

94 | | Range (a,b,c) -> |
||

95 | let a = self#option self#string a in |
||

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

97 | | Bit_vector (a,b) -> |
||

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

99 | 248eb65e | Arnaud Dieumegard | | Array { indexes; const; definition } -> |

100 | let indexes = self#list self#vhdl_name_t indexes in |
||

101 | let const = self#option self#vhdl_constraint_t const in |
||

102 | let definition = self#vhdl_subtype_indication_t definition in |
||

103 | Array { indexes; const; definition } |
||

104 | | Record a -> |
||

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

106 | | Enumerated a -> |
||

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

108 | d3f0059e | Arnaud Dieumegard | | Void -> Void |

109 | 248eb65e | Arnaud Dieumegard | method vhdl_element_declaration_t : |

110 | vhdl_element_declaration_t -> vhdl_element_declaration_t= |
||

111 | fun { names; definition } -> |
||

112 | let names = self#list self#vhdl_name_t names in |
||

113 | let definition = self#vhdl_subtype_indication_t definition in |
||

114 | { names; definition } |
||

115 | d3f0059e | Arnaud Dieumegard | method vhdl_subtype_indication_t : |

116 | vhdl_subtype_indication_t -> vhdl_subtype_indication_t= |
||

117 | fun { name; functionName; const } -> |
||

118 | let name = self#vhdl_name_t name in |
||

119 | let functionName = self#vhdl_name_t functionName in |
||

120 | let const = self#vhdl_constraint_t const in |
||

121 | { name; functionName; const } |
||

122 | method vhdl_discrete_range_t : |
||

123 | vhdl_discrete_range_t -> vhdl_discrete_range_t= |
||

124 | fun x -> |
||

125 | match x with |
||

126 | | SubDiscreteRange a -> |
||

127 | let a = self#vhdl_subtype_indication_t a in SubDiscreteRange a |
||

128 | | NamedRange a -> let a = self#vhdl_name_t a in NamedRange a |
||

129 | | DirectedRange { direction; from; _to } -> |
||

130 | let direction = self#string direction in |
||

131 | let from = self#vhdl_expr_t from in |
||

132 | let _to = self#vhdl_expr_t _to in |
||

133 | DirectedRange { direction; from; _to } |
||

134 | |||

135 | method vhdl_constraint_t : vhdl_constraint_t -> vhdl_constraint_t= |
||

136 | fun x -> |
||

137 | match x with |
||

138 | | RefConstraint { ref_name } -> |
||

139 | let ref_name = self#vhdl_name_t ref_name in |
||

140 | RefConstraint { ref_name } |
||

141 | | RangeConstraint { range } -> |
||

142 | let range = self#vhdl_discrete_range_t range in |
||

143 | RangeConstraint { range } |
||

144 | | IndexConstraint { ranges } -> |
||

145 | let ranges = self#list self#vhdl_discrete_range_t ranges in |
||

146 | IndexConstraint { ranges } |
||

147 | | ArrayConstraint { ranges; sub } -> |
||

148 | let ranges = self#list self#vhdl_discrete_range_t ranges in |
||

149 | let sub = self#vhdl_constraint_t sub in |
||

150 | ArrayConstraint { ranges; sub } |
||

151 | | RecordConstraint -> RecordConstraint |
||

152 | | NoConstraint -> NoConstraint |
||

153 | |||

154 | method vhdl_definition_t : vhdl_definition_t -> vhdl_definition_t= |
||

155 | fun x -> |
||

156 | match x with |
||

157 | | Type { name; definition } -> |
||

158 | let name = self#vhdl_name_t name in |
||

159 | let definition = self#vhdl_type_t definition in |
||

160 | Type { name; definition } |
||

161 | | Subtype { name; typ } -> |
||

162 | let name = self#vhdl_name_t name in |
||

163 | let typ = self#vhdl_subtype_indication_t typ in |
||

164 | Subtype { name; typ } |
||

165 | method vhdl_expr_t : vhdl_expr_t -> vhdl_expr_t= |
||

166 | fun x -> |
||

167 | match x with |
||

168 | | Call a -> let a = self#vhdl_name_t a in Call a |
||

169 | ab6312e7 | Arnaud Dieumegard | | Cst { value; unit_name } -> |

170 | let value = self#vhdl_cst_val_t value in |
||

171 | let unit_name = self#option self#vhdl_name_t unit_name in |
||

172 | Cst { value; unit_name } |
||

173 | d3f0059e | Arnaud Dieumegard | | Op { id; args } -> |

174 | let id = self#string id in |
||

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

176 | | IsNull -> IsNull |
||

177 | | Time { value; phy_unit } -> |
||

178 | let value = self#int value in |
||

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

180 | | Sig { name; att } -> |
||

181 | let name = self#vhdl_name_t name in |
||

182 | let att = self#option self#vhdl_signal_attributes_t att in |
||

183 | Sig { name; att } |
||

184 | | SuffixMod { expr; selection } -> |
||

185 | let expr = self#vhdl_expr_t expr in |
||

186 | let selection = self#vhdl_suffix_selection_t selection in |
||

187 | SuffixMod { expr; selection } |
||

188 | | Aggregate { elems } -> |
||

189 | let elems = self#list self#vhdl_element_assoc_t elems in |
||

190 | Aggregate { elems } |
||

191 | | Others -> Others |
||

192 | method vhdl_name_t : vhdl_name_t -> vhdl_name_t= |
||

193 | fun x -> |
||

194 | match x with |
||

195 | | Simple a -> let a = self#string a in Simple a |
||

196 | | Identifier a -> let a = self#string a in Identifier a |
||

197 | | Selected a -> let a = self#list self#vhdl_name_t a in Selected a |
||

198 | | Index { id; exprs } -> |
||

199 | let id = self#vhdl_name_t id in |
||

200 | let exprs = self#list self#vhdl_expr_t exprs in |
||

201 | Index { id; exprs } |
||

202 | | Slice { id; range } -> |
||

203 | let id = self#vhdl_name_t id in |
||

204 | let range = self#vhdl_discrete_range_t range in |
||

205 | Slice { id; range } |
||

206 | | Attribute { id; designator; expr } -> |
||

207 | let id = self#vhdl_name_t id in |
||

208 | let designator = self#vhdl_name_t designator in |
||

209 | let expr = self#vhdl_expr_t expr in |
||

210 | Attribute { id; designator; expr } |
||

211 | | Function { id; assoc_list } -> |
||

212 | let id = self#vhdl_name_t id in |
||

213 | let assoc_list = self#list self#vhdl_assoc_element_t assoc_list |
||

214 | in |
||

215 | Function { id; assoc_list } |
||

216 | | NoName -> NoName |
||

217 | method vhdl_assoc_element_t : |
||

218 | vhdl_assoc_element_t -> vhdl_assoc_element_t= |
||

219 | fun |
||

220 | { formal_name; formal_arg; actual_name; actual_designator; |
||

221 | actual_expr } |
||

222 | -> |
||

223 | let formal_name = self#option self#vhdl_name_t formal_name in |
||

224 | let formal_arg = self#option self#vhdl_name_t formal_arg in |
||

225 | let actual_name = self#option self#vhdl_name_t actual_name in |
||

226 | let actual_designator = |
||

227 | self#option self#vhdl_name_t actual_designator in |
||

228 | let actual_expr = self#option self#vhdl_expr_t actual_expr in |
||

229 | { |
||

230 | formal_name; |
||

231 | formal_arg; |
||

232 | actual_name; |
||

233 | actual_designator; |
||

234 | actual_expr |
||

235 | } |
||

236 | method vhdl_element_assoc_t : |
||

237 | vhdl_element_assoc_t -> vhdl_element_assoc_t= |
||

238 | fun { choices; expr } -> |
||

239 | let choices = self#list self#vhdl_expr_t choices in |
||

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

241 | method vhdl_array_attributes_t : |
||

242 | vhdl_array_attributes_t -> vhdl_array_attributes_t= |
||

243 | fun x -> |
||

244 | match x with |
||

245 | | AAttInt { id; arg } -> |
||

246 | let id = self#string id in |
||

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

248 | | AAttAscending -> AAttAscending |
||

249 | method vhdl_signal_attributes_t : |
||

250 | vhdl_signal_attributes_t -> vhdl_signal_attributes_t= |
||

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

252 | method vhdl_string_attributes_t : |
||

253 | vhdl_string_attributes_t -> vhdl_string_attributes_t= |
||

254 | fun x -> |
||

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

256 | method vhdl_suffix_selection_t : vhdl_suffix_selection_t -> vhdl_suffix_selection_t= |
||

257 | fun x -> |
||

258 | match x with |
||

259 | | Idx a -> let a = self#int a in Idx a |
||

260 | | SuffixRange (a,b) -> |
||

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

262 | |||

263 | method vhdl_type_attributes_t : |
||

264 | 'a . |
||

265 | ('a -> 'a) -> 'a vhdl_type_attributes_t -> 'a vhdl_type_attributes_t= |
||

266 | fun _basetype -> |
||

267 | fun x -> |
||

268 | match x with |
||

269 | | TAttNoArg { id } -> let id = self#string id in TAttNoArg { id } |
||

270 | | TAttIntArg { id; arg } -> |
||

271 | let id = self#string id in |
||

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

273 | | TAttValArg { id; arg } -> |
||

274 | let id = self#string id in |
||

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

276 | | TAttStringArg { id; arg } -> |
||

277 | let id = self#string id in |
||

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

279 | |||

280 | method vhdl_parameter_t : vhdl_parameter_t -> vhdl_parameter_t= |
||

281 | fun { names; mode; typ; init_val } -> |
||

282 | let names = self#list self#vhdl_name_t names in |
||

283 | let mode = self#list self#string mode in |
||

284 | let typ = self#vhdl_subtype_indication_t typ in |
||

285 | e1102543 | Arnaud Dieumegard | let init_val = self#option self#vhdl_cst_val_t init_val in |

286 | d3f0059e | Arnaud Dieumegard | { names; mode; typ; init_val } |

287 | |||

288 | method vhdl_subprogram_spec_t : |
||

289 | vhdl_subprogram_spec_t -> vhdl_subprogram_spec_t= |
||

290 | fun { name; typeMark; parameters; isPure } -> |
||

291 | let name = self#string name in |
||

292 | let typeMark = self#vhdl_name_t typeMark in |
||

293 | let parameters = self#list self#vhdl_parameter_t parameters in |
||

294 | let isPure = self#bool isPure in |
||

295 | { name; typeMark; parameters; isPure } |
||

296 | |||

297 | method vhdl_sequential_stmt_t : |
||

298 | vhdl_sequential_stmt_t -> vhdl_sequential_stmt_t= |
||

299 | fun x -> |
||

300 | match x with |
||

301 | | VarAssign { label; lhs; rhs } -> |
||

302 | let label = self#vhdl_name_t label in |
||

303 | let lhs = self#vhdl_name_t lhs in |
||

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

305 | | SigSeqAssign { label; lhs; rhs } -> |
||

306 | let label = self#vhdl_name_t label in |
||

307 | let lhs = self#vhdl_name_t lhs in |
||

308 | let rhs = self#list self#vhdl_expr_t rhs in |
||

309 | SigSeqAssign { label; lhs; rhs } |
||

310 | | If { label; if_cases; default } -> |
||

311 | let label = self#vhdl_name_t label in |
||

312 | let if_cases = self#list self#vhdl_if_case_t if_cases in |
||

313 | let default = self#list self#vhdl_sequential_stmt_t default in |
||

314 | If { label; if_cases; default } |
||

315 | | Case { label; guard; branches } -> |
||

316 | let label = self#vhdl_name_t label in |
||

317 | let guard = self#vhdl_expr_t guard in |
||

318 | let branches = self#list self#vhdl_case_item_t branches in |
||

319 | Case { label; guard; branches } |
||

320 | | Exit { label; loop_label; condition } -> |
||

321 | let label = self#vhdl_name_t label in |
||

322 | let loop_label = self#option self#string loop_label in |
||

323 | let condition = self#option self#vhdl_expr_t condition in |
||

324 | Exit { label; loop_label; condition } |
||

325 | | Assert { label; cond; report; severity } -> |
||

326 | let label = self#vhdl_name_t label in |
||

327 | let cond = self#vhdl_expr_t cond in |
||

328 | let report = self#vhdl_expr_t report in |
||

329 | let severity = self#vhdl_expr_t severity in |
||

330 | Assert { label; cond; report; severity } |
||

331 | 6d3b5007 | Arnaud Dieumegard | | ProcedureCall { label; name; assocs } -> |

332 | let label = self#vhdl_name_t label in |
||

333 | let name = self#vhdl_name_t name in |
||

334 | let assocs = self#list self#vhdl_assoc_element_t assocs in |
||

335 | ProcedureCall { label; name; assocs } |
||

336 | d3f0059e | Arnaud Dieumegard | | Wait -> Wait |

337 | | Null { label } -> |
||

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

339 | | Return { label } -> |
||

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

341 | method vhdl_if_case_t : vhdl_if_case_t -> vhdl_if_case_t= |
||

342 | fun { if_cond; if_block } -> |
||

343 | let if_cond = self#vhdl_expr_t if_cond in |
||

344 | let if_block = self#list self#vhdl_sequential_stmt_t if_block in |
||

345 | { if_cond; if_block } |
||

346 | method vhdl_case_item_t : vhdl_case_item_t -> vhdl_case_item_t= |
||

347 | fun { when_cond; when_stmt } -> |
||

348 | let when_cond = self#list self#vhdl_expr_t when_cond in |
||

349 | let when_stmt = self#list self#vhdl_sequential_stmt_t when_stmt in |
||

350 | { when_cond; when_stmt } |
||

351 | |||

352 | method vhdl_declaration_t : vhdl_declaration_t -> vhdl_declaration_t= |
||

353 | fun x -> |
||

354 | match x with |
||

355 | | VarDecl { names; typ; init_val } -> |
||

356 | let names = self#list self#vhdl_name_t names in |
||

357 | let typ = self#vhdl_subtype_indication_t typ in |
||

358 | d4175560 | Arnaud Dieumegard | let init_val = self#vhdl_expr_t init_val in |

359 | d3f0059e | Arnaud Dieumegard | VarDecl { names; typ; init_val } |

360 | | CstDecl { names; typ; init_val } -> |
||

361 | let names = self#list self#vhdl_name_t names in |
||

362 | let typ = self#vhdl_subtype_indication_t typ in |
||

363 | d4175560 | Arnaud Dieumegard | let init_val = self#vhdl_expr_t init_val in |

364 | d3f0059e | Arnaud Dieumegard | CstDecl { names; typ; init_val } |

365 | | SigDecl { names; typ; init_val } -> |
||

366 | let names = self#list self#vhdl_name_t names in |
||

367 | let typ = self#vhdl_subtype_indication_t typ in |
||

368 | d4175560 | Arnaud Dieumegard | let init_val = self#vhdl_expr_t init_val in |

369 | d3f0059e | Arnaud Dieumegard | SigDecl { names; typ; init_val } |

370 | | Subprogram { name; kind; spec; decl_part; stmts } -> |
||

371 | let name = self#vhdl_name_t name in |
||

372 | let kind = self#string kind in |
||

373 | let spec = self#vhdl_subprogram_spec_t spec in |
||

374 | let decl_part = self#list self#vhdl_declaration_t decl_part in |
||

375 | let stmts = self#list self#vhdl_sequential_stmt_t stmts in |
||

376 | Subprogram { name; kind; spec; decl_part; stmts } |
||

377 | |||

378 | method vhdl_signal_condition_t : vhdl_signal_condition_t -> vhdl_signal_condition_t= |
||

379 | fun { expr; cond } -> |
||

380 | let expr = self#list self#vhdl_expr_t expr in |
||

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

382 | |||

383 | method vhdl_signal_selection_t : vhdl_signal_selection_t -> vhdl_signal_selection_t= |
||

384 | fun { expr; when_sel } -> |
||

385 | let expr = self#vhdl_expr_t expr in |
||

386 | let when_sel = self#list self#vhdl_expr_t when_sel in |
||

387 | { expr; when_sel } |
||

388 | |||

389 | method vhdl_conditional_signal_t : |
||

390 | vhdl_conditional_signal_t -> vhdl_conditional_signal_t= |
||

391 | fun { postponed; label; lhs; rhs; cond; delay } -> |
||

392 | let postponed = self#bool postponed in |
||

393 | let label = self#vhdl_name_t label in |
||

394 | let lhs = self#vhdl_name_t lhs in |
||

395 | let rhs = self#list self#vhdl_signal_condition_t rhs in |
||

396 | let cond = self#vhdl_expr_t cond in |
||

397 | let delay = self#vhdl_expr_t delay in |
||

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

399 | |||

400 | |||

401 | method vhdl_process_t : vhdl_process_t -> vhdl_process_t= |
||

402 | fun { id; declarations; active_sigs; body } -> |
||

403 | let id = self#vhdl_name_t id in |
||

404 | let declarations = |
||

405 | self#option (self#list self#vhdl_declaration_t) declarations in |
||

406 | let active_sigs = self#list self#vhdl_name_t active_sigs in |
||

407 | let body = self#list self#vhdl_sequential_stmt_t body in |
||

408 | { id; declarations; active_sigs; body } |
||

409 | |||

410 | method vhdl_selected_signal_t : vhdl_selected_signal_t -> vhdl_selected_signal_t= |
||

411 | fun { postponed; label; lhs; sel; branches; delay } -> |
||

412 | let postponed = self#bool postponed in |
||

413 | let label = self#vhdl_name_t label in |
||

414 | let lhs = self#vhdl_name_t lhs in |
||

415 | let sel = self#vhdl_expr_t sel in |
||

416 | let branches = self#list self#vhdl_signal_selection_t branches in |
||

417 | let delay = self#option self#vhdl_expr_t delay in |
||

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

419 | |||

420 | method vhdl_port_mode_t : vhdl_port_mode_t -> vhdl_port_mode_t= |
||

421 | fun x -> x |
||

422 | |||

423 | 27332198 | Arnaud Dieumegard | method vhdl_component_instantiation_t : |

424 | vhdl_component_instantiation_t -> vhdl_component_instantiation_t= |
||

425 | 6f9095f6 | Arnaud Dieumegard | fun { name; inst_unit; archi_name; generic_map; port_map } -> |

426 | 27332198 | Arnaud Dieumegard | let name = self#vhdl_name_t name in |

427 | let inst_unit = self#vhdl_name_t inst_unit in |
||

428 | 6f9095f6 | Arnaud Dieumegard | let archi_name = self#option self#vhdl_name_t archi_name in |

429 | 27332198 | Arnaud Dieumegard | let generic_map = self#option self#vhdl_assoc_element_t generic_map |

430 | in |
||

431 | let port_map = self#option self#vhdl_assoc_element_t port_map in |
||

432 | 6f9095f6 | Arnaud Dieumegard | { name; inst_unit; archi_name; generic_map; port_map } |

433 | 27332198 | Arnaud Dieumegard | |

434 | d3f0059e | Arnaud Dieumegard | method vhdl_concurrent_stmt_t : |

435 | vhdl_concurrent_stmt_t -> vhdl_concurrent_stmt_t= |
||

436 | fun x -> |
||

437 | match x with |
||

438 | | SigAssign a -> let a = self#vhdl_conditional_signal_t a in SigAssign a |
||

439 | | Process a -> let a = self#vhdl_process_t a in Process a |
||

440 | | SelectedSig a -> let a = self#vhdl_selected_signal_t a in SelectedSig a |
||

441 | 27332198 | Arnaud Dieumegard | | ComponentInst a -> let a = self#vhdl_component_instantiation_t a in ComponentInst a |

442 | d3f0059e | Arnaud Dieumegard | |

443 | method vhdl_port_t : vhdl_port_t -> vhdl_port_t= |
||

444 | fun { names; mode; typ; expr } -> |
||

445 | let names = self#list self#vhdl_name_t names in |
||

446 | let mode = self#vhdl_port_mode_t mode in |
||

447 | let typ = self#vhdl_subtype_indication_t typ in |
||

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

449 | |||

450 | method vhdl_entity_t : vhdl_entity_t -> vhdl_entity_t= |
||

451 | fun { name; generics; ports; declaration; stmts } -> |
||

452 | let name = self#vhdl_name_t name in |
||

453 | let generics = self#list self#vhdl_port_t generics in |
||

454 | let ports = self#list self#vhdl_port_t ports in |
||

455 | let declaration = self#list self#vhdl_declaration_t declaration in |
||

456 | let stmts = self#list self#vhdl_concurrent_stmt_t stmts in |
||

457 | { name; generics; ports; declaration; stmts } |
||

458 | |||

459 | method vhdl_package_t : vhdl_package_t -> vhdl_package_t= |
||

460 | 248eb65e | Arnaud Dieumegard | fun { name; shared_defs; shared_decls } -> |

461 | d3f0059e | Arnaud Dieumegard | let name = self#vhdl_name_t name in |

462 | let shared_defs = self#list self#vhdl_definition_t shared_defs in |
||

463 | 248eb65e | Arnaud Dieumegard | let shared_decls = self#list self#vhdl_declaration_t shared_decls in |

464 | { name; shared_defs; shared_decls } |
||

465 | d3f0059e | Arnaud Dieumegard | |

466 | method vhdl_load_t : vhdl_load_t -> vhdl_load_t= |
||

467 | fun x -> |
||

468 | match x with |
||

469 | | Library a -> let a = self#list self#vhdl_name_t a in Library a |
||

470 | | Use a -> let a = self#list self#vhdl_name_t a in Use a |
||

471 | |||

472 | method vhdl_architecture_t : vhdl_architecture_t -> vhdl_architecture_t= |
||

473 | fun { name; entity; declarations; body } -> |
||

474 | let name = self#vhdl_name_t name in |
||

475 | let entity = self#vhdl_name_t entity in |
||

476 | let declarations = self#list self#vhdl_declaration_t declarations in |
||

477 | let body = self#list self#vhdl_concurrent_stmt_t body in |
||

478 | { name; entity; declarations; body } |
||

479 | |||

480 | method vhdl_configuration_t : |
||

481 | vhdl_configuration_t -> vhdl_configuration_t= self#unit |
||

482 | |||

483 | method vhdl_library_unit_t : vhdl_library_unit_t -> vhdl_library_unit_t= |
||

484 | fun x -> |
||

485 | match x with |
||

486 | | Package a -> let a = self#vhdl_package_t a in Package a |
||

487 | | Entities a -> let a = self#vhdl_entity_t a in Entities a |
||

488 | | Architecture a -> |
||

489 | let a = self#vhdl_architecture_t a in Architecture a |
||

490 | | Configuration a -> |
||

491 | let a = self#vhdl_configuration_t a in Configuration a |
||

492 | |||

493 | method vhdl_design_unit_t : vhdl_design_unit_t -> vhdl_design_unit_t= |
||

494 | fun { contexts; library } -> |
||

495 | let contexts = self#list self#vhdl_load_t contexts in |
||

496 | let library = self#vhdl_library_unit_t library in |
||

497 | { contexts; library } |
||

498 | |||

499 | method vhdl_design_file_t : vhdl_design_file_t -> vhdl_design_file_t= |
||

500 | fun { design_units } -> |
||

501 | let design_units = self#list self#vhdl_design_unit_t design_units in |
||

502 | { design_units } |
||

503 | |||

504 | method vhdl_file_t : vhdl_file_t -> vhdl_file_t= |
||

505 | fun { design_file } -> |
||

506 | let design_file = self#vhdl_design_file_t design_file in |
||

507 | { design_file } |
||

508 | end |