sv_parser_parser/source_text/
module_items.rs

1use crate::*;
2
3// -----------------------------------------------------------------------------
4
5#[tracable_parser]
6#[packrat_parser]
7pub(crate) fn elaboration_system_task(s: Span) -> IResult<Span, ElaborationSystemTask> {
8    alt((
9        elaboration_system_task_fatal,
10        elaboration_system_task_error,
11        elaboration_system_task_warning,
12        elaboration_system_task_info,
13    ))(s)
14}
15
16#[tracable_parser]
17#[packrat_parser]
18pub(crate) fn elaboration_system_task_fatal(s: Span) -> IResult<Span, ElaborationSystemTask> {
19    let (s, a) = keyword("$fatal")(s)?;
20    let (s, b) = opt(paren(pair(
21        finish_number,
22        opt(pair(symbol(","), list_of_arguments)),
23    )))(s)?;
24    let (s, c) = symbol(";")(s)?;
25    Ok((
26        s,
27        ElaborationSystemTask::TaskFatal(Box::new(ElaborationSystemTaskFatal { nodes: (a, b, c) })),
28    ))
29}
30
31#[tracable_parser]
32#[packrat_parser]
33pub(crate) fn elaboration_system_task_error(s: Span) -> IResult<Span, ElaborationSystemTask> {
34    let (s, a) = keyword("$error")(s)?;
35    let (s, b) = opt(paren(opt(list_of_arguments)))(s)?;
36    let (s, c) = symbol(";")(s)?;
37    Ok((
38        s,
39        ElaborationSystemTask::TaskError(Box::new(ElaborationSystemTaskError { nodes: (a, b, c) })),
40    ))
41}
42
43#[tracable_parser]
44#[packrat_parser]
45pub(crate) fn elaboration_system_task_warning(s: Span) -> IResult<Span, ElaborationSystemTask> {
46    let (s, a) = keyword("$warning")(s)?;
47    let (s, b) = opt(paren(opt(list_of_arguments)))(s)?;
48    let (s, c) = symbol(";")(s)?;
49    Ok((
50        s,
51        ElaborationSystemTask::TaskWarning(Box::new(ElaborationSystemTaskWarning {
52            nodes: (a, b, c),
53        })),
54    ))
55}
56
57#[tracable_parser]
58#[packrat_parser]
59pub(crate) fn elaboration_system_task_info(s: Span) -> IResult<Span, ElaborationSystemTask> {
60    let (s, a) = keyword("$info")(s)?;
61    let (s, b) = opt(paren(opt(list_of_arguments)))(s)?;
62    let (s, c) = symbol(";")(s)?;
63    Ok((
64        s,
65        ElaborationSystemTask::TaskInfo(Box::new(ElaborationSystemTaskInfo { nodes: (a, b, c) })),
66    ))
67}
68
69#[tracable_parser]
70#[packrat_parser]
71pub(crate) fn finish_number(s: Span) -> IResult<Span, FinishNumber> {
72    alt((
73        map(symbol("0"), |x| FinishNumber::Zero(Box::new(x))),
74        map(symbol("1"), |x| FinishNumber::One(Box::new(x))),
75        map(symbol("2"), |x| FinishNumber::Two(Box::new(x))),
76    ))(s)
77}
78
79#[tracable_parser]
80#[packrat_parser]
81pub(crate) fn module_common_item(s: Span) -> IResult<Span, ModuleCommonItem> {
82    alt((
83        map(module_or_generate_item_declaration, |x| {
84            ModuleCommonItem::ModuleOrGenerateItemDeclaration(Box::new(x))
85        }),
86        map(interface_instantiation, |x| {
87            ModuleCommonItem::InterfaceInstantiation(Box::new(x))
88        }),
89        map(program_instantiation, |x| {
90            ModuleCommonItem::ProgramInstantiation(Box::new(x))
91        }),
92        map(assertion_item, |x| {
93            ModuleCommonItem::AssertionItem(Box::new(x))
94        }),
95        map(bind_directive, |x| {
96            ModuleCommonItem::BindDirective(Box::new(x))
97        }),
98        map(continuous_assign, |x| {
99            ModuleCommonItem::ContinuousAssign(Box::new(x))
100        }),
101        map(net_alias, |x| ModuleCommonItem::NetAlias(Box::new(x))),
102        map(initial_construct, |x| {
103            ModuleCommonItem::InitialConstruct(Box::new(x))
104        }),
105        map(final_construct, |x| {
106            ModuleCommonItem::FinalConstruct(Box::new(x))
107        }),
108        map(always_construct, |x| {
109            ModuleCommonItem::AlwaysConstruct(Box::new(x))
110        }),
111        map(loop_generate_construct, |x| {
112            ModuleCommonItem::LoopGenerateConstruct(Box::new(x))
113        }),
114        map(conditional_generate_construct, |x| {
115            ModuleCommonItem::ConditionalGenerateConstruct(Box::new(x))
116        }),
117        map(elaboration_system_task, |x| {
118            ModuleCommonItem::ElaborationSystemTask(Box::new(x))
119        }),
120    ))(s)
121}
122
123#[tracable_parser]
124#[packrat_parser]
125pub(crate) fn module_item(s: Span) -> IResult<Span, ModuleItem> {
126    alt((
127        map(pair(port_declaration, symbol(";")), |x| {
128            ModuleItem::PortDeclaration(Box::new(x))
129        }),
130        map(non_port_module_item, |x| {
131            ModuleItem::NonPortModuleItem(Box::new(x))
132        }),
133    ))(s)
134}
135
136#[tracable_parser]
137#[packrat_parser]
138pub(crate) fn module_or_generate_item(s: Span) -> IResult<Span, ModuleOrGenerateItem> {
139    alt((
140        module_or_generate_item_parameter,
141        module_or_generate_item_module,
142        module_or_generate_item_module_item,
143        module_or_generate_item_gate,
144        module_or_generate_item_udp,
145    ))(s)
146}
147
148#[tracable_parser]
149#[packrat_parser]
150pub(crate) fn module_or_generate_item_parameter(s: Span) -> IResult<Span, ModuleOrGenerateItem> {
151    let (s, a) = many0(attribute_instance)(s)?;
152    let (s, b) = parameter_override(s)?;
153    Ok((
154        s,
155        ModuleOrGenerateItem::Parameter(Box::new(ModuleOrGenerateItemParameter { nodes: (a, b) })),
156    ))
157}
158
159#[tracable_parser]
160#[packrat_parser]
161pub(crate) fn module_or_generate_item_gate(s: Span) -> IResult<Span, ModuleOrGenerateItem> {
162    let (s, a) = many0(attribute_instance)(s)?;
163    let (s, b) = gate_instantiation(s)?;
164    Ok((
165        s,
166        ModuleOrGenerateItem::Gate(Box::new(ModuleOrGenerateItemGate { nodes: (a, b) })),
167    ))
168}
169
170#[tracable_parser]
171#[packrat_parser]
172pub(crate) fn module_or_generate_item_udp(s: Span) -> IResult<Span, ModuleOrGenerateItem> {
173    let (s, a) = many0(attribute_instance)(s)?;
174    let (s, b) = udp_instantiation(s)?;
175    Ok((
176        s,
177        ModuleOrGenerateItem::Udp(Box::new(ModuleOrGenerateItemUdp { nodes: (a, b) })),
178    ))
179}
180
181#[tracable_parser]
182#[packrat_parser]
183pub(crate) fn module_or_generate_item_module(s: Span) -> IResult<Span, ModuleOrGenerateItem> {
184    let (s, a) = many0(attribute_instance)(s)?;
185    let (s, b) = module_instantiation(s)?;
186    Ok((
187        s,
188        ModuleOrGenerateItem::Module(Box::new(ModuleOrGenerateItemModule { nodes: (a, b) })),
189    ))
190}
191
192#[recursive_parser]
193#[tracable_parser]
194#[packrat_parser]
195pub(crate) fn module_or_generate_item_module_item(s: Span) -> IResult<Span, ModuleOrGenerateItem> {
196    let (s, a) = many0(attribute_instance)(s)?;
197    let (s, b) = module_common_item(s)?;
198    Ok((
199        s,
200        ModuleOrGenerateItem::ModuleItem(Box::new(ModuleOrGenerateItemModuleItem {
201            nodes: (a, b),
202        })),
203    ))
204}
205
206#[tracable_parser]
207#[packrat_parser]
208pub(crate) fn module_or_generate_item_declaration(
209    s: Span,
210) -> IResult<Span, ModuleOrGenerateItemDeclaration> {
211    alt((
212        map(package_or_generate_item_declaration, |x| {
213            ModuleOrGenerateItemDeclaration::PackageOrGenerateItemDeclaration(Box::new(x))
214        }),
215        map(genvar_declaration, |x| {
216            ModuleOrGenerateItemDeclaration::GenvarDeclaration(Box::new(x))
217        }),
218        map(clocking_declaration, |x| {
219            ModuleOrGenerateItemDeclaration::ClockingDeclaration(Box::new(x))
220        }),
221        module_or_generate_item_declaration_clocking,
222        module_or_generate_item_declaration_disable,
223    ))(s)
224}
225
226#[tracable_parser]
227#[packrat_parser]
228pub(crate) fn module_or_generate_item_declaration_clocking(
229    s: Span,
230) -> IResult<Span, ModuleOrGenerateItemDeclaration> {
231    let (s, a) = keyword("default")(s)?;
232    let (s, b) = keyword("clocking")(s)?;
233    let (s, c) = clocking_identifier(s)?;
234    let (s, d) = symbol(";")(s)?;
235    Ok((
236        s,
237        ModuleOrGenerateItemDeclaration::Clocking(Box::new(
238            ModuleOrGenerateItemDeclarationClocking {
239                nodes: (a, b, c, d),
240            },
241        )),
242    ))
243}
244
245#[tracable_parser]
246#[packrat_parser]
247pub(crate) fn module_or_generate_item_declaration_disable(
248    s: Span,
249) -> IResult<Span, ModuleOrGenerateItemDeclaration> {
250    let (s, a) = keyword("default")(s)?;
251    let (s, b) = keyword("disable")(s)?;
252    let (s, c) = keyword("iff")(s)?;
253    let (s, d) = expression_or_dist(s)?;
254    let (s, e) = symbol(";")(s)?;
255    Ok((
256        s,
257        ModuleOrGenerateItemDeclaration::Disable(Box::new(
258            ModuleOrGenerateItemDeclarationDisable {
259                nodes: (a, b, c, d, e),
260            },
261        )),
262    ))
263}
264
265#[tracable_parser]
266#[packrat_parser]
267pub(crate) fn non_port_module_item(s: Span) -> IResult<Span, NonPortModuleItem> {
268    alt((
269        map(generate_region, |x| {
270            NonPortModuleItem::GenerateRegion(Box::new(x))
271        }),
272        map(module_or_generate_item, |x| {
273            NonPortModuleItem::ModuleOrGenerateItem(Box::new(x))
274        }),
275        map(specify_block, |x| {
276            NonPortModuleItem::SpecifyBlock(Box::new(x))
277        }),
278        non_port_module_item_specparam,
279        map(program_declaration, |x| {
280            NonPortModuleItem::ProgramDeclaration(Box::new(x))
281        }),
282        map(module_declaration, |x| {
283            NonPortModuleItem::ModuleDeclaration(Box::new(x))
284        }),
285        map(interface_declaration, |x| {
286            NonPortModuleItem::InterfaceDeclaration(Box::new(x))
287        }),
288        map(timeunits_declaration, |x| {
289            NonPortModuleItem::TimeunitsDeclaration(Box::new(x))
290        }),
291    ))(s)
292}
293
294#[tracable_parser]
295#[packrat_parser]
296pub(crate) fn non_port_module_item_specparam(s: Span) -> IResult<Span, NonPortModuleItem> {
297    let (s, a) = many0(attribute_instance)(s)?;
298    let (s, b) = specparam_declaration(s)?;
299    Ok((
300        s,
301        NonPortModuleItem::Specparam(Box::new(NonPortModuleItemSpecparam { nodes: (a, b) })),
302    ))
303}
304
305#[tracable_parser]
306#[packrat_parser]
307pub(crate) fn parameter_override(s: Span) -> IResult<Span, ParameterOverride> {
308    let (s, a) = keyword("defparam")(s)?;
309    let (s, b) = list_of_defparam_assignments(s)?;
310    let (s, c) = symbol(";")(s)?;
311    Ok((s, ParameterOverride { nodes: (a, b, c) }))
312}
313
314#[tracable_parser]
315#[packrat_parser]
316pub(crate) fn bind_directive(s: Span) -> IResult<Span, BindDirective> {
317    alt((bind_directive_scope, bind_directive_instance))(s)
318}
319
320#[tracable_parser]
321#[packrat_parser]
322pub(crate) fn bind_directive_scope(s: Span) -> IResult<Span, BindDirective> {
323    let (s, a) = keyword("bind")(s)?;
324    let (s, b) = bind_target_scope(s)?;
325    let (s, c) = opt(pair(symbol(":"), bind_target_instance_list))(s)?;
326    let (s, d) = bind_instantiation(s)?;
327    Ok((
328        s,
329        BindDirective::Scope(Box::new(BindDirectiveScope {
330            nodes: (a, b, c, d),
331        })),
332    ))
333}
334
335#[tracable_parser]
336#[packrat_parser]
337pub(crate) fn bind_directive_instance(s: Span) -> IResult<Span, BindDirective> {
338    let (s, a) = keyword("bind")(s)?;
339    let (s, b) = bind_target_instance(s)?;
340    let (s, c) = bind_instantiation(s)?;
341    Ok((
342        s,
343        BindDirective::Instance(Box::new(BindDirectiveInstance { nodes: (a, b, c) })),
344    ))
345}
346
347#[tracable_parser]
348#[packrat_parser]
349pub(crate) fn bind_target_scope(s: Span) -> IResult<Span, BindTargetScope> {
350    alt((
351        map(module_identifier, |x| {
352            BindTargetScope::ModuleIdentifier(Box::new(x))
353        }),
354        map(interface_identifier, |x| {
355            BindTargetScope::InterfaceIdentifier(Box::new(x))
356        }),
357    ))(s)
358}
359
360#[tracable_parser]
361#[packrat_parser]
362pub(crate) fn bind_target_instance(s: Span) -> IResult<Span, BindTargetInstance> {
363    let (s, a) = hierarchical_identifier(s)?;
364    let (s, b) = constant_bit_select(s)?;
365    Ok((s, BindTargetInstance { nodes: (a, b) }))
366}
367
368#[tracable_parser]
369#[packrat_parser]
370pub(crate) fn bind_target_instance_list(s: Span) -> IResult<Span, BindTargetInstanceList> {
371    let (s, a) = list(symbol(","), bind_target_instance)(s)?;
372    Ok((s, BindTargetInstanceList { nodes: (a,) }))
373}
374
375#[tracable_parser]
376#[packrat_parser]
377pub(crate) fn bind_instantiation(s: Span) -> IResult<Span, BindInstantiation> {
378    alt((
379        map(program_instantiation, |x| {
380            BindInstantiation::ProgramInstantiation(Box::new(x))
381        }),
382        map(module_instantiation, |x| {
383            BindInstantiation::ModuleInstantiation(Box::new(x))
384        }),
385        map(interface_instantiation, |x| {
386            BindInstantiation::InterfaceInstantiation(Box::new(x))
387        }),
388        map(checker_instantiation, |x| {
389            BindInstantiation::CheckerInstantiation(Box::new(x))
390        }),
391    ))(s)
392}
sv_parser_parser/source_text/module_items.rs

sv_parser_parser/source_text/
module_items.rs
