sv_parser_syntaxtree/
any_node.rs

1use crate::*;
2use core::convert::TryFrom;
3
4// -----------------------------------------------------------------------------
5
6include!(concat!(env!("OUT_DIR"), "/any_node.rs"));
7
8// -----------------------------------------------------------------------------
9
10pub struct RefNodes<'a>(pub Vec<RefNode<'a>>);
11
12pub struct Iter<'a> {
13    pub(crate) next: RefNodes<'a>,
14}
15
16impl<'a> Iter<'a> {
17    pub fn new(mut next: RefNodes<'a>) -> Self {
18        next.0.reverse();
19        Iter { next }
20    }
21
22    pub fn event(self) -> EventIter<'a> {
23        let next: NodeEvents = self.next.into();
24        EventIter { next }
25    }
26}
27
28impl<'a> Iterator for Iter<'a> {
29    type Item = RefNode<'a>;
30
31    fn next(&mut self) -> Option<Self::Item> {
32        let ret = self.next.0.pop();
33        if let Some(x) = ret.clone() {
34            let mut x = x.next();
35            x.0.reverse();
36            self.next.0.append(&mut x.0);
37        }
38        ret
39    }
40}
41
42// -----------------------------------------------------------------------------
43
44#[derive(Debug, Clone)]
45pub enum NodeEvent<'a> {
46    Enter(RefNode<'a>),
47    Leave(RefNode<'a>),
48}
49
50pub struct NodeEvents<'a>(pub Vec<NodeEvent<'a>>);
51
52pub struct EventIter<'a> {
53    pub(crate) next: NodeEvents<'a>,
54}
55
56impl<'a> Iterator for EventIter<'a> {
57    type Item = NodeEvent<'a>;
58
59    fn next(&mut self) -> Option<Self::Item> {
60        let ret = self.next.0.pop();
61        if let Some(x) = ret.clone() {
62            if let NodeEvent::Enter(x) = x {
63                self.next.0.push(NodeEvent::Leave(x.clone()));
64                let mut x: NodeEvents = x.next().into();
65                x.0.reverse();
66                self.next.0.append(&mut x.0);
67            }
68        }
69        ret
70    }
71}
72
73// -----------------------------------------------------------------------------
74
75impl<'a> From<Iter<'a>> for EventIter<'a> {
76    fn from(x: Iter<'a>) -> Self {
77        let mut ret = Vec::new();
78        for x in x.next.0 {
79            ret.push(NodeEvent::Enter(x));
80        }
81        EventIter {
82            next: NodeEvents(ret),
83        }
84    }
85}
86
87impl<'a> From<RefNodes<'a>> for NodeEvents<'a> {
88    fn from(x: RefNodes<'a>) -> Self {
89        let mut ret = Vec::new();
90        for x in x.0 {
91            ret.push(NodeEvent::Enter(x));
92        }
93        NodeEvents(ret)
94    }
95}
96
97impl<'a> From<Vec<RefNode<'a>>> for RefNodes<'a> {
98    fn from(x: Vec<RefNode<'a>>) -> Self {
99        RefNodes(x)
100    }
101}
102
103impl<'a> From<&'a Locate> for RefNodes<'a> {
104    fn from(x: &'a Locate) -> Self {
105        vec![RefNode::Locate(x)].into()
106    }
107}
108
109impl<'a, T: 'a> From<&'a Vec<T>> for RefNodes<'a>
110where
111    &'a T: Into<RefNodes<'a>>,
112{
113    fn from(x: &'a Vec<T>) -> Self {
114        let mut ret = Vec::new();
115        for x in x {
116            ret.append(&mut x.into().0);
117        }
118        ret.into()
119    }
120}
121
122impl<'a, T: 'a> From<&'a Option<T>> for RefNodes<'a>
123where
124    &'a T: Into<RefNodes<'a>>,
125{
126    fn from(x: &'a Option<T>) -> Self {
127        let mut ret = Vec::new();
128        if let Some(x) = x {
129            ret.append(&mut x.into().0);
130        }
131        ret.into()
132    }
133}
134
135impl<'a, T0: 'a> From<&'a (T0,)> for RefNodes<'a>
136where
137    &'a T0: Into<RefNodes<'a>>,
138{
139    fn from(x: &'a (T0,)) -> Self {
140        let mut ret = Vec::new();
141        let (t0,) = x;
142        ret.append(&mut t0.into().0);
143        ret.into()
144    }
145}
146
147impl<'a, T0: 'a, T1: 'a> From<&'a (T0, T1)> for RefNodes<'a>
148where
149    &'a T0: Into<RefNodes<'a>>,
150    &'a T1: Into<RefNodes<'a>>,
151{
152    fn from(x: &'a (T0, T1)) -> Self {
153        let mut ret = Vec::new();
154        let (t0, t1) = x;
155        ret.append(&mut t0.into().0);
156        ret.append(&mut t1.into().0);
157        ret.into()
158    }
159}
160
161impl<'a, T0: 'a, T1: 'a, T2: 'a> From<&'a (T0, T1, T2)> for RefNodes<'a>
162where
163    &'a T0: Into<RefNodes<'a>>,
164    &'a T1: Into<RefNodes<'a>>,
165    &'a T2: Into<RefNodes<'a>>,
166{
167    fn from(x: &'a (T0, T1, T2)) -> Self {
168        let mut ret = Vec::new();
169        let (t0, t1, t2) = x;
170        ret.append(&mut t0.into().0);
171        ret.append(&mut t1.into().0);
172        ret.append(&mut t2.into().0);
173        ret.into()
174    }
175}
176
177impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a> From<&'a (T0, T1, T2, T3)> for RefNodes<'a>
178where
179    &'a T0: Into<RefNodes<'a>>,
180    &'a T1: Into<RefNodes<'a>>,
181    &'a T2: Into<RefNodes<'a>>,
182    &'a T3: Into<RefNodes<'a>>,
183{
184    fn from(x: &'a (T0, T1, T2, T3)) -> Self {
185        let mut ret = Vec::new();
186        let (t0, t1, t2, t3) = x;
187        ret.append(&mut t0.into().0);
188        ret.append(&mut t1.into().0);
189        ret.append(&mut t2.into().0);
190        ret.append(&mut t3.into().0);
191        ret.into()
192    }
193}
194
195impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a> From<&'a (T0, T1, T2, T3, T4)> for RefNodes<'a>
196where
197    &'a T0: Into<RefNodes<'a>>,
198    &'a T1: Into<RefNodes<'a>>,
199    &'a T2: Into<RefNodes<'a>>,
200    &'a T3: Into<RefNodes<'a>>,
201    &'a T4: Into<RefNodes<'a>>,
202{
203    fn from(x: &'a (T0, T1, T2, T3, T4)) -> Self {
204        let mut ret = Vec::new();
205        let (t0, t1, t2, t3, t4) = x;
206        ret.append(&mut t0.into().0);
207        ret.append(&mut t1.into().0);
208        ret.append(&mut t2.into().0);
209        ret.append(&mut t3.into().0);
210        ret.append(&mut t4.into().0);
211        ret.into()
212    }
213}
214
215impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a> From<&'a (T0, T1, T2, T3, T4, T5)>
216    for RefNodes<'a>
217where
218    &'a T0: Into<RefNodes<'a>>,
219    &'a T1: Into<RefNodes<'a>>,
220    &'a T2: Into<RefNodes<'a>>,
221    &'a T3: Into<RefNodes<'a>>,
222    &'a T4: Into<RefNodes<'a>>,
223    &'a T5: Into<RefNodes<'a>>,
224{
225    fn from(x: &'a (T0, T1, T2, T3, T4, T5)) -> Self {
226        let mut ret = Vec::new();
227        let (t0, t1, t2, t3, t4, t5) = x;
228        ret.append(&mut t0.into().0);
229        ret.append(&mut t1.into().0);
230        ret.append(&mut t2.into().0);
231        ret.append(&mut t3.into().0);
232        ret.append(&mut t4.into().0);
233        ret.append(&mut t5.into().0);
234        ret.into()
235    }
236}
237
238impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a>
239    From<&'a (T0, T1, T2, T3, T4, T5, T6)> for RefNodes<'a>
240where
241    &'a T0: Into<RefNodes<'a>>,
242    &'a T1: Into<RefNodes<'a>>,
243    &'a T2: Into<RefNodes<'a>>,
244    &'a T3: Into<RefNodes<'a>>,
245    &'a T4: Into<RefNodes<'a>>,
246    &'a T5: Into<RefNodes<'a>>,
247    &'a T6: Into<RefNodes<'a>>,
248{
249    fn from(x: &'a (T0, T1, T2, T3, T4, T5, T6)) -> Self {
250        let mut ret = Vec::new();
251        let (t0, t1, t2, t3, t4, t5, t6) = x;
252        ret.append(&mut t0.into().0);
253        ret.append(&mut t1.into().0);
254        ret.append(&mut t2.into().0);
255        ret.append(&mut t3.into().0);
256        ret.append(&mut t4.into().0);
257        ret.append(&mut t5.into().0);
258        ret.append(&mut t6.into().0);
259        ret.into()
260    }
261}
262
263impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a>
264    From<&'a (T0, T1, T2, T3, T4, T5, T6, T7)> for RefNodes<'a>
265where
266    &'a T0: Into<RefNodes<'a>>,
267    &'a T1: Into<RefNodes<'a>>,
268    &'a T2: Into<RefNodes<'a>>,
269    &'a T3: Into<RefNodes<'a>>,
270    &'a T4: Into<RefNodes<'a>>,
271    &'a T5: Into<RefNodes<'a>>,
272    &'a T6: Into<RefNodes<'a>>,
273    &'a T7: Into<RefNodes<'a>>,
274{
275    fn from(x: &'a (T0, T1, T2, T3, T4, T5, T6, T7)) -> Self {
276        let mut ret = Vec::new();
277        let (t0, t1, t2, t3, t4, t5, t6, t7) = x;
278        ret.append(&mut t0.into().0);
279        ret.append(&mut t1.into().0);
280        ret.append(&mut t2.into().0);
281        ret.append(&mut t3.into().0);
282        ret.append(&mut t4.into().0);
283        ret.append(&mut t5.into().0);
284        ret.append(&mut t6.into().0);
285        ret.append(&mut t7.into().0);
286        ret.into()
287    }
288}
289
290impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a>
291    From<&'a (T0, T1, T2, T3, T4, T5, T6, T7, T8)> for RefNodes<'a>
292where
293    &'a T0: Into<RefNodes<'a>>,
294    &'a T1: Into<RefNodes<'a>>,
295    &'a T2: Into<RefNodes<'a>>,
296    &'a T3: Into<RefNodes<'a>>,
297    &'a T4: Into<RefNodes<'a>>,
298    &'a T5: Into<RefNodes<'a>>,
299    &'a T6: Into<RefNodes<'a>>,
300    &'a T7: Into<RefNodes<'a>>,
301    &'a T8: Into<RefNodes<'a>>,
302{
303    fn from(x: &'a (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> Self {
304        let mut ret = Vec::new();
305        let (t0, t1, t2, t3, t4, t5, t6, t7, t8) = x;
306        ret.append(&mut t0.into().0);
307        ret.append(&mut t1.into().0);
308        ret.append(&mut t2.into().0);
309        ret.append(&mut t3.into().0);
310        ret.append(&mut t4.into().0);
311        ret.append(&mut t5.into().0);
312        ret.append(&mut t6.into().0);
313        ret.append(&mut t7.into().0);
314        ret.append(&mut t8.into().0);
315        ret.into()
316    }
317}
318
319impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a>
320    From<&'a (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> for RefNodes<'a>
321where
322    &'a T0: Into<RefNodes<'a>>,
323    &'a T1: Into<RefNodes<'a>>,
324    &'a T2: Into<RefNodes<'a>>,
325    &'a T3: Into<RefNodes<'a>>,
326    &'a T4: Into<RefNodes<'a>>,
327    &'a T5: Into<RefNodes<'a>>,
328    &'a T6: Into<RefNodes<'a>>,
329    &'a T7: Into<RefNodes<'a>>,
330    &'a T8: Into<RefNodes<'a>>,
331    &'a T9: Into<RefNodes<'a>>,
332{
333    fn from(x: &'a (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> Self {
334        let mut ret = Vec::new();
335        let (t0, t1, t2, t3, t4, t5, t6, t7, t8, t9) = x;
336        ret.append(&mut t0.into().0);
337        ret.append(&mut t1.into().0);
338        ret.append(&mut t2.into().0);
339        ret.append(&mut t3.into().0);
340        ret.append(&mut t4.into().0);
341        ret.append(&mut t5.into().0);
342        ret.append(&mut t6.into().0);
343        ret.append(&mut t7.into().0);
344        ret.append(&mut t8.into().0);
345        ret.append(&mut t9.into().0);
346        ret.into()
347    }
348}
349
350impl<
351        'a,
352        T0: 'a,
353        T1: 'a,
354        T2: 'a,
355        T3: 'a,
356        T4: 'a,
357        T5: 'a,
358        T6: 'a,
359        T7: 'a,
360        T8: 'a,
361        T9: 'a,
362        T10: 'a,
363    > From<&'a (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> for RefNodes<'a>
364where
365    &'a T0: Into<RefNodes<'a>>,
366    &'a T1: Into<RefNodes<'a>>,
367    &'a T2: Into<RefNodes<'a>>,
368    &'a T3: Into<RefNodes<'a>>,
369    &'a T4: Into<RefNodes<'a>>,
370    &'a T5: Into<RefNodes<'a>>,
371    &'a T6: Into<RefNodes<'a>>,
372    &'a T7: Into<RefNodes<'a>>,
373    &'a T8: Into<RefNodes<'a>>,
374    &'a T9: Into<RefNodes<'a>>,
375    &'a T10: Into<RefNodes<'a>>,
376{
377    fn from(x: &'a (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> Self {
378        let mut ret = Vec::new();
379        let (t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) = x;
380        ret.append(&mut t0.into().0);
381        ret.append(&mut t1.into().0);
382        ret.append(&mut t2.into().0);
383        ret.append(&mut t3.into().0);
384        ret.append(&mut t4.into().0);
385        ret.append(&mut t5.into().0);
386        ret.append(&mut t6.into().0);
387        ret.append(&mut t7.into().0);
388        ret.append(&mut t8.into().0);
389        ret.append(&mut t9.into().0);
390        ret.append(&mut t10.into().0);
391        ret.into()
392    }
393}
394
395impl<'a, T> From<&'a Paren<T>> for RefNodes<'a>
396where
397    &'a T: Into<RefNodes<'a>>,
398{
399    fn from(x: &'a Paren<T>) -> Self {
400        let mut ret = Vec::new();
401        let (a, b, c) = &x.nodes;
402        let mut a: RefNodes<'a> = a.into();
403        let mut c: RefNodes<'a> = c.into();
404        ret.append(&mut a.0);
405        ret.append(&mut b.into().0);
406        ret.append(&mut c.0);
407        ret.into()
408    }
409}
410
411impl<'a, T> From<&'a Brace<T>> for RefNodes<'a>
412where
413    &'a T: Into<RefNodes<'a>>,
414{
415    fn from(x: &'a Brace<T>) -> Self {
416        let mut ret = Vec::new();
417        let (a, b, c) = &x.nodes;
418        let mut a: RefNodes<'a> = a.into();
419        let mut c: RefNodes<'a> = c.into();
420        ret.append(&mut a.0);
421        ret.append(&mut b.into().0);
422        ret.append(&mut c.0);
423        ret.into()
424    }
425}
426
427impl<'a, T> From<&'a Bracket<T>> for RefNodes<'a>
428where
429    &'a T: Into<RefNodes<'a>>,
430{
431    fn from(x: &'a Bracket<T>) -> Self {
432        let mut ret = Vec::new();
433        let (a, b, c) = &x.nodes;
434        let mut a: RefNodes<'a> = a.into();
435        let mut c: RefNodes<'a> = c.into();
436        ret.append(&mut a.0);
437        ret.append(&mut b.into().0);
438        ret.append(&mut c.0);
439        ret.into()
440    }
441}
442
443impl<'a, T> From<&'a ApostropheBrace<T>> for RefNodes<'a>
444where
445    &'a T: Into<RefNodes<'a>>,
446{
447    fn from(x: &'a ApostropheBrace<T>) -> Self {
448        let mut ret = Vec::new();
449        let (a, b, c) = &x.nodes;
450        let mut a: RefNodes<'a> = a.into();
451        let mut c: RefNodes<'a> = c.into();
452        ret.append(&mut a.0);
453        ret.append(&mut b.into().0);
454        ret.append(&mut c.0);
455        ret.into()
456    }
457}
458
459impl<'a, T, U> From<&'a List<T, U>> for RefNodes<'a>
460where
461    &'a T: Into<RefNodes<'a>>,
462    &'a U: Into<RefNodes<'a>>,
463{
464    fn from(x: &'a List<T, U>) -> Self {
465        let mut ret = Vec::new();
466        let (t, u) = &x.nodes;
467        let mut u: RefNodes<'a> = u.into();
468        ret.append(&mut t.into().0);
469        ret.append(&mut u.0);
470        ret.into()
471    }
472}
473
474impl<'a, T: 'a> From<&'a Box<T>> for RefNodes<'a>
475where
476    &'a T: Into<RefNodes<'a>>,
477{
478    fn from(x: &'a Box<T>) -> Self {
479        let mut ret = Vec::new();
480        let mut x: RefNodes<'a> = (&**x).into();
481        ret.append(&mut x.0);
482        ret.into()
483    }
484}
sv_parser_syntaxtree/any_node.rs

sv_parser_syntaxtree/
any_node.rs
