tree_sitter_sleigh/
lib.rs

1pub use grammar::parse;
2
3#[rust_sitter::grammar("sleigh")]
4#[allow(
5    clippy::declare_interior_mutable_const,
6    clippy::borrow_interior_mutable_const,
7    clippy::large_enum_variant
8)]
9pub mod grammar {
10    use malachite::{num::conversion::traits::FromStringBase, Integer};
11    use regex::Regex;
12    use std::cell::OnceCell;
13    use typed_builder::TypedBuilder;
14
15    trait XmlUnescape {
16        /// Unescape XML:
17        /// - `&amp;` -> `&`
18        /// - `&lt;` -> `<`
19        /// - `&gt;` -> `>`
20        /// - `&quot;` -> `"`
21        /// - `&apos;` -> `'`
22        fn xml_unescape(&self) -> String;
23    }
24
25    impl<S> XmlUnescape for S
26    where
27        S: AsRef<str>,
28    {
29        fn xml_unescape(&self) -> String {
30            self.as_ref()
31                .replace("&amp;", "&")
32                .replace("&lt;", "<")
33                .replace("&gt;", ">")
34                .replace("&quot;", "\"")
35                .replace("&apos;", "'")
36        }
37    }
38
39    impl Sleigh {
40        const VERSION_REGEX: OnceCell<Regex> = OnceCell::new();
41        const BIGENDIAN_REGEX: OnceCell<Regex> = OnceCell::new();
42        const ALIGN_REGEX: OnceCell<Regex> = OnceCell::new();
43        const UNIQBASE_REGEX: OnceCell<Regex> = OnceCell::new();
44        const MAXDELAY_REGEX: OnceCell<Regex> = OnceCell::new();
45        const UNIQMASK_REGEX: OnceCell<Regex> = OnceCell::new();
46        const NUMSECTIONS_REGEX: OnceCell<Regex> = OnceCell::new();
47    }
48
49    #[rust_sitter::language]
50    #[derive(TypedBuilder, Debug, PartialEq)]
51    /// Sleigh Base
52    ///
53    pub struct Sleigh {
54        #[rust_sitter::leaf(pattern = r#"<sleigh"#)]
55        #[builder(default, setter(skip))]
56        _open: (),
57        #[rust_sitter::leaf(
58            pattern = r#"version\s*=\s*"(-?[0-9]+)""#,
59            transform = |v| {
60                Sleigh::VERSION_REGEX
61                    .get_or_init(|| {
62                        Regex::new(r#"version\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
63                    })
64                    .captures(v)
65                    .expect("No captures or no capture group")
66                    .get(1)
67                    .expect("No capture group")
68                    .as_str()
69                    .parse()
70                    .expect("Invalid integer")
71            }
72        )]
73        #[builder(setter(transform = |v: impl Into<Integer>| {
74            Some(v.into())
75        }))]
76        /// Technically, version is optional
77        version: Option<Integer>,
78        #[rust_sitter::leaf(
79            pattern = r#"bigendian\s*=\s*"([a-z]+)""#,
80            transform = |v| {
81                Sleigh::BIGENDIAN_REGEX
82                    .get_or_init(|| {
83                        Regex::new(r#"bigendian\s*=\s*"([a-z]+)""#)
84                            .expect("Invalid regular expression")
85                    })
86                    .captures(v)
87                    .expect("No captures or no capture group")
88                    .get(1)
89                    .expect("No capture group")
90                    .as_str()
91                    .parse()
92                    .expect("Invalid boolean")
93            }
94        )]
95        bigendian: bool,
96        #[rust_sitter::leaf(
97            pattern = r#"align\s*=\s*"(-?[0-9]+)""#,
98            transform = |v| {
99                Sleigh::ALIGN_REGEX
100                    .get_or_init(|| {
101                        Regex::new(r#"align\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
102                    })
103                    .captures(v)
104                    .expect("No captures or no capture group")
105                    .get(1)
106                    .expect("No capture group")
107                    .as_str()
108                    .parse()
109                    .expect("Invalid integer")
110            }
111        )]
112        #[builder(setter(transform = |v: impl Into<Integer>| {
113            v.into()
114        }))]
115        align: Integer,
116        #[rust_sitter::leaf(
117            pattern = r#"uniqbase\s*=\s*"0x([0-9a-fA-F]+)""#,
118            transform = |v| {
119                Integer::from_string_base(16, Sleigh::UNIQBASE_REGEX
120                    .get_or_init(|| {
121                        Regex::new(r#"uniqbase\s*=\s*"0x([0-9a-fA-F]+)""#)
122                            .expect("Invalid regular expression")
123                    })
124                    .captures(v)
125                    .expect("No captures or no capture group")
126                    .get(1)
127                    .expect("No capture group")
128                    .as_str()).expect("Invalid integer")
129            }
130        )]
131        #[builder(setter(transform = |v: impl Into<Integer>| {
132            v.into()
133        }))]
134        uniqbase: Integer,
135        #[rust_sitter::leaf(
136            pattern = r#"maxdelay\s*=\s*"0x([0-9a-fA-F]+)""#,
137            transform = |v| {
138                Integer::from_string_base(16, Sleigh::MAXDELAY_REGEX
139                    .get_or_init(|| {
140                        Regex::new(r#"maxdelay\s*=\s*"0x([0-9a-fA-F]+)""#)
141                            .expect("Invalid regular expression")
142                    })
143                    .captures(v)
144                    .expect("No captures or no capture group")
145                    .get(1)
146                    .expect("No capture group")
147                    .as_str()).expect("Invalid integer")
148            }
149        )]
150        #[builder(default, setter(transform = |v: impl Into<Integer>| {
151            Some(v.into())
152        }))]
153        /// `maxdelay` is used, but is only usually set to 0x1 (1 delay slot)
154        maxdelay: Option<Integer>,
155        #[rust_sitter::leaf(
156            pattern = r#"uniqmask\s*=\s*"0x([0-9a-fA-F]+)""#,
157            transform = |v| {
158                Integer::from_string_base(16, Sleigh::UNIQMASK_REGEX
159                    .get_or_init(|| {
160                        Regex::new(r#"uniqmask\s*=\s*"0x([0-9a-fA-F]+)""#)
161                            .expect("Invalid regular expression")
162                    })
163                    .captures(v)
164                    .expect("No captures or no capture group")
165                    .get(1)
166                    .expect("No capture group")
167                    .as_str()).expect("Invalid integer")
168            }
169        )]
170        #[builder(default, setter(transform = |v: impl Into<Integer>| {
171            Some(v.into())
172        }))]
173        /// `maxdelay` is used, but is only usually set to 0x1 (1 delay slot)
174        uniqmask: Option<Integer>,
175        #[rust_sitter::leaf(
176            pattern = r#"numsections\s*=\s*"0x([0-9a-fA-F]+)""#,
177            transform = |v| {
178                Sleigh::NUMSECTIONS_REGEX
179                    .get_or_init(|| {
180                        Regex::new(r#"numsections\s*=\s*"([0-9]+)""#).expect("Invalid regular expression")
181                    })
182                    .captures(v)
183                    .expect("No captures or no capture group")
184                    .get(1)
185                    .expect("No capture group")
186                    .as_str()
187                    .parse()
188                    .expect("Invalid integer")
189            }
190        )]
191        #[builder(default, setter(transform = |v: impl Into<Integer>| {
192            Some(v.into())
193        }))]
194        numsections: Option<Integer>,
195        #[rust_sitter::leaf(pattern = r#">"#)]
196        #[builder(default, setter(skip))]
197        _close: (),
198        sourcefiles: SourceFiles,
199        spaces: Spaces,
200        symbol_table: SymbolTable,
201        #[rust_sitter::leaf(pattern = r#"<\s*/\s*sleigh\s*>"#)]
202        #[builder(default, setter(skip))]
203        _end: (),
204    }
205
206    #[derive(TypedBuilder, Debug, PartialEq)]
207    pub struct SourceFiles {
208        #[rust_sitter::leaf(pattern = r#"<\s*sourcefiles\s*>"#)]
209        #[builder(default, setter(skip))]
210        _start: (),
211        #[builder(default)]
212        source_files: Vec<SourceFile>,
213        #[rust_sitter::leaf(pattern = r#"<\s*/\s*sourcefiles\s*>"#)]
214        #[builder(default, setter(skip))]
215        _end: (),
216    }
217
218    impl SourceFile {
219        const NAME_REGEX: OnceCell<Regex> = OnceCell::new();
220        const INDEX_REGEX: OnceCell<Regex> = OnceCell::new();
221    }
222
223    #[derive(TypedBuilder, Debug, PartialEq)]
224    pub struct SourceFile {
225        #[rust_sitter::leaf(pattern = r#"<\s*sourcefile"#)]
226        #[builder(default, setter(skip))]
227        _start: (),
228        #[rust_sitter::leaf(
229            pattern = r#"name\s*=\s*"([^"]+)""#,
230            transform = |v| {
231                SourceFile::NAME_REGEX
232                    .get_or_init(|| {
233                        Regex::new(r#"name\s*=\s*"([^"]+)""#).expect("Invalid regular expression")
234                    })
235                    .captures(v)
236                    .expect("No captures or no capture group")
237                    .get(1)
238                    .expect("No capture group")
239                    .as_str()
240                    .to_string()
241                    .xml_unescape()
242            }
243        )]
244        name: String,
245        #[rust_sitter::leaf(
246            pattern = r#"index\s*=\s*"(-?[0-9]+)""#,
247            transform = |v| {
248                SourceFile::INDEX_REGEX
249                    .get_or_init(|| {
250                        Regex::new(r#"index\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
251                    })
252                    .captures(v)
253                    .expect("No captures or no capture group")
254                    .get(1)
255                    .expect("No capture group")
256                    .as_str()
257                    .parse()
258                    .expect("Invalid integer")
259            }
260        )]
261        #[builder(default, setter(transform = |v: impl Into<Integer>| {
262            v.into()
263        }))]
264        index: Integer,
265        #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
266        #[builder(default, setter(skip))]
267        _end: (),
268    }
269
270    impl Spaces {
271        const DEFAULTSPACE_REGEX: OnceCell<Regex> = OnceCell::new();
272    }
273
274    #[derive(TypedBuilder, Debug, PartialEq)]
275    pub struct Spaces {
276        #[rust_sitter::leaf(pattern = r#"<\s*spaces"#)]
277        #[builder(default, setter(skip))]
278        _start: (),
279        #[rust_sitter::leaf(pattern = r#"defaultspace\s*=\s*"([^"]+)""#, transform = |v| {
280            Spaces::DEFAULTSPACE_REGEX
281                .get_or_init(|| {
282                    Regex::new(r#"defaultspace\s*=\s*"([^"]+)""#).expect("Invalid regular expression")
283                })
284                .captures(v)
285                .expect("No captures or no capture group")
286                .get(1)
287                .expect("No capture group")
288                .as_str()
289                .to_string()
290                .xml_unescape()
291        })]
292        defaultspace: String,
293        #[rust_sitter::leaf(pattern = r#">"#)]
294        #[builder(default, setter(skip))]
295        _close: (),
296        #[builder(default)]
297        spaces: Vec<AddrSpaceType>,
298        #[rust_sitter::leaf(pattern = r#"<\s*/\s*spaces\s*>"#)]
299        #[builder(default, setter(skip))]
300        _end: (),
301    }
302
303    impl AddrSpace {
304        pub const NAME_REGEX: OnceCell<Regex> = OnceCell::new();
305        pub const INDEX_REGEX: OnceCell<Regex> = OnceCell::new();
306        pub const BIGENDIAN_REGEX: OnceCell<Regex> = OnceCell::new();
307        pub const DELAY_REGEX: OnceCell<Regex> = OnceCell::new();
308        pub const DEADCODEDELAY_REGEX: OnceCell<Regex> = OnceCell::new();
309        pub const SIZE_REGEX: OnceCell<Regex> = OnceCell::new();
310        pub const WORDSIZE_REGEX: OnceCell<Regex> = OnceCell::new();
311        pub const PHYSICAL_REGEX: OnceCell<Regex> = OnceCell::new();
312    }
313
314    #[derive(TypedBuilder, Debug, PartialEq)]
315    pub struct AddrSpace {
316        #[rust_sitter::leaf(
317            pattern = r#"name\s*=\s*"([^"]+)""#,
318            transform = |v| {
319                AddrSpace::NAME_REGEX
320                    .get_or_init(|| {
321                        Regex::new(r#"name\s*=\s*"([^"]+)""#).expect("Invalid regular expression")
322                    })
323                    .captures(v)
324                    .expect("No captures or no capture group")
325                    .get(1)
326                    .expect("No capture group")
327                    .as_str()
328                    .to_string()
329                    .xml_unescape()
330            }
331        )]
332        name: String,
333        #[rust_sitter::leaf(
334            pattern = r#"index\s*=\s*"(-?[0-9]+)""#,
335            transform = |v| {
336                AddrSpace::INDEX_REGEX
337                    .get_or_init(|| {
338                        Regex::new(r#"index\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
339                    })
340                    .captures(v)
341                    .expect("No captures or no capture group")
342                    .get(1)
343                    .expect("No capture group")
344                    .as_str()
345                    .parse()
346                    .expect("Invalid integer")
347            }
348        )]
349        #[builder(setter(transform = |v: impl Into<Integer>| {
350            v.into()
351        }))]
352        index: Integer,
353        #[rust_sitter::leaf(
354            pattern = r#"bigendian\s*=\s*"([a-z]+)""#,
355            transform = |v| {
356                AddrSpace::BIGENDIAN_REGEX
357                    .get_or_init(|| {
358                        Regex::new(r#"bigendian\s*=\s*"([a-z]+)""#)
359                            .expect("Invalid regular expression")
360                    })
361                    .captures(v)
362                    .expect("No captures or no capture group")
363                    .get(1)
364                    .expect("No capture group")
365                    .as_str()
366                    .parse()
367                    .expect("Invalid boolean")
368            }
369        )]
370        bigendian: bool,
371        #[rust_sitter::leaf(
372            pattern = r#"delay\s*=\s*"(-?[0-9]+)""#,
373            transform = |v| {
374                AddrSpace::DELAY_REGEX
375                    .get_or_init(|| {
376                        Regex::new(r#"delay\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
377                    })
378                    .captures(v)
379                    .expect("No captures or no capture group")
380                    .get(1)
381                    .expect("No capture group")
382                    .as_str()
383                    .parse()
384                    .expect("Invalid integer")
385            }
386        )]
387        #[builder(setter(transform = |v: impl Into<Integer>| {
388            v.into()
389        }))]
390        delay: Integer,
391        #[rust_sitter::leaf(
392            pattern = r#"deadcodedelay\s*=\s*"(-?[0-9]+)""#,
393            transform = |v| {
394                AddrSpace::DEADCODEDELAY_REGEX
395                    .get_or_init(|| {
396                        Regex::new(r#"deadcodedelay\s*=\s*"(-?[0-9]+)""#)
397                            .expect("Invalid regular expression")
398                    })
399                    .captures(v)
400                    .expect("No captures or no capture group")
401                    .get(1)
402                    .expect("No capture group")
403                    .as_str()
404                    .parse()
405                    .expect("Invalid integer")
406            }
407        )]
408        #[builder(default, setter(transform = |v: impl Into<Integer>| {
409            Some(v.into())
410        }))]
411        deadcodedelay: Option<Integer>,
412        #[rust_sitter::leaf(
413            pattern = r#"size\s*=\s*"(-?[0-9]+)""#,
414            transform = |v| {
415                AddrSpace::SIZE_REGEX
416                    .get_or_init(|| {
417                        Regex::new(r#"size\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
418                    })
419                    .captures(v)
420                    .expect("No captures or no capture group")
421                    .get(1)
422                    .expect("No capture group")
423                    .as_str()
424                    .parse()
425                    .expect("Invalid integer")
426            }
427        )]
428        #[builder(setter(transform = |v: impl Into<Integer>| {
429            v.into()
430        }))]
431        size: Integer,
432        #[rust_sitter::leaf(
433            pattern = r#"wordsize\s*=\s*"(-?[0-9]+)""#,
434            transform = |v| {
435                AddrSpace::WORDSIZE_REGEX
436                    .get_or_init(|| {
437                        Regex::new(r#"wordsize\s*=\s*"(-?[0-9]+)""#)
438                            .expect("Invalid regular expression")
439                    })
440                    .captures(v)
441                    .expect("No captures or no capture group")
442                    .get(1)
443                    .expect("No capture group")
444                    .as_str()
445                    .parse()
446                    .expect("Invalid integer")
447            }
448        )]
449        #[builder(default, setter(transform = |v: impl Into<Integer>| {
450            Some(v.into())
451        }))]
452        wordsize: Option<Integer>,
453        #[rust_sitter::leaf(
454            pattern = r#"physical\s*=\s*"([a-z]+)""#,
455            transform = |v| {
456                AddrSpace::PHYSICAL_REGEX
457                    .get_or_init(|| {
458                        Regex::new(r#"physical\s*=\s*"([a-z]+)""#)
459                            .expect("Invalid regular expression")
460                    })
461                    .captures(v)
462                    .expect("No captures or no capture group")
463                    .get(1)
464                    .expect("No capture group")
465                    .as_str()
466                    .parse()
467                    .expect("Invalid boolean")
468            }
469        )]
470        physical: bool,
471    }
472
473    #[derive(Debug, PartialEq)]
474    pub enum AddrSpaceType {
475        Base {
476            #[rust_sitter::leaf(pattern = r#"<\s*space_base"#)]
477            _start: (),
478            space: AddrSpace,
479            #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
480            _end: (),
481        },
482        Unique {
483            #[rust_sitter::leaf(pattern = r#"<\s*space_unique"#)]
484            _start: (),
485            space: AddrSpace,
486            #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
487            _end: (),
488        },
489        Other {
490            #[rust_sitter::leaf(pattern = r#"<\s*space_other"#)]
491            _start: (),
492            space: AddrSpace,
493            #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
494            _end: (),
495        },
496        Overlay {
497            #[rust_sitter::leaf(pattern = r#"<\s*space_overlay"#)]
498            _start: (),
499            space: AddrSpace,
500            #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
501            _end: (),
502        },
503        Space {
504            #[rust_sitter::leaf(pattern = r#"<\s*space"#)]
505            _start: (),
506            space: AddrSpace,
507            #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
508            _end: (),
509        },
510    }
511
512    impl SymbolTable {
513        const SCOPESIZE_REGEX: OnceCell<Regex> = OnceCell::new();
514        const SYMBOLSIZE_REGEX: OnceCell<Regex> = OnceCell::new();
515    }
516
517    #[derive(TypedBuilder, Debug, PartialEq)]
518    pub struct SymbolTable {
519        #[rust_sitter::leaf(pattern = r#"<\s*symbol_table"#)]
520        #[builder(default, setter(skip))]
521        _start: (),
522        #[rust_sitter::leaf(
523            pattern = r#"scopesize\s*=\s*"(-?[0-9]+)""#,
524            transform = |v| {
525                SymbolTable::SCOPESIZE_REGEX
526                    .get_or_init(|| {
527                        Regex::new(r#"scopesize\s*=\s*"(-?[0-9]+)""#)
528                            .expect("Invalid regular expression")
529                    })
530                    .captures(v)
531                    .expect("No captures or no capture group")
532                    .get(1)
533                    .expect("No capture group")
534                    .as_str()
535                    .parse()
536                    .expect("Invalid integer")
537            }
538        )]
539        #[builder(setter(transform = |v: impl Into<Integer>| {
540            v.into()
541        }))]
542        scopesize: Integer,
543        #[rust_sitter::leaf(
544            pattern = r#"symbolsize\s*=\s*"(-?[0-9]+)""#,
545            transform = |v| {
546                SymbolTable::SYMBOLSIZE_REGEX
547                    .get_or_init(|| {
548                        Regex::new(r#"symbolsize\s*=\s*"(-?[0-9]+)""#)
549                            .expect("Invalid regular expression")
550                    })
551                    .captures(v)
552                    .expect("No captures or no capture group")
553                    .get(1)
554                    .expect("No capture group")
555                    .as_str()
556                    .parse()
557                    .expect("Invalid integer")
558            }
559        )]
560        #[builder(setter(transform = |v: impl Into<Integer>| {
561            v.into()
562        }))]
563        symbolsize: Integer,
564        #[rust_sitter::leaf(pattern = r#">"#)]
565        #[builder(default, setter(skip))]
566        _close: (),
567        #[builder(default)]
568        scopes: Vec<Scope>,
569        #[builder(default)]
570        symbol_headers: Vec<SymbolHeaderType>,
571        #[builder(default)]
572        symbols: Vec<SleighSymbolType>,
573        #[rust_sitter::leaf(pattern = r#"<\s*/\s*symbol_table\s*>"#)]
574        #[builder(default, setter(skip))]
575        _end: (),
576    }
577
578    impl Scope {
579        const ID_REGEX: OnceCell<Regex> = OnceCell::new();
580        const PARENT_REGEX: OnceCell<Regex> = OnceCell::new();
581    }
582
583    #[derive(TypedBuilder, Debug, PartialEq)]
584    pub struct Scope {
585        #[rust_sitter::leaf(pattern = r#"<\s*scope"#)]
586        #[builder(default, setter(skip))]
587        _start: (),
588        #[rust_sitter::leaf(
589            pattern = r#"id\s*=\s*"0x([0-9a-fA-F]+)""#,
590            transform = |v| {
591                Integer::from_string_base(16, Scope::ID_REGEX
592                    .get_or_init(|| {
593                        Regex::new(r#"id\s*=\s*"0x([0-9a-fA-F]+)""#)
594                            .expect("Invalid regular expression")
595                    })
596                    .captures(v)
597                    .expect("No captures or no capture group")
598                    .get(1)
599                    .expect("No capture group")
600                    .as_str()).expect("Invalid integer")
601            }
602        )]
603        #[builder(setter(transform = |v: impl Into<Integer>| {
604            v.into()
605        }))]
606        id: Integer,
607        #[rust_sitter::leaf(
608            pattern = r#"parent\s*=\s*"0x([0-9a-fA-F]+)""#,
609            transform = |v| {
610                Integer::from_string_base(16, Scope::PARENT_REGEX
611                    .get_or_init(|| {
612                        Regex::new(r#"parent\s*=\s*"0x([0-9a-fA-F]+)""#)
613                            .expect("Invalid regular expression")
614                    })
615                    .captures(v)
616                    .expect("No captures or no capture group")
617                    .get(1)
618                    .expect("No capture group")
619                    .as_str()).expect("Invalid integer")
620            }
621        )]
622        #[builder(setter(transform = |v: impl Into<Integer>| {
623            v.into()
624        }))]
625        parent: Integer,
626        #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
627        #[builder(default, setter(skip))]
628        _end: (),
629    }
630
631    impl SymbolHeader {
632        const NAME_REGEX: OnceCell<Regex> = OnceCell::new();
633        const ID_REGEX: OnceCell<Regex> = OnceCell::new();
634        const SCOPE_REGEX: OnceCell<Regex> = OnceCell::new();
635    }
636
637    #[derive(TypedBuilder, Debug, PartialEq)]
638    pub struct SymbolHeader {
639        #[rust_sitter::leaf(
640            pattern = r#"name\s*=\s*"([^"]+)""#,
641            transform = |v| {
642                SymbolHeader::NAME_REGEX
643                    .get_or_init(|| {
644                        Regex::new(r#"name\s*=\s*"([^"]+)""#).expect("Invalid regular expression")
645                    })
646                    .captures(v)
647                    .expect("No captures or no capture group")
648                    .get(1)
649                    .expect("No capture group")
650                    .as_str()
651                    .to_string()
652                    .xml_unescape()
653            }
654        )]
655        name: String,
656        #[rust_sitter::leaf(
657            pattern = r#"id\s*=\s*"0x([0-9a-fA-F]+)""#,
658            transform = |v| {
659                Integer::from_string_base(16, SymbolHeader::ID_REGEX
660                    .get_or_init(|| {
661                        Regex::new(r#"id\s*=\s*"0x([0-9a-fA-F]+)""#)
662                            .expect("Invalid regular expression")
663                    })
664                    .captures(v)
665                    .expect("No captures or no capture group").get(1).expect("No capture group").as_str()).expect("Invalid integer")
666            }
667        )]
668        #[builder(setter(transform = |v: impl Into<Integer>| {
669            v.into()
670        }))]
671        id: Integer,
672        #[rust_sitter::leaf(
673            pattern = r#"scope\s*=\s*"0x([0-9a-fA-F]+)""#,
674            transform = |v| {
675                Integer::from_string_base(16, SymbolHeader::SCOPE_REGEX
676                    .get_or_init(|| {
677                        Regex::new(r#"scope\s*=\s*"0x([0-9a-fA-F]+)""#)
678                            .expect("Invalid regular expression")
679                    })
680                    .captures(v)
681                    .expect("No captures or no capture group").get(1).expect("No capture group").as_str()).expect("Invalid integer")
682            }
683        )]
684        #[builder(setter(transform = |v: impl Into<Integer>| {
685            v.into()
686        }))]
687        scope: Integer,
688    }
689
690    #[derive(Debug, PartialEq)]
691    pub enum SymbolHeaderType {
692        UserOp {
693            #[rust_sitter::leaf(pattern = r#"<\s*userop_head"#)]
694            _start: (),
695            header: SymbolHeader,
696            #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
697            _end: (),
698        },
699        Epsilon {
700            #[rust_sitter::leaf(pattern = r#"<\s*epsilon_sym_head"#)]
701            _start: (),
702            header: SymbolHeader,
703            #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
704            _end: (),
705        },
706        Value {
707            #[rust_sitter::leaf(pattern = r#"<\s*value_sym_head"#)]
708            _start: (),
709            header: SymbolHeader,
710            #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
711            _end: (),
712        },
713        ValueMap {
714            #[rust_sitter::leaf(pattern = r#"<\s*valuemap_sym_head"#)]
715            _start: (),
716            header: SymbolHeader,
717            #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
718            _end: (),
719        },
720        Name {
721            #[rust_sitter::leaf(pattern = r#"<\s*name_sym_head"#)]
722            _start: (),
723            header: SymbolHeader,
724            #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
725            _end: (),
726        },
727        VarNode {
728            #[rust_sitter::leaf(pattern = r#"<\s*varnode_sym_head"#)]
729            _start: (),
730            header: SymbolHeader,
731            #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
732            _end: (),
733        },
734        Context {
735            #[rust_sitter::leaf(pattern = r#"<\s*context_sym_head"#)]
736            _start: (),
737            header: SymbolHeader,
738            #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
739            _end: (),
740        },
741        VarNodeList {
742            #[rust_sitter::leaf(pattern = r#"<\s*varlist_sym_head"#)]
743            _start: (),
744            header: SymbolHeader,
745            #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
746            _end: (),
747        },
748        Operand {
749            #[rust_sitter::leaf(pattern = r#"<\s*operand_sym_head"#)]
750            _start: (),
751            header: SymbolHeader,
752            #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
753            _end: (),
754        },
755        Start {
756            #[rust_sitter::leaf(pattern = r#"<\s*start_sym_head"#)]
757            _start: (),
758            header: SymbolHeader,
759            #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
760            _end: (),
761        },
762        End {
763            #[rust_sitter::leaf(pattern = r#"<\s*end_sym_head"#)]
764            _start: (),
765            header: SymbolHeader,
766            #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
767            _end: (),
768        },
769        Next2 {
770            #[rust_sitter::leaf(pattern = r#"<\s*next2_sym_head"#)]
771            _start: (),
772            header: SymbolHeader,
773            #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
774            _end: (),
775        },
776        FlowDest {
777            #[rust_sitter::leaf(pattern = r#"<\s*flowdest_sym_head"#)]
778            _start: (),
779            header: SymbolHeader,
780            #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
781            _end: (),
782        },
783        FlowRef {
784            #[rust_sitter::leaf(pattern = r#"<\s*flowref_sym_head"#)]
785            _start: (),
786            header: SymbolHeader,
787            #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
788            _end: (),
789        },
790        SubTable {
791            #[rust_sitter::leaf(pattern = r#"<\s*subtable_sym_head"#)]
792            _start: (),
793            header: SymbolHeader,
794            #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
795            _close: (),
796        },
797    }
798
799    #[derive(Debug, PartialEq)]
800    pub enum PatternExpressionType {
801        PatternValue(PatternValueType),
802        BinaryExpression(Box<BinaryExpressionType>),
803        UnaryExpression(Box<UnaryExpressionType>),
804    }
805
806    impl TokenField {
807        const BIGENDIAN_REGEX: OnceCell<Regex> = OnceCell::new();
808        const SIGNBIT_REGEX: OnceCell<Regex> = OnceCell::new();
809        const BITSTART_REGEX: OnceCell<Regex> = OnceCell::new();
810        const BITEND_REGEX: OnceCell<Regex> = OnceCell::new();
811        const BYTESTART_REGEX: OnceCell<Regex> = OnceCell::new();
812        const BYTEEND_REGEX: OnceCell<Regex> = OnceCell::new();
813        const SHIFT_REGEX: OnceCell<Regex> = OnceCell::new();
814    }
815
816    #[derive(TypedBuilder, Debug, PartialEq)]
817    pub struct TokenField {
818        #[rust_sitter::leaf(pattern = r#"<\s*tokenfield"#)]
819        #[builder(default, setter(skip))]
820        _start: (),
821        #[rust_sitter::leaf(
822            pattern = r#"bigendian\s*=\s*"([a-z]+)""#,
823            transform = |v| {
824                TokenField::BIGENDIAN_REGEX
825                    .get_or_init(|| {
826                        Regex::new(r#"bigendian\s*=\s*"([a-z]+)""#)
827                            .expect("Invalid regular expression")
828                    })
829                    .captures(v)
830                    .expect("No captures or no capture group").get(1).expect("No capture group").as_str().parse().expect("Invalid boolean")
831            }
832        )]
833        bigendian: bool,
834        #[rust_sitter::leaf(
835            pattern = r#"signbit\s*=\s*"([a-z]+)""#,
836            transform = |v| {
837                TokenField::SIGNBIT_REGEX
838                    .get_or_init(|| {
839                        Regex::new(r#"signbit\s*=\s*"([a-z]+)""#)
840                            .expect("Invalid regular expression")
841                    })
842                    .captures(v)
843                    .expect("No captures or no capture group").get(1).expect("No capture group").as_str().parse().expect("Invalid boolean")
844            }
845        )]
846        signbit: bool,
847        #[rust_sitter::leaf(
848            pattern = r#"bitstart\s*=\s*"(-?[0-9]+)""#,
849            transform = |v| {
850                TokenField::BITSTART_REGEX
851                    .get_or_init(|| {
852                        Regex::new(r#"bitstart\s*=\s*"(-?[0-9]+)""#)
853                            .expect("Invalid regular expression")
854                    })
855                    .captures(v)
856                    .expect("No captures or no capture group").get(1).expect("No capture group").as_str().parse().expect("Invalid integer")
857            }
858        )]
859        #[builder(setter(transform = |v: impl Into<Integer>| {
860            v.into()
861        }))]
862        bitstart: Integer,
863        #[rust_sitter::leaf(
864            pattern = r#"bitend\s*=\s*"(-?[0-9]+)""#,
865            transform = |v| {
866                TokenField::BITEND_REGEX
867                    .get_or_init(|| {
868                        Regex::new(r#"bitend\s*=\s*"(-?[0-9]+)""#)
869                            .expect("Invalid regular expression")
870                    })
871                    .captures(v)
872                    .expect("No captures or no capture group").get(1).expect("No capture group").as_str().parse().expect("Invalid integer")
873            }
874        )]
875        #[builder(setter(transform = |v: impl Into<Integer>| {
876            v.into()
877        }))]
878        bitend: Integer,
879        #[rust_sitter::leaf(
880            pattern = r#"bytestart\s*=\s*"(-?[0-9]+)""#,
881            transform = |v| {
882                TokenField::BYTESTART_REGEX
883                    .get_or_init(|| {
884                        Regex::new(r#"bytestart\s*=\s*"(-?[0-9]+)""#)
885                            .expect("Invalid regular expression")
886                    })
887                    .captures(v)
888                    .expect("No captures or no capture group").get(1).expect("No capture group").as_str().parse().expect("Invalid integer")
889            }
890        )]
891        #[builder(setter(transform = |v: impl Into<Integer>| {
892            v.into()
893        }))]
894        bytestart: Integer,
895        #[rust_sitter::leaf(
896            pattern = r#"byteend\s*=\s*"(-?[0-9]+)""#,
897            transform = |v| {
898                TokenField::BYTEEND_REGEX
899                    .get_or_init(|| {
900                        Regex::new(r#"byteend\s*=\s*"(-?[0-9]+)""#)
901                            .expect("Invalid regular expression")
902                    })
903                    .captures(v)
904                    .expect("No captures or no capture group").get(1).expect("No capture group").as_str().parse().expect("Invalid integer")
905            }
906        )]
907        #[builder(setter(transform = |v: impl Into<Integer>| {
908            v.into()
909        }))]
910        byteend: Integer,
911        #[rust_sitter::leaf(
912            pattern = r#"shift\s*=\s*"(-?[0-9]+)""#,
913            transform = |v| {
914                TokenField::SHIFT_REGEX
915                    .get_or_init(|| {
916                        Regex::new(r#"shift\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
917                    })
918                    .captures(v)
919                    .expect("No captures or no capture group").get(1).expect("No capture group").as_str().parse().expect("Invalid integer")
920            }
921        )]
922        #[builder(setter(transform = |v: impl Into<Integer>| {
923            v.into()
924        }))]
925        shift: Integer,
926        #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
927        #[builder(default, setter(skip))]
928        _end: (),
929    }
930
931    impl ContextField {
932        const SIGNBIT_REGEX: OnceCell<Regex> = OnceCell::new();
933        const STARTBIT_REGEX: OnceCell<Regex> = OnceCell::new();
934        const ENDBIT_REGEX: OnceCell<Regex> = OnceCell::new();
935        const STARTBYTE_REGEX: OnceCell<Regex> = OnceCell::new();
936        const ENDBYTE_REGEX: OnceCell<Regex> = OnceCell::new();
937        const SHIFT_REGEX: OnceCell<Regex> = OnceCell::new();
938    }
939
940    #[derive(TypedBuilder, Debug, PartialEq)]
941    pub struct ContextField {
942        #[rust_sitter::leaf(pattern = r#"<\s*contextfield"#)]
943        #[builder(default, setter(skip))]
944        _start: (),
945        #[rust_sitter::leaf(
946            pattern = r#"signbit\s*=\s*"([a-z]+)""#,
947            transform = |v| {
948                ContextField::SIGNBIT_REGEX
949                    .get_or_init(|| {
950                        Regex::new(r#"signbit\s*=\s*"([a-z]+)""#)
951                            .expect("Invalid regular expression")
952                    })
953                    .captures(v)
954                    .expect("No captures or no capture group")
955                    .get(1)
956                    .expect("No capture group").as_str().parse().expect("Invalid boolean")
957            }
958        )]
959        signbit: bool,
960        #[rust_sitter::leaf(
961            pattern = r#"startbit\s*=\s*"(-?[0-9]+)""#,
962            transform = |v| {
963                ContextField::STARTBIT_REGEX
964                    .get_or_init(|| {
965                        Regex::new(r#"startbit\s*=\s*"(-?[0-9]+)""#)
966                            .expect("Invalid regular expression")
967                    })
968                    .captures(v)
969                    .expect("No captures or no capture group")
970                    .get(1)
971                    .expect("No capture group").as_str().parse().expect("Invalid integer")
972            }
973        )]
974        #[builder(setter(transform = |v: impl Into<Integer>| {
975            v.into()
976        }))]
977        startbit: Integer,
978        #[rust_sitter::leaf(
979            pattern = r#"endbit\s*=\s*"(-?[0-9]+)""#,
980            transform = |v| {
981                ContextField::ENDBIT_REGEX
982                    .get_or_init(|| {
983                        Regex::new(r#"endbit\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
984                    })
985                    .captures(v)
986                    .expect("No captures or no capture group")
987                    .get(1)
988                    .expect("No capture group").as_str().parse().expect("Invalid integer")
989            }
990        )]
991        #[builder(setter(transform = |v: impl Into<Integer>| {
992            v.into()
993        }))]
994        endbit: Integer,
995        #[rust_sitter::leaf(
996            pattern = r#"startbyte\s*=\s*"(-?[0-9]+)""#,
997            transform = |v| {
998                ContextField::STARTBYTE_REGEX
999                    .get_or_init(|| {
1000                        Regex::new(r#"startbyte\s*=\s*"(-?[0-9]+)""#)
1001                            .expect("Invalid regular expression")
1002                    })
1003                    .captures(v)
1004                    .expect("No captures or no capture group").get(1).expect("No capture group").as_str().parse().expect("Invalid integer")
1005            }
1006        )]
1007        #[builder(setter(transform = |v: impl Into<Integer>| {
1008            v.into()
1009        }))]
1010        startbyte: Integer,
1011        #[rust_sitter::leaf(
1012            pattern = r#"endbyte\s*=\s*"(-?[0-9]+)""#,
1013            transform = |v| {
1014                ContextField::ENDBYTE_REGEX
1015                    .get_or_init(|| {
1016                        Regex::new(r#"endbyte\s*=\s*"(-?[0-9]+)""#)
1017                            .expect("Invalid regular expression")
1018                    })
1019                    .captures(v)
1020                    .expect("No captures or no capture group").get(1).expect("No capture group").as_str().parse().expect("Invalid integer")
1021            }
1022        )]
1023        #[builder(setter(transform = |v: impl Into<Integer>| {
1024            v.into()
1025        }))]
1026        endbyte: Integer,
1027        #[rust_sitter::leaf(
1028            pattern = r#"shift\s*=\s*"(-?[0-9]+)""#,
1029            transform = |v| {
1030                ContextField::SHIFT_REGEX
1031                    .get_or_init(|| {
1032                        Regex::new(r#"shift\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
1033                    })
1034                    .captures(v)
1035                    .expect("No captures or no capture group").get(1).expect("No capture group").as_str().parse().expect("Invalid integer")
1036            }
1037        )]
1038        #[builder(setter(transform = |v: impl Into<Integer>| {
1039            v.into()
1040        }))]
1041        shift: Integer,
1042        #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
1043        #[builder(default, setter(skip))]
1044        _end: (),
1045    }
1046
1047    impl ConstantValue {
1048        const VAL_REGEX: OnceCell<Regex> = OnceCell::new();
1049    }
1050
1051    #[derive(TypedBuilder, Debug, PartialEq)]
1052    pub struct ConstantValue {
1053        #[rust_sitter::leaf(pattern = r#"<\s*intb"#)]
1054        #[builder(default, setter(skip))]
1055        _start: (),
1056        #[rust_sitter::leaf(
1057            pattern = r#"val\s*=\s*"(-?[0-9]+)""#,
1058            transform = |v| {
1059                ConstantValue::VAL_REGEX
1060                    .get_or_init(|| {
1061                        Regex::new(r#"val\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
1062                    })
1063                    .captures(v)
1064                    .expect("No captures or no capture group")
1065                    .get(1)
1066                    .expect("No capture group").as_str().parse().expect("Invalid integer")
1067            }
1068        )]
1069        #[builder(setter(transform = |v: impl Into<Integer>| {
1070            v.into()
1071        }))]
1072        val: Integer,
1073        #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
1074        #[builder(default, setter(skip))]
1075        _end: (),
1076    }
1077
1078    impl OperandValue {
1079        // DEC:
1080        const INDEX_REGEX: OnceCell<Regex> = OnceCell::new();
1081        // HEX:
1082        const TABLE_REGEX: OnceCell<Regex> = OnceCell::new();
1083        /// HEX: Constructor ID
1084        const CONSTRUCTOR_ID_REGEX: OnceCell<Regex> = OnceCell::new();
1085    }
1086
1087    #[derive(TypedBuilder, Debug, PartialEq)]
1088    pub struct OperandValue {
1089        #[rust_sitter::leaf(pattern = r#"<\s*operand_exp"#)]
1090        #[builder(default, setter(skip))]
1091        _start: (),
1092        #[rust_sitter::leaf(
1093            pattern = r#"index\s*=\s*"(-?[0-9]+)""#,
1094            transform = |v| {
1095                OperandValue::INDEX_REGEX
1096                    .get_or_init(|| {
1097                        Regex::new(r#"index\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
1098                    })
1099                    .captures(v)
1100                    .expect("No captures or no capture group")
1101                    .get(1)
1102                    .expect("No capture group").as_str().parse().expect("Invalid integer")
1103            }
1104        )]
1105        #[builder(setter(transform = |v: impl Into<Integer>| {
1106            v.into()
1107        }))]
1108        index: Integer,
1109        #[rust_sitter::leaf(
1110            pattern = r#"table\s*=\s*"0x([0-9a-fA-F]+)""#,
1111            transform = |v| {
1112                Integer::from_string_base(16, OperandValue::TABLE_REGEX
1113                    .get_or_init(|| {
1114                        Regex::new(r#"table\s*=\s*"0x([0-9a-fA-F]+)""#)
1115                            .expect("Invalid regular expression")
1116                    })
1117                    .captures(v)
1118                    .expect("No captures or no capture group")
1119                    .get(1)
1120                    .expect("No capture group").as_str()).expect("Invalid integer")
1121            }
1122        )]
1123        #[builder(setter(transform = |v: impl Into<Integer>| {
1124            v.into()
1125        }))]
1126        table: Integer,
1127        #[rust_sitter::leaf(
1128            pattern = r#"ct\s*=\s*"0x([0-9a-fA-F]+)""#,
1129            transform = |v| {
1130                Integer::from_string_base(16, OperandValue::CONSTRUCTOR_ID_REGEX
1131                    .get_or_init(|| {
1132                        Regex::new(r#"ct\s*=\s*"0x([0-9a-fA-F]+)""#)
1133                            .expect("Invalid regular expression")
1134                    })
1135                    .captures(v)
1136                    .expect("No captures or no capture group")
1137                    .get(1)
1138                    .expect("No capture group").as_str()).expect("Invalid integer")
1139            }
1140        )]
1141        #[builder(setter(transform = |v: impl Into<Integer>| {
1142            v.into()
1143        }))]
1144        constructor_id: Integer,
1145        #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
1146        #[builder(default, setter(skip))]
1147        _end: (),
1148    }
1149
1150    #[derive(Debug, PartialEq)]
1151    /// Class Inheritance goes:
1152    /// - PatternExpression:
1153    ///   - PatternValue : PatternExpression
1154    ///     - TokenField : PatternValue
1155    ///     - ContextField : PatternValue
1156    ///     - ConstantValue : PatternValue
1157    ///     - StartInstructionValue : PatternValue
1158    ///     - EndInstructionValue : PatternValue
1159    ///     - Next2InstructionValue : PatternValue
1160    ///     - OperandValue : PatternValue
1161    ///   - UnaryExpression : PatternExpression
1162    ///   - BinaryExpression : PatternExpression
1163    pub enum PatternValueType {
1164        TokenField(TokenField),
1165        ContextField(ContextField),
1166        ConstantValue(ConstantValue),
1167        OperandValue(OperandValue),
1168        StartInstructionValue {
1169            #[rust_sitter::leaf(pattern = r#"<\s*start_exp\s*/\s*>"#)]
1170            _tag: (),
1171        },
1172        EndInstructionValue {
1173            #[rust_sitter::leaf(pattern = r#"<\s*end_exp\s*/\s*>"#)]
1174            _tag: (),
1175        },
1176        Next2InstructionValue {
1177            #[rust_sitter::leaf(pattern = r#"<\s*next2_exp\s*/\s*>"#)]
1178            _tag: (),
1179        },
1180    }
1181
1182    #[derive(Debug, PartialEq)]
1183    /// Class Inheritance goes:
1184    /// - PatternExpression:
1185    ///   - BinaryExpression : PatternExpression
1186    ///     - PlusExpression : BinaryExpression
1187    ///     - SubExpression : BinaryExpression
1188    ///     - MultExpression : BinaryExpression
1189    ///     - LeftShiftExpression : BinaryExpression
1190    ///     - RightShiftExpression : BinaryExpression
1191    ///     - AndExpression : BinaryExpression
1192    ///     - OrExpression : BinaryExpression
1193    ///     - XorExpression : BinaryExpression
1194    ///     - DivExpression : BinaryExpression
1195    ///   - PatternValue : PatternExpression
1196    ///   - UnaryExpression : PatternExpression
1197    pub enum BinaryExpressionType {
1198        Plus {
1199            #[rust_sitter::leaf(pattern = r#"<\s*plus_exp\s*>"#)]
1200            _start: (),
1201            left: PatternExpressionType,
1202            right: PatternExpressionType,
1203            #[rust_sitter::leaf(pattern = r#"<\s*/\s*plus_exp\s*>"#)]
1204            _end: (),
1205        },
1206        Sub {
1207            #[rust_sitter::leaf(pattern = r#"<\s*sub_exp\s*>"#)]
1208            _start: (),
1209            left: PatternExpressionType,
1210            right: PatternExpressionType,
1211            #[rust_sitter::leaf(pattern = r#"<\s*/\s*sub_exp\s*>"#)]
1212            _end: (),
1213        },
1214        Mult {
1215            #[rust_sitter::leaf(pattern = r#"<\s*mult_exp\s*>"#)]
1216            _start: (),
1217            left: PatternExpressionType,
1218            right: PatternExpressionType,
1219            #[rust_sitter::leaf(pattern = r#"<\s*/\s*mult_exp\s*>"#)]
1220            _end: (),
1221        },
1222        LeftShift {
1223            #[rust_sitter::leaf(pattern = r#"<\s*lshift_exp\s*>"#)]
1224            _start: (),
1225            left: PatternExpressionType,
1226            right: PatternExpressionType,
1227            #[rust_sitter::leaf(pattern = r#"<\s*/\s*lshift_exp\s*>"#)]
1228            _end: (),
1229        },
1230        RightShift {
1231            #[rust_sitter::leaf(pattern = r#"<\s*rshift_exp\s*>"#)]
1232            _start: (),
1233            left: PatternExpressionType,
1234            right: PatternExpressionType,
1235            #[rust_sitter::leaf(pattern = r#"<\s*/\s*rshift_exp\s*>"#)]
1236            _end: (),
1237        },
1238        And {
1239            #[rust_sitter::leaf(pattern = r#"<\s*and_exp\s*>"#)]
1240            _start: (),
1241            left: PatternExpressionType,
1242            right: PatternExpressionType,
1243            #[rust_sitter::leaf(pattern = r#"<\s*/\s*and_exp\s*>"#)]
1244            _end: (),
1245        },
1246        Or {
1247            #[rust_sitter::leaf(pattern = r#"<\s*or_exp\s*>"#)]
1248            _start: (),
1249            left: PatternExpressionType,
1250            right: PatternExpressionType,
1251            #[rust_sitter::leaf(pattern = r#"<\s*/\s*or_exp\s*>"#)]
1252            _end: (),
1253        },
1254        Xor {
1255            #[rust_sitter::leaf(pattern = r#"<\s*xor_exp\s*>"#)]
1256            _start: (),
1257            left: PatternExpressionType,
1258            right: PatternExpressionType,
1259            #[rust_sitter::leaf(pattern = r#"<\s*/\s*xor_exp\s*>"#)]
1260            _end: (),
1261        },
1262        Div {
1263            #[rust_sitter::leaf(pattern = r#"<\s*div_exp\s*>"#)]
1264            _start: (),
1265            left: PatternExpressionType,
1266            right: PatternExpressionType,
1267            #[rust_sitter::leaf(pattern = r#"<\s*/\s*div_exp\s*>"#)]
1268            _end: (),
1269        },
1270    }
1271
1272    #[derive(Debug, PartialEq)]
1273    /// Class Inheritance goes:
1274    /// - PatternExpression:
1275    ///   - PatternValue : PatternExpression
1276    ///   - BinaryExpression : PatternExpression
1277    ///   - UnaryExpression : PatternExpression
1278    ///     - MinusExpression : UnaryExpression
1279    ///     - NotExpression : UnaryExpression
1280    pub enum UnaryExpressionType {
1281        Minus {
1282            #[rust_sitter::leaf(pattern = r#"<\s*minus_exp\s*>"#)]
1283            _start: (),
1284            inner: PatternExpressionType,
1285            #[rust_sitter::leaf(pattern = r#"<\s*/\s*minus_exp\s*>"#)]
1286            _end: (),
1287        },
1288        Not {
1289            #[rust_sitter::leaf(pattern = r#"<\s*not_exp\s*>"#)]
1290            _start: (),
1291            inner: PatternExpressionType,
1292            #[rust_sitter::leaf(pattern = r#"<\s*/\s*not_exp\s*>"#)]
1293            _end: (),
1294        },
1295    }
1296
1297    #[derive(TypedBuilder, Debug, PartialEq)]
1298    pub struct Value {
1299        header: SymbolHeader,
1300        #[rust_sitter::leaf(pattern = r#">"#)]
1301        #[builder(default, setter(skip))]
1302        _close: (),
1303        patval: PatternValueType,
1304    }
1305
1306    impl UserOpSymbol {
1307        const INDEX_REGEX: OnceCell<Regex> = OnceCell::new();
1308    }
1309
1310    #[derive(TypedBuilder, Debug, PartialEq)]
1311    pub struct UserOpSymbol {
1312        header: SymbolHeader,
1313        #[rust_sitter::leaf(
1314            pattern = r#"index\s*=\s*"(-?[0-9]+)""#,
1315            transform = |v| {
1316                UserOpSymbol::INDEX_REGEX
1317                    .get_or_init(|| {
1318                        Regex::new(r#"index\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
1319                    })
1320                    .captures(v)
1321                    .expect("No captures or no capture group")
1322                    .get(1)
1323                    .expect("No capture group").as_str().parse().expect("Invalid integer")
1324            }
1325        )]
1326        #[builder(setter(transform = |v: impl Into<Integer>| {
1327            v.into()
1328        }))]
1329        index: Integer,
1330    }
1331
1332    #[derive(Debug, PartialEq)]
1333    /// Class Inheritance goes:
1334    /// - SleighSymbol
1335    ///   - SpaceSymbol : SleighSymbol
1336    ///   - TokenSymbol : SleighSymbol
1337    ///   - SectionSymbol : SleighSymbol
1338    ///   - UserOpSymbol : SleighSymbol
1339    ///   - TripleSymbol : SleighSymbol
1340    ///     - FamilySymbol : TripleSymbol
1341    ///       - ValueSymbol : FamilySymbol
1342    ///         - ValueMapSymbol : ValueSymbol
1343    ///         - NameSymbol : ValueSymbol
1344    ///         - ContextSymbol : ValueSymbol
1345    ///         - VarNodeListSymbol : ValueSymbol
1346    ///     - SpecificSymbol : TripleSymbol
1347    ///       - PatternlessSymbol : SpecificSymbol
1348    ///         - EpsilonSymbol : PatternlessSymbol
1349    ///         - VarNodeSymbol : PatternlessSymbol
1350    ///       - OperandSymbol : SpecificSymbol
1351    ///       - StartSymbol : SpecificSymbol
1352    ///       - EndSymbol : SpecificSymbol
1353    ///       - Next2Symbol : SpecificSymbol
1354    ///       - FlowDestSymbol : SpecificSymbol
1355    ///       - FlowRefSymbol : SpecificSymbol
1356    ///     - SubtableSymbol : SpecificSymbol
1357    ///   - BitRangeSymbol : SleighSymbol
1358    ///   - MacroSymbol : SleighSymbol
1359    ///   - LabelSymbol : SleighSymbol
1360    pub enum SleighSymbolType {
1361        // NOTE: Not saved/restored
1362        // SpaceSymbol(SpaceSymbol),
1363        // TokenSymbol(TokenSymbol),
1364        // SectionSymbol(SectionSymbol),
1365        UserOpSymbol {
1366            #[rust_sitter::leaf(pattern = r#"<\s*userop"#)]
1367            _start: (),
1368            user_op: UserOpSymbol,
1369            #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
1370            _end: (),
1371        },
1372        TripleSymbol(TripleSymbol),
1373        // NOTE: Not saved/restored
1374        // BitRangeSymbol(BitRangeSymbol),
1375    }
1376
1377    impl ConstructorOperand {
1378        // HEX:
1379        const ID_REGEX: OnceCell<Regex> = OnceCell::new();
1380    }
1381    #[derive(TypedBuilder, Debug, PartialEq)]
1382    pub struct ConstructorOperand {
1383        #[rust_sitter::leaf(pattern = r#"<\s*oper"#)]
1384        #[builder(default, setter(skip))]
1385        _start: (),
1386        #[rust_sitter::leaf(
1387            pattern = r#"id\s*=\s*"0x([0-9a-fA-F]+)""#,
1388            transform = |v| {
1389                Integer::from_string_base(16, ConstructorOperand::ID_REGEX
1390                    .get_or_init(|| {
1391                        Regex::new(r#"id\s*=\s*"0x([0-9a-fA-F]+)""#)
1392                            .expect("Invalid regular expression")
1393                    })
1394                    .captures(v)
1395                    .expect("No captures or no capture group")
1396                    .get(1)
1397                    .expect("No capture group").as_str()).expect("Invalid integer")
1398            }
1399        )]
1400        #[builder(setter(transform = |v: impl Into<Integer>| {
1401            v.into()
1402        }))]
1403        id: Integer,
1404        #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
1405        #[builder(default, setter(skip))]
1406        _end: (),
1407    }
1408
1409    impl OperandPrint {
1410        // DEC
1411        const ID_REGEX: OnceCell<Regex> = OnceCell::new();
1412    }
1413
1414    #[derive(TypedBuilder, Debug, PartialEq)]
1415    pub struct OperandPrint {
1416        #[rust_sitter::leaf(pattern = r#"<\s*opprint"#)]
1417        #[builder(default, setter(skip))]
1418        _start: (),
1419        #[rust_sitter::leaf(
1420            pattern = r#"id\s*=\s*"(-?[0-9]+)""#,
1421            transform = |v| {
1422                OperandPrint::ID_REGEX
1423                    .get_or_init(|| {
1424                        Regex::new(r#"id\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
1425                    })
1426                    .captures(v)
1427                    .expect("No captures or no capture group")
1428                    .get(1)
1429                    .expect("No capture group").as_str().parse().expect("Invalid integer")
1430            }
1431        )]
1432        #[builder(setter(transform = |v: impl Into<Integer>| {
1433            v.into()
1434        }))]
1435        id: Integer,
1436        #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
1437        #[builder(default, setter(skip))]
1438        _end: (),
1439    }
1440
1441    impl Print {
1442        // ESCAPED STRING
1443        const PIECE_REGEX: OnceCell<Regex> = OnceCell::new();
1444    }
1445
1446    #[derive(TypedBuilder, Debug, PartialEq)]
1447    pub struct Print {
1448        #[rust_sitter::leaf(pattern = r#"<\s*print"#)]
1449        #[builder(default, setter(skip))]
1450        _start: (),
1451        #[rust_sitter::leaf(
1452            pattern = r#"piece\s*=\s*"([^"]*)""#,
1453            transform = |v| {
1454                Print::PIECE_REGEX
1455                    .get_or_init(|| {
1456                        Regex::new(r#"piece\s*=\s*"([^"]*)""#).expect("Invalid regular expression")
1457                    })
1458                    .captures(v)
1459                    .expect("No captures or no capture group")
1460                    .get(1)
1461                    .expect("No capture group")
1462                    .as_str()
1463                    .to_string()
1464                    .xml_unescape()
1465            }
1466        )]
1467        piece: String,
1468        #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
1469        #[builder(default, setter(skip))]
1470        _end: (),
1471    }
1472
1473    #[derive(Debug, PartialEq)]
1474    pub enum PrintPieceType {
1475        Operand(OperandPrint),
1476        Print(Print),
1477    }
1478
1479    impl Operation {
1480        // DEC
1481        const I_REGEX: OnceCell<Regex> = OnceCell::new();
1482        // DEC
1483        const SHIFT_REGEX: OnceCell<Regex> = OnceCell::new();
1484        // HEX
1485        const MASK_REGEX: OnceCell<Regex> = OnceCell::new();
1486    }
1487
1488    #[derive(TypedBuilder, Debug, PartialEq)]
1489    pub struct Operation {
1490        #[rust_sitter::leaf(pattern = r#"<\s*context_op"#)]
1491        #[builder(default, setter(skip))]
1492        _start: (),
1493        #[rust_sitter::leaf(
1494            pattern = r#"i\s*=\s*"(-?[0-9]+)""#,
1495            transform = |v| {
1496                Operation::I_REGEX
1497                    .get_or_init(|| {
1498                        Regex::new(r#"i\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
1499                    })
1500                    .captures(v)
1501                    .expect("No captures or no capture group").get(1).expect("No capture group").as_str().parse().expect("Invalid integer")
1502            }
1503        )]
1504        #[builder(setter(transform = |v: impl Into<Integer>| {
1505            v.into()
1506        }))]
1507        i: Integer,
1508        #[rust_sitter::leaf(
1509            pattern = r#"shift\s*=\s*"(-?[0-9]+)""#,
1510            transform = |v| {
1511                Operation::SHIFT_REGEX
1512                    .get_or_init(|| {
1513                        Regex::new(r#"shift\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
1514                    })
1515                    .captures(v)
1516                    .expect("No captures or no capture group").get(1).expect("No capture group").as_str().parse().expect("Invalid integer")
1517            }
1518        )]
1519        #[builder(setter(transform = |v: impl Into<Integer>| {
1520            v.into()
1521        }))]
1522        shift: Integer,
1523        #[rust_sitter::leaf(
1524            pattern = r#"mask\s*=\s*"0x([0-9a-fA-F]+)""#,
1525            transform = |v| {
1526                Integer::from_string_base(16, Operation::MASK_REGEX
1527                    .get_or_init(|| {
1528                        Regex::new(r#"mask\s*=\s*"0x([0-9a-fA-F]+)""#)
1529                            .expect("Invalid regular expression")
1530                    })
1531                    .captures(v)
1532                    .expect("No captures or no capture group")
1533                    .get(1)
1534                    .expect("No capture group").as_str()).expect("Invalid integer")
1535            }
1536        )]
1537        #[builder(setter(transform = |v: impl Into<Integer>| {
1538            v.into()
1539        }))]
1540        mask: Integer,
1541        #[rust_sitter::leaf(pattern = r#">"#)]
1542        #[builder(default, setter(skip))]
1543        _close: (),
1544        patexp: PatternExpressionType,
1545        #[rust_sitter::leaf(pattern = r#"<\s*/\s*context_op\s*>"#)]
1546        #[builder(default, setter(skip))]
1547        _end: (),
1548    }
1549
1550    impl Commit {
1551        // HEX
1552        const ID_REGEX: OnceCell<Regex> = OnceCell::new();
1553        // DEC
1554        const NUM_REGEX: OnceCell<Regex> = OnceCell::new();
1555        // HEX
1556        const MASK_REGEX: OnceCell<Regex> = OnceCell::new();
1557        // BOOLEAN
1558        const FLOW_REGEX: OnceCell<Regex> = OnceCell::new();
1559    }
1560
1561    #[derive(TypedBuilder, Debug, PartialEq)]
1562    pub struct Commit {
1563        #[rust_sitter::leaf(pattern = r#"<\s*commit"#)]
1564        #[builder(default, setter(skip))]
1565        _start: (),
1566        #[rust_sitter::leaf(
1567            pattern = r#"id\s*=\s*"0x([0-9a-fA-F]+)""#,
1568            transform = |v| {
1569                Integer::from_string_base(16, Commit::ID_REGEX
1570                    .get_or_init(|| {
1571                        Regex::new(r#"id\s*=\s*"0x([0-9a-fA-F]+)""#)
1572                            .expect("Invalid regular expression")
1573                    })
1574                    .captures(v)
1575                    .expect("No captures or no capture group")
1576                    .get(1)
1577                    .expect("No capture group").as_str()).expect("Invalid integer")
1578            }
1579        )]
1580        #[builder(setter(transform = |v: impl Into<Integer>| {
1581            v.into()
1582        }))]
1583        id: Integer,
1584        #[rust_sitter::leaf(
1585            pattern = r#"num\s*=\s*"(-?[0-9]+)""#,
1586            transform = |v| {
1587                Commit::NUM_REGEX
1588                    .get_or_init(|| {
1589                        Regex::new(r#"num\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
1590                    })
1591                    .captures(v)
1592                    .expect("No captures or no capture group").get(1).expect("No capture group").as_str().parse().expect("Invalid integer")
1593            }
1594        )]
1595        #[builder(setter(transform = |v: impl Into<Integer>| {
1596            v.into()
1597        }))]
1598        num: Integer,
1599        #[rust_sitter::leaf(
1600            pattern = r#"mask\s*=\s*"0x([0-9a-fA-F]+)""#,
1601            transform = |v| {
1602                Integer::from_string_base(16, Commit::MASK_REGEX
1603                    .get_or_init(|| {
1604                        Regex::new(r#"mask\s*=\s*"0x([0-9a-fA-F]+)""#)
1605                            .expect("Invalid regular expression")
1606                    })
1607                    .captures(v)
1608                    .expect("No captures or no capture group")
1609                    .get(1)
1610                    .expect("No capture group").as_str()).expect("Invalid integer")
1611            }
1612        )]
1613        #[builder(setter(transform = |v: impl Into<Integer>| {
1614            v.into()
1615        }))]
1616        mask: Integer,
1617        #[rust_sitter::leaf(
1618            pattern = r#"flow\s*=\s*"([a-z]+)""#,
1619            transform = |v| {
1620                Commit::FLOW_REGEX
1621                    .get_or_init(|| {
1622                        Regex::new(r#"flow\s*=\s*"([a-z]+)""#).expect("Invalid regular expression")
1623                    })
1624                    .captures(v)
1625                    .expect("No captures or no capture group").get(1).expect("No capture group").as_str().parse().expect("Invalid boolean")
1626            }
1627        )]
1628        flow: bool,
1629        #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
1630        #[builder(default, setter(skip))]
1631        _end: (),
1632    }
1633
1634    #[derive(Debug, PartialEq)]
1635    pub enum ContextChangeType {
1636        Operation(Operation),
1637        Commit(Commit),
1638    }
1639
1640    #[derive(Debug, PartialEq)]
1641    pub enum ConstantTemplateSelector {
1642        Space {
1643            #[rust_sitter::leaf(pattern = r#"s\s*=\s*"space""#)]
1644            _space: (),
1645        },
1646        Offset {
1647            #[rust_sitter::leaf(pattern = r#"s\s*=\s*"offset""#)]
1648            _offset: (),
1649        },
1650        Size {
1651            #[rust_sitter::leaf(pattern = r#"s\s*=\s*"size""#)]
1652            _size: (),
1653        },
1654        OffsetPlus {
1655            #[rust_sitter::leaf(pattern = r#"s\s*=\s*"offset_plus""#)]
1656            _offset_plus: (),
1657        },
1658    }
1659
1660    impl ConstantTemplateType {
1661        // DEC or HEX depending on type
1662        const DEC_VAL_REGEX: OnceCell<Regex> = OnceCell::new();
1663        const HEX_VAL_REGEX: OnceCell<Regex> = OnceCell::new();
1664        // HEX
1665        const PLUS_REGEX: OnceCell<Regex> = OnceCell::new();
1666        // STRING
1667        const NAME_REGEX: OnceCell<Regex> = OnceCell::new();
1668    }
1669
1670    #[derive(Debug, PartialEq)]
1671    pub enum ConstantTemplateType {
1672        Real {
1673            #[rust_sitter::leaf(pattern = r#"<\s*const_tpl\s*type\s*=\s*"real""#)]
1674            _start: (),
1675            // This one is hex
1676            #[rust_sitter::leaf(
1677                pattern = r#"val\s*=\s*"0x([0-9a-fA-F]+)""#,
1678                transform = |v| {
1679                    Integer::from_string_base(16, ConstantTemplateType::HEX_VAL_REGEX
1680                        .get_or_init(|| {
1681                            Regex::new(r#"val\s*=\s*"0x([0-9a-fA-F]+)""#)
1682                                .expect("Invalid regular expression")
1683                        })
1684                        .captures(v)
1685                        .expect("No captures or no capture group")
1686                        .get(1)
1687                        .expect("No capture group").as_str()).expect("Invalid integer")
1688                }
1689            )]
1690            val: Integer,
1691            #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
1692            _end: (),
1693        },
1694        Handle {
1695            #[rust_sitter::leaf(pattern = r#"<\s*const_tpl\s*type\s*=\s*"handle""#)]
1696            _start: (),
1697            #[rust_sitter::leaf(
1698                pattern = r#"val\s*=\s*"(-?[0-9]+)""#,
1699                transform = |v| {
1700                    ConstantTemplateType::DEC_VAL_REGEX
1701                        .get_or_init(|| {
1702                            Regex::new(r#"val\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
1703                        })
1704                        .captures(v)
1705                        .expect("No captures or no capture group")
1706                        .get(1)
1707                        .expect("No capture group").as_str().parse().expect("Invalid integer")
1708                }
1709            )]
1710            val: Integer,
1711            selector: ConstantTemplateSelector,
1712            #[rust_sitter::leaf(
1713                pattern = r#"plus\s*=\s*"0x([0-9a-fA-F]+)""#,
1714                transform = |v| {
1715                    Integer::from_string_base(16, ConstantTemplateType::PLUS_REGEX
1716                        .get_or_init(|| {
1717                            Regex::new(r#"plus\s*=\s*"0x([0-9a-fA-F]+)""#)
1718                                .expect("Invalid regular expression")
1719                        })
1720                        .captures(v)
1721                        .expect("No captures or no capture group")
1722                        .get(1)
1723                        .expect("No capture group").as_str()).expect("Invalid integer")
1724                }
1725            )]
1726            plus: Option<Integer>,
1727            #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
1728            _end: (),
1729        },
1730        Start {
1731            #[rust_sitter::leaf(pattern = r#"<\s*const_tpl\s*type\s*=\s*"start"\s*/\s*>"#)]
1732            _start: (),
1733        },
1734        End {
1735            #[rust_sitter::leaf(pattern = r#"<\s*const_tpl\s*type\s*=\s*"end"\s*/\s*>"#)]
1736            _end: (),
1737        },
1738        Next {
1739            #[rust_sitter::leaf(pattern = r#"<\s*const_tpl\s*type\s*=\s*"next"\s*/\s*>"#)]
1740            _next: (),
1741        },
1742        Next2 {
1743            #[rust_sitter::leaf(pattern = r#"<\s*const_tpl\s*type\s*=\s*"next2"\s*/\s*>"#)]
1744            _next2: (),
1745        },
1746        CurSpace {
1747            #[rust_sitter::leaf(pattern = r#"<\s*const_tpl\s*type\s*=\s*"curspace"\s*/\s*>"#)]
1748            _cur_space: (),
1749        },
1750        CurSpaceSize {
1751            #[rust_sitter::leaf(pattern = r#"<\s*const_tpl\s*type\s*=\s*"curspace_size"\s*/\s*>"#)]
1752            _cur_space_size: (),
1753        },
1754        SpaceId {
1755            #[rust_sitter::leaf(pattern = r#"<\s*const_tpl\s*type\s*=\s*"spaceid""#)]
1756            _start: (),
1757            #[rust_sitter::leaf(
1758                pattern = r#"name\s*=\s*"([^"]*)""#,
1759                transform = |v| {
1760                    ConstantTemplateType::NAME_REGEX
1761                        .get_or_init(|| {
1762                            Regex::new(r#"name\s*=\s*"([^"]*)""#).expect("Invalid regular expression")
1763                        })
1764                        .captures(v)
1765                        .expect("No captures or no capture group")
1766                        .get(1)
1767                        .expect("No capture group")
1768                        .as_str()
1769                        .to_string()
1770                        .xml_unescape()
1771                }
1772            )]
1773            name: String,
1774            #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
1775            _end: (),
1776        },
1777        JumpRelative {
1778            #[rust_sitter::leaf(pattern = r#"<\s*const_tpl\s*type\s*=\s*"relative""#)]
1779            _start: (),
1780            #[rust_sitter::leaf(
1781                pattern = r#"val\s*=\s*"0x([0-9a-fA-F]+)""#,
1782                transform = |v| {
1783                    Integer::from_string_base(16, ConstantTemplateType::HEX_VAL_REGEX
1784                        .get_or_init(|| {
1785                            Regex::new(r#"val\s*=\s*"0x([0-9a-fA-F]+)""#)
1786                                .expect("Invalid regular expression")
1787                        })
1788                        .captures(v)
1789                        .expect("No captures or no capture group")
1790                        .get(1)
1791                        .expect("No capture group").as_str()).expect("Invalid integer")
1792                }
1793            )]
1794            val: Integer,
1795            #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
1796            _end: (),
1797        },
1798        FlowRef {
1799            #[rust_sitter::leaf(pattern = r#"<\s*const_tpl\s*type\s*=\s*"flowref"\s*/\s*>"#)]
1800            _flow_ref: (),
1801        },
1802        FlowDest {
1803            #[rust_sitter::leaf(pattern = r#"<\s*const_tpl\s*type\s*=\s*"flowdest"\s*/\s*>"#)]
1804            _flow_dest: (),
1805        },
1806        FlowDestSize {
1807            #[rust_sitter::leaf(pattern = r#"<\s*const_tpl\s*type\s*=\s*"flowdest_size"\s*/\s*>"#)]
1808            _flow_dest_size: (),
1809        },
1810    }
1811
1812    #[derive(TypedBuilder, Debug, PartialEq)]
1813    pub struct HandleTemplate {
1814        #[rust_sitter::leaf(pattern = r#"<\s*handle_tpl\s*>"#)]
1815        #[builder(default, setter(skip))]
1816        _start: (),
1817        space: ConstantTemplateType,
1818        size: ConstantTemplateType,
1819        ptrspace: ConstantTemplateType,
1820        ptroffset: ConstantTemplateType,
1821        ptrsize: ConstantTemplateType,
1822        temp_space: ConstantTemplateType,
1823        temp_offset: ConstantTemplateType,
1824        #[rust_sitter::leaf(pattern = r#"<\s*/\s*handle_tpl\s*>"#)]
1825        #[builder(default, setter(skip))]
1826        _end: (),
1827    }
1828
1829    #[derive(TypedBuilder, Debug, PartialEq)]
1830    pub struct VarNodeTemplate {
1831        #[rust_sitter::leaf(pattern = r#"<\s*varnode_tpl\s*>"#)]
1832        #[builder(default, setter(skip))]
1833        _start: (),
1834        space: ConstantTemplateType,
1835        offset: ConstantTemplateType,
1836        size: ConstantTemplateType,
1837        #[rust_sitter::leaf(pattern = r#"<\s*/\s*varnode_tpl\s*>"#)]
1838        #[builder(default, setter(skip))]
1839        _end: (),
1840    }
1841
1842    #[derive(Debug, PartialEq)]
1843    pub enum OperationCode {
1844        Blank {
1845            #[rust_sitter::leaf(pattern = r#"BLANK"#)]
1846            _blank: (),
1847        },
1848        Copy {
1849            #[rust_sitter::leaf(pattern = r#"COPY"#)]
1850            _copy: (),
1851        },
1852        Load {
1853            #[rust_sitter::leaf(pattern = r#"LOAD"#)]
1854            _load: (),
1855        },
1856        Store {
1857            #[rust_sitter::leaf(pattern = r#"STORE"#)]
1858            _store: (),
1859        },
1860        Branch {
1861            #[rust_sitter::leaf(pattern = r#"BRANCH"#)]
1862            _branch: (),
1863        },
1864        ConditionalBranch {
1865            #[rust_sitter::leaf(pattern = r#"CBRANCH"#)]
1866            _cbranch: (),
1867        },
1868        BranchIndirect {
1869            #[rust_sitter::leaf(pattern = r#"BRANCHIND"#)]
1870            _branchind: (),
1871        },
1872        Call {
1873            #[rust_sitter::leaf(pattern = r#"CALL"#)]
1874            _call: (),
1875        },
1876        CallIndirect {
1877            #[rust_sitter::leaf(pattern = r#"CALLIND"#)]
1878            _callind: (),
1879        },
1880        CallOther {
1881            #[rust_sitter::leaf(pattern = r#"CALLOTHER"#)]
1882            _callother: (),
1883        },
1884        Return {
1885            #[rust_sitter::leaf(pattern = r#"RETURN"#)]
1886            _return: (),
1887        },
1888        IntegerEqual {
1889            #[rust_sitter::leaf(pattern = r#"INT_EQUAL"#)]
1890            _int_equal: (),
1891        },
1892        IntegerNotEqual {
1893            #[rust_sitter::leaf(pattern = r#"INT_NOTEQUAL"#)]
1894            _int_notequal: (),
1895        },
1896        IntegerSignedLessThan {
1897            #[rust_sitter::leaf(pattern = r#"INT_SLESS"#)]
1898            _int_sless: (),
1899        },
1900        IntegerSignedLessThanOrEqual {
1901            #[rust_sitter::leaf(pattern = r#"INT_SLESSEQUAL"#)]
1902            _int_slessequal: (),
1903        },
1904        IntegerUnsignedLessThan {
1905            #[rust_sitter::leaf(pattern = r#"INT_LESS"#)]
1906            _int_less: (),
1907        },
1908        IntegerUnsignedLessThanOrEqual {
1909            #[rust_sitter::leaf(pattern = r#"INT_LESSEQUAL"#)]
1910            _int_lessequal: (),
1911        },
1912        IntegerZeroExtend {
1913            #[rust_sitter::leaf(pattern = r#"INT_ZEXT"#)]
1914            _int_zext: (),
1915        },
1916        IntegerSignExtend {
1917            #[rust_sitter::leaf(pattern = r#"INT_SEXT"#)]
1918            _int_sext: (),
1919        },
1920        IntegerAdd {
1921            #[rust_sitter::leaf(pattern = r#"INT_ADD"#)]
1922            _int_add: (),
1923        },
1924        IntegerSubtract {
1925            #[rust_sitter::leaf(pattern = r#"INT_SUB"#)]
1926            _int_sub: (),
1927        },
1928        IntegerCarry {
1929            #[rust_sitter::leaf(pattern = r#"INT_CARRY"#)]
1930            _int_carry: (),
1931        },
1932        IntegerSignedCarry {
1933            #[rust_sitter::leaf(pattern = r#"INT_SCARRY"#)]
1934            _int_scarry: (),
1935        },
1936        IntegerSignedBorrow {
1937            #[rust_sitter::leaf(pattern = r#"INT_SBORROW"#)]
1938            _int_sborrow: (),
1939        },
1940        IntegerTwosCompliment {
1941            #[rust_sitter::leaf(pattern = r#"INT_2COMP"#)]
1942            _int_2comp: (),
1943        },
1944        IntegerNegate {
1945            #[rust_sitter::leaf(pattern = r#"INT_NEGATE"#)]
1946            _int_negate: (),
1947        },
1948        IntegerXor {
1949            #[rust_sitter::leaf(pattern = r#"INT_XOR"#)]
1950            _int_xor: (),
1951        },
1952        IntegerAnd {
1953            #[rust_sitter::leaf(pattern = r#"INT_AND"#)]
1954            _int_and: (),
1955        },
1956        IntegerOr {
1957            #[rust_sitter::leaf(pattern = r#"INT_OR"#)]
1958            _int_or: (),
1959        },
1960        IntegerLeftShift {
1961            #[rust_sitter::leaf(pattern = r#"INT_LEFT"#)]
1962            _int_left: (),
1963        },
1964        IntegerRightShift {
1965            #[rust_sitter::leaf(pattern = r#"INT_RIGHT"#)]
1966            _int_right: (),
1967        },
1968        IntegerSignedRightShift {
1969            #[rust_sitter::leaf(pattern = r#"INT_SRIGHT"#)]
1970            _int_sright: (),
1971        },
1972        IntegerMultiply {
1973            #[rust_sitter::leaf(pattern = r#"INT_MULT"#)]
1974            _int_mult: (),
1975        },
1976        IntegerDivide {
1977            #[rust_sitter::leaf(pattern = r#"INT_DIV"#)]
1978            _int_div: (),
1979        },
1980        IntegerSignedDivide {
1981            #[rust_sitter::leaf(pattern = r#"INT_SDIV"#)]
1982            _int_sdiv: (),
1983        },
1984        IntegerRemainder {
1985            #[rust_sitter::leaf(pattern = r#"INT_REM"#)]
1986            _int_rem: (),
1987        },
1988        IntegerSignedRemainder {
1989            #[rust_sitter::leaf(pattern = r#"INT_SREM"#)]
1990            _int_srem: (),
1991        },
1992        BooleanNegate {
1993            #[rust_sitter::leaf(pattern = r#"BOOL_NEGATE"#)]
1994            _bool_negate: (),
1995        },
1996        BooleanXor {
1997            #[rust_sitter::leaf(pattern = r#"BOOL_XOR"#)]
1998            _bool_xor: (),
1999        },
2000        BooleanAnd {
2001            #[rust_sitter::leaf(pattern = r#"BOOL_AND"#)]
2002            _bool_and: (),
2003        },
2004        BooleanOr {
2005            #[rust_sitter::leaf(pattern = r#"BOOL_OR"#)]
2006            _bool_or: (),
2007        },
2008        FloatEqual {
2009            #[rust_sitter::leaf(pattern = r#"FLOAT_EQUAL"#)]
2010            _float_equal: (),
2011        },
2012        FloatNotEqual {
2013            #[rust_sitter::leaf(pattern = r#"FLOAT_NOTEQUAL"#)]
2014            _float_notequal: (),
2015        },
2016        FloatLessThan {
2017            #[rust_sitter::leaf(pattern = r#"FLOAT_LESS"#)]
2018            _float_less: (),
2019        },
2020        FloatLessThanOrEqual {
2021            #[rust_sitter::leaf(pattern = r#"FLOAT_LESSEQUAL"#)]
2022            _float_lessequal: (),
2023        },
2024        Unused1 {
2025            #[rust_sitter::leaf(pattern = r#"UNUSED1"#)]
2026            _unused1: (),
2027        },
2028        FloatNotANumber {
2029            #[rust_sitter::leaf(pattern = r#"FLOAT_NAN"#)]
2030            _float_nan: (),
2031        },
2032        FloatAdd {
2033            #[rust_sitter::leaf(pattern = r#"FLOAT_ADD"#)]
2034            _float_add: (),
2035        },
2036        FloatDivide {
2037            #[rust_sitter::leaf(pattern = r#"FLOAT_DIV"#)]
2038            _float_div: (),
2039        },
2040        FloatMultiply {
2041            #[rust_sitter::leaf(pattern = r#"FLOAT_MULT"#)]
2042            _float_mult: (),
2043        },
2044        FloatSubtract {
2045            #[rust_sitter::leaf(pattern = r#"FLOAT_SUB"#)]
2046            _float_sub: (),
2047        },
2048        FloatNegate {
2049            #[rust_sitter::leaf(pattern = r#"FLOAT_NEG"#)]
2050            _float_neg: (),
2051        },
2052        FloatAbsoluteValue {
2053            #[rust_sitter::leaf(pattern = r#"FLOAT_ABS"#)]
2054            _float_abs: (),
2055        },
2056        FloatSquareRoot {
2057            #[rust_sitter::leaf(pattern = r#"FLOAT_SQRT"#)]
2058            _float_sqrt: (),
2059        },
2060        IntegerToFloat {
2061            #[rust_sitter::leaf(pattern = r#"INT2FLOAT"#)]
2062            _int2float: (),
2063        },
2064        FloatToFloat {
2065            #[rust_sitter::leaf(pattern = r#"FLOAT2FLOAT"#)]
2066            _float2float: (),
2067        },
2068        Truncate {
2069            #[rust_sitter::leaf(pattern = r#"TRUNC"#)]
2070            _trunc: (),
2071        },
2072        Ceiling {
2073            #[rust_sitter::leaf(pattern = r#"CEIL"#)]
2074            _ceil: (),
2075        },
2076        Floor {
2077            #[rust_sitter::leaf(pattern = r#"FLOOR"#)]
2078            _floor: (),
2079        },
2080        Round {
2081            #[rust_sitter::leaf(pattern = r#"ROUND"#)]
2082            _round: (),
2083        },
2084        Build {
2085            #[rust_sitter::leaf(pattern = r#"BUILD"#)]
2086            _build: (),
2087        },
2088        DelaySlot {
2089            #[rust_sitter::leaf(pattern = r#"DELAY_SLOT"#)]
2090            _delay_slot: (),
2091        },
2092        Piece {
2093            #[rust_sitter::leaf(pattern = r#"PIECE"#)]
2094            _piece: (),
2095        },
2096        Subpiece {
2097            #[rust_sitter::leaf(pattern = r#"SUBPIECE"#)]
2098            _subpiece: (),
2099        },
2100        Cast {
2101            #[rust_sitter::leaf(pattern = r#"CAST"#)]
2102            _cast: (),
2103        },
2104        Label {
2105            #[rust_sitter::leaf(pattern = r#"LABEL"#)]
2106            _label: (),
2107        },
2108        CrossBuild {
2109            #[rust_sitter::leaf(pattern = r#"CROSSBUILD"#)]
2110            _crossbuild: (),
2111        },
2112        SegmentOp {
2113            #[rust_sitter::leaf(pattern = r#"SEGMENTOP"#)]
2114            _segmentop: (),
2115        },
2116        CpoolRef {
2117            #[rust_sitter::leaf(pattern = r#"CPOOLREF"#)]
2118            _cpoolref: (),
2119        },
2120        New {
2121            #[rust_sitter::leaf(pattern = r#"NEW"#)]
2122            _new: (),
2123        },
2124        Insert {
2125            #[rust_sitter::leaf(pattern = r#"INSERT"#)]
2126            _insert: (),
2127        },
2128        Extract {
2129            #[rust_sitter::leaf(pattern = r#"EXTRACT"#)]
2130            _extract: (),
2131        },
2132        PopCount {
2133            #[rust_sitter::leaf(pattern = r#"POPCOUNT"#)]
2134            _popcount: (),
2135        },
2136        LzCount {
2137            #[rust_sitter::leaf(pattern = r#"LZCOUNT"#)]
2138            _lzcnt: (),
2139        },
2140    }
2141
2142    #[derive(Debug, PartialEq)]
2143    pub enum OperationTemplateOutput {
2144        Null {
2145            #[rust_sitter::leaf(pattern = r#"<\s*null\s*/\s*>"#)]
2146            _null: (),
2147        },
2148        Output(VarNodeTemplate),
2149    }
2150
2151    #[derive(TypedBuilder, Debug, PartialEq)]
2152    pub struct OperationTemplate {
2153        #[rust_sitter::leaf(pattern = r#"<\s*op_tpl"#)]
2154        #[builder(default, setter(skip))]
2155        _start: (),
2156        #[rust_sitter::leaf(pattern = r#"code\s*=\s*""#)]
2157        #[builder(default, setter(skip))]
2158        _code_pre: (),
2159        code: OperationCode,
2160        #[rust_sitter::leaf(pattern = r#""\s*>"#)]
2161        #[builder(default, setter(skip))]
2162        _close: (),
2163        output: OperationTemplateOutput,
2164        input: Vec<VarNodeTemplate>,
2165        #[rust_sitter::leaf(pattern = r#"<\s*/\s*op_tpl\s*>"#)]
2166        #[builder(default, setter(skip))]
2167        _end: (),
2168    }
2169
2170    impl ConstructorTemplate {
2171        // DEC
2172        const SECTION_REGEX: OnceCell<Regex> = OnceCell::new();
2173        // DEC
2174        const DELAY_REGEX: OnceCell<Regex> = OnceCell::new();
2175        // DEC
2176        const NUMLABELS_REGEX: OnceCell<Regex> = OnceCell::new();
2177    }
2178
2179    #[derive(Debug, PartialEq)]
2180    pub enum ConstructorTemplateResult {
2181        Null {
2182            #[rust_sitter::leaf(pattern = r#"<\s*null\s*/\s*>"#)]
2183            _null: (),
2184        },
2185        Result(HandleTemplate),
2186    }
2187
2188    #[derive(TypedBuilder, Debug, PartialEq)]
2189    pub struct ConstructorTemplate {
2190        #[rust_sitter::leaf(pattern = r#"<\s*construct_tpl"#)]
2191        #[builder(default, setter(skip))]
2192        _start: (),
2193        #[rust_sitter::leaf(
2194            pattern = r#"section\s*=\s*"(-?[0-9]+)""#,
2195            transform = |v| {
2196                ConstructorTemplate::SECTION_REGEX
2197                    .get_or_init(|| {
2198                        Regex::new(r#"section\s*=\s*"(-?[0-9]+)""#)
2199                            .expect("Invalid regular expression")
2200                    })
2201                    .captures(v)
2202                    .expect("No captures or no capture group").get(1).expect("No capture group").as_str().parse().expect("Invalid integer")
2203            }
2204        )]
2205        #[builder(setter(transform = |v: impl Into<Integer>| {
2206            Some(v.into())
2207        }))]
2208        section: Option<Integer>,
2209        #[rust_sitter::leaf(
2210            pattern = r#"delay\s*=\s*"(-?[0-9]+)""#,
2211            transform = |v| {
2212                ConstructorTemplate::DELAY_REGEX
2213                    .get_or_init(|| {
2214                        Regex::new(r#"delay\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
2215                    })
2216                    .captures(v)
2217                    .expect("No captures or no capture group").get(1).expect("No capture group").as_str().parse().expect("Invalid integer")
2218            }
2219        )]
2220        #[builder(setter(transform = |v: impl Into<Integer>| {
2221            Some(v.into())
2222        }))]
2223        delay: Option<Integer>,
2224        #[rust_sitter::leaf(
2225            pattern = r#"labels\s*=\s*"(-?[0-9]+)""#,
2226            transform = |v| {
2227                ConstructorTemplate::NUMLABELS_REGEX
2228                    .get_or_init(|| {
2229                        Regex::new(r#"labels\s*=\s*"(-?[0-9]+)""#)
2230                            .expect("Invalid regular expression")
2231                    })
2232                    .captures(v)
2233                    .expect("No captures or no capture group").get(1).expect("No capture group").as_str().parse().expect("Invalid integer")
2234            }
2235        )]
2236        #[builder(setter(transform = |v: impl Into<Integer>| {
2237            Some(v.into())
2238        }))]
2239        numlabels: Option<Integer>,
2240        #[rust_sitter::leaf(pattern = r#">"#)]
2241        #[builder(default, setter(skip))]
2242        _close: (),
2243        result: ConstructorTemplateResult,
2244        vec: Vec<OperationTemplate>,
2245        #[rust_sitter::leaf(pattern = r#"<\s*/\s*construct_tpl\s*>"#)]
2246        #[builder(default, setter(skip))]
2247        _end: (),
2248    }
2249
2250    impl Constructor {
2251        // HEX
2252        const PARENT_REGEX: OnceCell<Regex> = OnceCell::new();
2253        // DEC
2254        const FIRST_REGEX: OnceCell<Regex> = OnceCell::new();
2255        // DEC
2256        const LENGTH_REGEX: OnceCell<Regex> = OnceCell::new();
2257        // DEC:DEC
2258        const LINE_REGEX: OnceCell<Regex> = OnceCell::new();
2259    }
2260
2261    #[derive(TypedBuilder, Debug, PartialEq)]
2262    #[rust_sitter::prec_left(1)]
2263    pub struct Constructor {
2264        #[rust_sitter::leaf(pattern = r#"<\s*constructor"#)]
2265        #[builder(default, setter(skip))]
2266        _start: (),
2267        #[rust_sitter::leaf(
2268            pattern = r#"parent\s*=\s*"0x([0-9a-fA-F]+)""#,
2269            transform = |v| {
2270                Integer::from_string_base(16, Constructor::PARENT_REGEX
2271                    .get_or_init(|| {
2272                        Regex::new(r#"parent\s*=\s*"0x([0-9a-fA-F]+)""#)
2273                            .expect("Invalid regular expression")
2274                    })
2275                    .captures(v)
2276                    .expect("No captures or no capture group")
2277                    .get(1)
2278                    .expect("No capture group").as_str()).expect("Invalid integer")
2279            }
2280        )]
2281        #[builder(setter(transform = |v: impl Into<Integer>| {
2282            v.into()
2283        }))]
2284        parent: Integer,
2285        #[rust_sitter::leaf(
2286            pattern = r#"first\s*=\s*"(-?[0-9]+)""#,
2287            transform = |v| {
2288                Constructor::FIRST_REGEX
2289                    .get_or_init(|| {
2290                        Regex::new(r#"first\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
2291                    })
2292                    .captures(v)
2293                    .expect("No captures or no capture group")
2294                    .get(1)
2295                    .expect("No capture group").as_str().parse().expect("Invalid integer")
2296            }
2297        )]
2298        #[builder(setter(transform = |v: impl Into<Integer>| {
2299            v.into()
2300        }))]
2301        first: Integer,
2302        #[rust_sitter::leaf(
2303            pattern = r#"length\s*=\s*"(-?[0-9]+)""#,
2304            transform = |v| {
2305                Constructor::LENGTH_REGEX
2306                    .get_or_init(|| {
2307                        Regex::new(r#"length\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
2308                    })
2309                    .captures(v)
2310                    .expect("No captures or no capture group").get(1).expect("No capture group").as_str().parse().expect("Invalid integer")
2311            }
2312        )]
2313        #[builder(setter(transform = |v: impl Into<Integer>| {
2314            v.into()
2315        }))]
2316        length: Integer,
2317        #[rust_sitter::leaf(
2318            pattern = r#"line\s*=\s*"(-?[0-9]+):(-?[0-9]+)""#,
2319            transform = |v| {
2320                let captures = Constructor::LINE_REGEX
2321                    .get_or_init(|| {
2322                        Regex::new(r#"line\s*=\s*"(-?[0-9]+):(-?[0-9]+)""#)
2323                            .expect("Invalid regular expression")
2324                    })
2325                    .captures(v)
2326                    .expect("No captures or no capture group");
2327                let line = captures.get(1).expect("No capture group").as_str().parse().expect("Invalid integer");
2328                let col = captures.get(2).expect("No capture group").as_str().parse().expect("Invalid integer");
2329                (line, col)
2330            }
2331        )]
2332        #[builder(setter(transform = |v: impl Into<(Integer, Integer)>| {
2333            let (line, col) = v.into();
2334            (line, col)
2335        }))]
2336        line: (Integer, Integer),
2337        #[rust_sitter::leaf(pattern = r#">"#)]
2338        #[builder(default, setter(skip))]
2339        _close: (),
2340        operands: Vec<ConstructorOperand>,
2341        printpiece: Vec<PrintPieceType>,
2342        contexts: Vec<ContextChangeType>,
2343        templ: Option<ConstructorTemplate>,
2344        namedtempl: Vec<ConstructorTemplate>,
2345        #[rust_sitter::leaf(pattern = r#"<\s*/\s*constructor\s*>"#)]
2346        #[builder(default, setter(skip))]
2347        _end: (),
2348    }
2349
2350    impl PatternBlockWord {
2351        // HEX
2352        const MASK_REGEX: OnceCell<Regex> = OnceCell::new();
2353        const VAL_REGEX: OnceCell<Regex> = OnceCell::new();
2354    }
2355
2356    #[derive(TypedBuilder, Debug, PartialEq)]
2357    pub struct PatternBlockWord {
2358        #[rust_sitter::leaf(pattern = r#"<\s*mask_word"#)]
2359        #[builder(default, setter(skip))]
2360        _start: (),
2361        #[rust_sitter::leaf(
2362            pattern = r#"mask\s*=\s*"0x([0-9a-fA-F]+)""#,
2363            transform = |v| {
2364                Integer::from_string_base(16, PatternBlockWord::MASK_REGEX
2365                    .get_or_init(|| {
2366                        Regex::new(r#"mask\s*=\s*"0x([0-9a-fA-F]+)""#)
2367                            .expect("Invalid regular expression")
2368                    })
2369                    .captures(v)
2370                    .expect("No captures or no capture group")
2371                    .get(1)
2372                    .expect("No capture group").as_str()).expect("Invalid integer")
2373            }
2374        )]
2375        #[builder(setter(transform = |v: impl Into<Integer>| {
2376            v.into()
2377        }))]
2378        mask: Integer,
2379        #[rust_sitter::leaf(
2380            pattern = r#"val\s*=\s*"0x([0-9a-fA-F]+)""#,
2381            transform = |v| {
2382                Integer::from_string_base(16, PatternBlockWord::VAL_REGEX
2383                    .get_or_init(|| {
2384                        Regex::new(r#"val\s*=\s*"0x([0-9a-fA-F]+)""#)
2385                            .expect("Invalid regular expression")
2386                    })
2387                    .captures(v)
2388                    .expect("No captures or no capture group")
2389                    .get(1)
2390                    .expect("No capture group").as_str()).expect("Invalid integer")
2391            }
2392        )]
2393        #[builder(setter(transform = |v: impl Into<Integer>| {
2394            v.into()
2395        }))]
2396        val: Integer,
2397        #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
2398        #[builder(default, setter(skip))]
2399        _end: (),
2400    }
2401
2402    impl PatternBlock {
2403        // DEC
2404        const OFFSET_REGEX: OnceCell<Regex> = OnceCell::new();
2405        // DEC
2406        const NONZERO_REGEX: OnceCell<Regex> = OnceCell::new();
2407    }
2408
2409    #[derive(TypedBuilder, Debug, PartialEq)]
2410    pub struct PatternBlock {
2411        #[rust_sitter::leaf(pattern = r#"<\s*pat_block"#)]
2412        #[builder(default, setter(skip))]
2413        _start: (),
2414        #[rust_sitter::leaf(
2415            pattern = r#"offset\s*=\s*"(-?[0-9]+)""#,
2416            transform = |v| {
2417                PatternBlock::OFFSET_REGEX
2418                    .get_or_init(|| {
2419                        Regex::new(r#"offset\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
2420                    })
2421                    .captures(v)
2422                    .expect("No captures or no capture group")
2423                    .get(1)
2424                    .expect("No capture group").as_str().parse().expect("Invalid integer")
2425            }
2426        )]
2427        #[builder(setter(transform = |v: impl Into<Integer>| {
2428            v.into()
2429        }))]
2430        offset: Integer,
2431        #[rust_sitter::leaf(
2432            pattern = r#"nonzero\s*=\s*"(-?[0-9]+)""#,
2433            transform = |v| {
2434                PatternBlock::NONZERO_REGEX
2435                    .get_or_init(|| {
2436                        Regex::new(r#"nonzero\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
2437                    })
2438                    .captures(v)
2439                    .expect("No captures or no capture group")
2440                    .get(1)
2441                    .expect("No capture group").as_str().parse().expect("Invalid integer")
2442            }
2443        )]
2444        #[builder(setter(transform = |v: impl Into<Integer>| {
2445            v.into()
2446        }))]
2447        nonzero: Integer,
2448        #[rust_sitter::leaf(pattern = r#">"#)]
2449        #[builder(default, setter(skip))]
2450        _close: (),
2451        mask_vals: Vec<PatternBlockWord>,
2452        #[rust_sitter::leaf(pattern = r#"<\s*/\s*pat_block\s*>"#)]
2453        #[builder(default, setter(skip))]
2454        _end: (),
2455    }
2456
2457    #[derive(TypedBuilder, Debug, PartialEq)]
2458    pub struct InstructionPattern {
2459        #[rust_sitter::leaf(pattern = r#"<\s*instruct_pat\s*>"#)]
2460        #[builder(default, setter(skip))]
2461        _start: (),
2462        mask_value: PatternBlock,
2463        #[rust_sitter::leaf(pattern = r#"<\s*/\s*instruct_pat\s*>"#)]
2464        #[builder(default, setter(skip))]
2465        _end: (),
2466    }
2467
2468    #[derive(TypedBuilder, Debug, PartialEq)]
2469    pub struct ContextPattern {
2470        #[rust_sitter::leaf(pattern = r#"<\s*context_pat\s*>"#)]
2471        #[builder(default, setter(skip))]
2472        _start: (),
2473        mask_value: PatternBlock,
2474        #[rust_sitter::leaf(pattern = r#"<\s*/\s*context_pat\s*>"#)]
2475        #[builder(default, setter(skip))]
2476        _end: (),
2477    }
2478
2479    #[derive(TypedBuilder, Debug, PartialEq)]
2480    pub struct CombinePattern {
2481        #[rust_sitter::leaf(pattern = r#"<\s*combine_pat\s*>"#)]
2482        #[builder(default, setter(skip))]
2483        _start: (),
2484        context: ContextPattern,
2485        instr: InstructionPattern,
2486        #[rust_sitter::leaf(pattern = r#"<\s*/\s*combine_pat\s*>"#)]
2487        #[builder(default, setter(skip))]
2488        _end: (),
2489    }
2490
2491    #[derive(Debug, PartialEq)]
2492    pub enum DisjointPatternType {
2493        Instruction(InstructionPattern),
2494        Context(ContextPattern),
2495        Combine(CombinePattern),
2496    }
2497
2498    impl DecisionNodePair {
2499        // DEC
2500        const ID_REGEX: OnceCell<Regex> = OnceCell::new();
2501    }
2502
2503    #[derive(TypedBuilder, Debug, PartialEq)]
2504    pub struct DecisionNodePair {
2505        #[rust_sitter::leaf(pattern = r#"<\s*pair"#)]
2506        #[builder(default, setter(skip))]
2507        _start: (),
2508        #[rust_sitter::leaf(
2509            pattern = r#"id\s*=\s*"(-?[0-9]+)""#,
2510            transform = |v| {
2511                DecisionNodePair::ID_REGEX
2512                    .get_or_init(|| {
2513                        Regex::new(r#"id\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
2514                    })
2515                    .captures(v)
2516                    .expect("No captures or no capture group")
2517                    .get(1)
2518                    .expect("No capture group").as_str().parse().expect("Invalid integer")
2519            }
2520        )]
2521        #[builder(setter(transform = |v: impl Into<Integer>| {
2522            v.into()
2523        }))]
2524        id: Integer,
2525        #[rust_sitter::leaf(pattern = r#">"#)]
2526        #[builder(default, setter(skip))]
2527        _close: (),
2528        pattern: DisjointPatternType,
2529        #[rust_sitter::leaf(pattern = r#"<\s*/\s*pair\s*>"#)]
2530        #[builder(default, setter(skip))]
2531        _end: (),
2532    }
2533
2534    impl DecisionNode {
2535        // DEC
2536        const NUMBER_REGEX: OnceCell<Regex> = OnceCell::new();
2537        // BOOLEAN
2538        const CONTEXT_REGEX: OnceCell<Regex> = OnceCell::new();
2539        // DEC
2540        const START_REGEX: OnceCell<Regex> = OnceCell::new();
2541        // DEC
2542        const SIZE_REGEX: OnceCell<Regex> = OnceCell::new();
2543    }
2544
2545    #[derive(TypedBuilder, Debug, PartialEq)]
2546    pub struct DecisionNode {
2547        #[rust_sitter::leaf(pattern = r#"<\s*decision"#)]
2548        #[builder(default, setter(skip))]
2549        _start: (),
2550        #[rust_sitter::leaf(
2551            pattern = r#"number\s*=\s*"(-?[0-9]+)""#,
2552            transform = |v| {
2553                DecisionNode::NUMBER_REGEX
2554                    .get_or_init(|| {
2555                        Regex::new(r#"number\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
2556                    })
2557                    .captures(v)
2558                    .expect("No captures or no capture group").get(1).expect("No capture group").as_str().parse().expect("Invalid integer")
2559            }
2560        )]
2561        #[builder(setter(transform = |v: impl Into<Integer>| {
2562            v.into()
2563        }))]
2564        number: Integer,
2565        #[rust_sitter::leaf(
2566            pattern = r#"context\s*=\s*"([a-z]+)""#,
2567            transform = |v| {
2568                DecisionNode::CONTEXT_REGEX
2569                    .get_or_init(|| {
2570                        Regex::new(r#"context\s*=\s*"([a-z]+)""#).expect("Invalid regular expression")
2571                    })
2572                    .captures(v)
2573                    .expect("No captures or no capture group").get(1).expect("No capture group").as_str().parse().expect("Invalid boolean")
2574            }
2575        )]
2576        context: bool,
2577        #[rust_sitter::leaf(
2578            pattern = r#"start\s*=\s*"(-?[0-9]+)""#,
2579            transform = |v| {
2580                DecisionNode::START_REGEX
2581                    .get_or_init(|| {
2582                        Regex::new(r#"start\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
2583                    })
2584                    .captures(v)
2585                    .expect("No captures or no capture group").get(1).expect("No capture group").as_str().parse().expect("Invalid integer")
2586            }
2587        )]
2588        #[builder(setter(transform = |v: impl Into<Integer>| {
2589            v.into()
2590        }))]
2591        start: Integer,
2592        #[rust_sitter::leaf(
2593            pattern = r#"size\s*=\s*"(-?[0-9]+)""#,
2594            transform = |v| {
2595                DecisionNode::SIZE_REGEX
2596                    .get_or_init(|| {
2597                        Regex::new(r#"size\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
2598                    })
2599                    .captures(v)
2600                    .expect("No captures or no capture group").get(1).expect("No capture group").as_str().parse().expect("Invalid integer")
2601            }
2602        )]
2603        #[builder(setter(transform = |v: impl Into<Integer>| {
2604            v.into()
2605        }))]
2606        bitsize: Integer,
2607        #[rust_sitter::leaf(pattern = r#">"#)]
2608        #[builder(default, setter(skip))]
2609        _close: (),
2610        pairs: Vec<DecisionNodePair>,
2611        children: Vec<DecisionNode>,
2612        #[rust_sitter::leaf(pattern = r#"<\s*/\s*decision\s*>"#)]
2613        #[builder(default, setter(skip))]
2614        _end: (),
2615    }
2616
2617    impl SubtableSymbol {
2618        const NUMCT_REGEX: OnceCell<Regex> = OnceCell::new();
2619    }
2620
2621    #[derive(TypedBuilder, Debug, PartialEq)]
2622    pub struct SubtableSymbol {
2623        header: SymbolHeader,
2624        #[rust_sitter::leaf(
2625            pattern = r#"numct\s*=\s*"(-?[0-9]+)""#,
2626            transform = |v| {
2627                SubtableSymbol::NUMCT_REGEX
2628                    .get_or_init(|| {
2629                        Regex::new(r#"numct\s*=\s*"(-?[0-9]+)""#)
2630                            .expect("Invalid regular expression")
2631                    })
2632                    .captures(v)
2633                    .expect("No captures or no capture group")
2634                    .get(1)
2635                    .expect("No capture group").as_str().parse().expect("Invalid integer")
2636            }
2637        )]
2638        #[builder(setter(transform = |v: impl Into<Integer>| {
2639            v.into()
2640        }))]
2641        numct: Integer,
2642        #[rust_sitter::leaf(pattern = r#">"#)]
2643        #[builder(default, setter(skip))]
2644        _close: (),
2645        constructors: Vec<Constructor>,
2646        decisiontree: DecisionNode,
2647    }
2648
2649    impl ValueTableValue {
2650        // DEC
2651        const VAL_REGEX: OnceCell<Regex> = OnceCell::new();
2652    }
2653
2654    #[derive(TypedBuilder, Debug, PartialEq)]
2655    pub struct ValueTableValue {
2656        #[rust_sitter::leaf(pattern = r#"<\s*valuetab"#)]
2657        #[builder(default, setter(skip))]
2658        _start: (),
2659        #[rust_sitter::leaf(
2660            pattern = r#"val\s*=\s*"(-?[0-9]+)""#,
2661            transform = |v| {
2662                ValueTableValue::VAL_REGEX
2663                    .get_or_init(|| {
2664                        Regex::new(r#"val\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
2665                    })
2666                    .captures(v)
2667                    .expect("No captures or no capture group")
2668                    .get(1)
2669                    .expect("No capture group").as_str().parse().expect("Invalid integer")
2670            }
2671        )]
2672        #[builder(setter(transform = |v: impl Into<Integer>| {
2673            v.into()
2674        }))]
2675        val: Integer,
2676        #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
2677        #[builder(default, setter(skip))]
2678        _end: (),
2679    }
2680
2681    #[derive(TypedBuilder, Debug, PartialEq)]
2682    pub struct ValueMapSymbol {
2683        #[rust_sitter::leaf(pattern = r#"<\s*valuemap_sym"#)]
2684        #[builder(default, setter(skip))]
2685        _start: (),
2686        header: SymbolHeader,
2687        #[rust_sitter::leaf(pattern = r#">"#)]
2688        #[builder(default, setter(skip))]
2689        _close: (),
2690        patval: PatternValueType,
2691        valuetable: Vec<ValueTableValue>,
2692        #[rust_sitter::leaf(pattern = r#"<\s*/\s*valuemap_sym\s*>"#)]
2693        #[builder(default, setter(skip))]
2694        _end: (),
2695    }
2696
2697    impl NameTableValue {
2698        const NAME_REGEX: OnceCell<Regex> = OnceCell::new();
2699    }
2700
2701    #[derive(TypedBuilder, Debug, PartialEq)]
2702    pub struct NameTableValue {
2703        #[rust_sitter::leaf(pattern = r#"<\s*nametab"#)]
2704        #[builder(default, setter(skip))]
2705        _start: (),
2706        #[rust_sitter::leaf(
2707            pattern = r#"name\s*=\s*"([^"]*)""#,
2708            transform = |v| {
2709                NameTableValue::NAME_REGEX
2710                    .get_or_init(|| {
2711                        Regex::new(r#"name\s*=\s*"([^"]*)""#).expect("Invalid regular expression")
2712                    })
2713                    .captures(v)
2714                    .expect("No captures or no capture group")
2715                    .get(1)
2716                    .expect("No capture group")
2717                    .as_str()
2718                    .to_string()
2719                    .xml_unescape()
2720            }
2721        )]
2722        #[builder(setter(transform = |v: impl Into<String>| {
2723            Some(v.into())
2724        }))]
2725        name: Option<String>,
2726        #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
2727        #[builder(default, setter(skip))]
2728        _end: (),
2729    }
2730
2731    #[derive(TypedBuilder, Debug, PartialEq)]
2732    pub struct NameSymbol {
2733        #[rust_sitter::leaf(pattern = r#"<\s*name_sym"#)]
2734        #[builder(default, setter(skip))]
2735        _start: (),
2736        header: SymbolHeader,
2737        #[rust_sitter::leaf(pattern = r#">"#)]
2738        #[builder(default, setter(skip))]
2739        _close: (),
2740        patval: PatternValueType,
2741        nametable: Vec<NameTableValue>,
2742        #[rust_sitter::leaf(pattern = r#"<\s*/\s*name_sym\s*>"#)]
2743        #[builder(default, setter(skip))]
2744        _end: (),
2745    }
2746
2747    impl ContextSymbol {
2748        // HEX
2749        const VARNODE_REGEX: OnceCell<Regex> = OnceCell::new();
2750        // DEC
2751        const LOW_REGEX: OnceCell<Regex> = OnceCell::new();
2752        // DEC
2753        const HIGH_REGEX: OnceCell<Regex> = OnceCell::new();
2754        // BOOLEAN
2755        const FLOW_REGEX: OnceCell<Regex> = OnceCell::new();
2756    }
2757
2758    #[derive(TypedBuilder, Debug, PartialEq)]
2759    pub struct ContextSymbol {
2760        #[rust_sitter::leaf(pattern = r#"<\s*context_sym"#)]
2761        #[builder(default, setter(skip))]
2762        _start: (),
2763        header: SymbolHeader,
2764        #[rust_sitter::leaf(
2765            pattern = r#"varnode\s*=\s*"0x([0-9a-fA-F]+)""#,
2766            transform = |v| {
2767                Integer::from_string_base(16, ContextSymbol::VARNODE_REGEX
2768                    .get_or_init(|| {
2769                        Regex::new(r#"varnode\s*=\s*"0x([0-9a-fA-F]+)""#)
2770                            .expect("Invalid regular expression")
2771                    })
2772                    .captures(v)
2773                    .expect("No captures or no capture group")
2774                    .get(1)
2775                    .expect("No capture group").as_str()).expect("Invalid integer")
2776            }
2777        )]
2778        #[builder(setter(transform = |v: impl Into<Integer>| {
2779            v.into()
2780        }))]
2781        varnode: Integer,
2782        #[rust_sitter::leaf(
2783            pattern = r#"low\s*=\s*"(-?[0-9]+)""#,
2784            transform = |v| {
2785                ContextSymbol::LOW_REGEX
2786                    .get_or_init(|| {
2787                        Regex::new(r#"low\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
2788                    })
2789                    .captures(v)
2790                    .expect("No captures or no capture group")
2791                    .get(1)
2792                    .expect("No capture group").as_str().parse().expect("Invalid integer")
2793            }
2794        )]
2795        #[builder(setter(transform = |v: impl Into<Integer>| {
2796            v.into()
2797        }))]
2798        low: Integer,
2799        #[rust_sitter::leaf(
2800            pattern = r#"high\s*=\s*"(-?[0-9]+)""#,
2801            transform = |v| {
2802                ContextSymbol::HIGH_REGEX
2803                    .get_or_init(|| {
2804                        Regex::new(r#"high\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
2805                    })
2806                    .captures(v)
2807                    .expect("No captures or no capture group")
2808                    .get(1)
2809                    .expect("No capture group").as_str().parse().expect("Invalid integer")
2810            }
2811        )]
2812        #[builder(setter(transform = |v: impl Into<Integer>| {
2813            v.into()
2814        }))]
2815        high: Integer,
2816        #[rust_sitter::leaf(
2817            pattern = r#"flow\s*=\s*"([a-z]+)""#,
2818            transform = |v| {
2819                ContextSymbol::FLOW_REGEX
2820                    .get_or_init(|| {
2821                        Regex::new(r#"flow\s*=\s*"([a-z]+)""#).expect("Invalid regular expression")
2822                    })
2823                    .captures(v)
2824                    .expect("No captures or no capture group").get(1).expect("No capture group").as_str().parse().expect("Invalid boolean")
2825            }
2826        )]
2827        flow: bool,
2828        #[rust_sitter::leaf(pattern = r#">"#)]
2829        #[builder(default, setter(skip))]
2830        _close: (),
2831        patval: PatternValueType,
2832        #[rust_sitter::leaf(pattern = r#"<\s*/\s*context_sym\s*>"#)]
2833        #[builder(default, setter(skip))]
2834        _end: (),
2835    }
2836
2837    impl VarNodeTableValue {
2838        // HEX
2839        const ID_REGEX: OnceCell<Regex> = OnceCell::new();
2840    }
2841
2842    #[derive(TypedBuilder, Debug, PartialEq)]
2843    pub struct VarNodeTableValue {
2844        #[rust_sitter::leaf(pattern = r#"<\s*var"#)]
2845        #[builder(default, setter(skip))]
2846        _start: (),
2847        #[rust_sitter::leaf(
2848            pattern = r#"id\s*=\s*"0x([0-9a-fA-F]+)""#,
2849            transform = |v| {
2850                Integer::from_string_base(16, VarNodeTableValue::ID_REGEX
2851                    .get_or_init(|| {
2852                        Regex::new(r#"id\s*=\s*"0x([0-9a-fA-F]+)""#)
2853                            .expect("Invalid regular expression")
2854                    })
2855                    .captures(v)
2856                    .expect("No captures or no capture group")
2857                    .get(1)
2858                    .expect("No capture group").as_str()).expect("Invalid integer")
2859            }
2860        )]
2861        #[builder(setter(transform = |v: impl Into<Integer>| {
2862            v.into()
2863        }))]
2864        id: Integer,
2865        #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
2866        #[builder(default, setter(skip))]
2867        _end: (),
2868    }
2869
2870    #[derive(Debug, PartialEq)]
2871    pub enum VarNodeTableValueType {
2872        Null {
2873            #[rust_sitter::leaf(pattern = r#"<\s*null\s*/\s*>"#)]
2874            _null: (),
2875        },
2876        Value(VarNodeTableValue),
2877    }
2878
2879    #[derive(TypedBuilder, Debug, PartialEq)]
2880    pub struct VarNodeListSymbol {
2881        #[rust_sitter::leaf(pattern = r#"<\s*varlist_sym"#)]
2882        #[builder(default, setter(skip))]
2883        _start: (),
2884        header: SymbolHeader,
2885        #[rust_sitter::leaf(pattern = r#">"#)]
2886        #[builder(default, setter(skip))]
2887        _close: (),
2888        patval: PatternValueType,
2889        varnode_table: Vec<VarNodeTableValueType>,
2890        #[rust_sitter::leaf(pattern = r#"<\s*/\s*varlist_sym\s*>"#)]
2891        #[builder(default, setter(skip))]
2892        _end: (),
2893    }
2894
2895    #[derive(TypedBuilder, Debug, PartialEq)]
2896    pub struct ValueSymbol {
2897        #[rust_sitter::leaf(pattern = r#"<\s*value_sym"#)]
2898        #[builder(default, setter(skip))]
2899        _start: (),
2900        header: SymbolHeader,
2901        #[rust_sitter::leaf(pattern = r#">"#)]
2902        #[builder(default, setter(skip))]
2903        _close: (),
2904        patval: PatternValueType,
2905        #[rust_sitter::leaf(pattern = r#"<\s*/\s*value_sym\s*>"#)]
2906        #[builder(default, setter(skip))]
2907        _end: (),
2908    }
2909
2910    #[derive(Debug, PartialEq)]
2911    pub enum ValueSymbolType {
2912        ValueMapSymbol(ValueMapSymbol),
2913        NameSymbol(NameSymbol),
2914        ContextSymbol(ContextSymbol),
2915        VarNodeListSymbol(VarNodeListSymbol),
2916        ValueSymbol(ValueSymbol),
2917    }
2918
2919    #[derive(Debug, PartialEq)]
2920    pub enum FamilySymbol {
2921        ValueSymbol(ValueSymbolType),
2922    }
2923
2924    #[derive(TypedBuilder, Debug, PartialEq)]
2925    pub struct EpsilonSymbol {
2926        #[rust_sitter::leaf(pattern = r#"<\s*epsilon_sym"#)]
2927        #[builder(default, setter(skip))]
2928        _start: (),
2929        header: SymbolHeader,
2930        #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
2931        #[builder(default, setter(skip))]
2932        _end: (),
2933    }
2934
2935    impl VarNodeSymbol {
2936        // STRING
2937        const SPACE_REGEX: OnceCell<Regex> = OnceCell::new();
2938        // HEX
2939        const OFFSET_REGEX: OnceCell<Regex> = OnceCell::new();
2940        // DEC
2941        const SIZE_REGEX: OnceCell<Regex> = OnceCell::new();
2942    }
2943
2944    #[derive(TypedBuilder, Debug, PartialEq)]
2945    pub struct VarNodeSymbol {
2946        #[rust_sitter::leaf(pattern = r#"<\s*varnode_sym"#)]
2947        #[builder(default, setter(skip))]
2948        _start: (),
2949        header: SymbolHeader,
2950        #[rust_sitter::leaf(
2951            pattern = r#"space\s*=\s*"([^"]*)""#,
2952            transform = |v| {
2953                VarNodeSymbol::SPACE_REGEX
2954                    .get_or_init(|| {
2955                        Regex::new(r#"space\s*=\s*"([^"]*)""#).expect("Invalid regular expression")
2956                    })
2957                    .captures(v)
2958                    .expect("No captures or no capture group")
2959                    .get(1)
2960                    .expect("No capture group")
2961                    .as_str()
2962                    .to_string()
2963                    .xml_unescape()
2964            }
2965        )]
2966        space: String,
2967        #[rust_sitter::leaf(
2968            pattern = r#"offset\s*=\s*"0x([0-9a-fA-F]+)""#,
2969            transform = |v| {
2970                Integer::from_string_base(16, VarNodeSymbol::OFFSET_REGEX
2971                    .get_or_init(|| {
2972                        Regex::new(r#"offset\s*=\s*"0x([0-9a-fA-F]+)""#)
2973                            .expect("Invalid regular expression")
2974                    })
2975                    .captures(v)
2976                    .expect("No captures or no capture group")
2977                    .get(1)
2978                    .expect("No capture group").as_str()).expect("Invalid integer")
2979            }
2980        )]
2981        #[builder(setter(transform = |v: impl Into<Integer>| {
2982            v.into()
2983        }))]
2984        offset: Integer,
2985        #[rust_sitter::leaf(
2986            pattern = r#"size\s*=\s*"(-?[0-9]+)""#,
2987            transform = |v| {
2988                VarNodeSymbol::SIZE_REGEX
2989                    .get_or_init(|| {
2990                        Regex::new(r#"size\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
2991                    })
2992                    .captures(v)
2993                    .expect("No captures or no capture group")
2994                    .get(1)
2995                    .expect("No capture group").as_str().parse().expect("Invalid integer")
2996            }
2997        )]
2998        #[builder(setter(transform = |v: impl Into<Integer>| {
2999            v.into()
3000        }))]
3001        size: Integer,
3002        #[rust_sitter::leaf(pattern = r#">"#)]
3003        #[builder(default, setter(skip))]
3004        _close: (),
3005        #[rust_sitter::leaf(pattern = r#"<\s*/\s*varnode_sym\s*>"#)]
3006        #[builder(default, setter(skip))]
3007        _end: (),
3008    }
3009
3010    #[derive(Debug, PartialEq)]
3011    pub enum PatternlessSymbol {
3012        EpsilonSymbol(EpsilonSymbol),
3013        VarNodeSymbol(VarNodeSymbol),
3014    }
3015
3016    impl OperandSymbol {
3017        // HEX
3018        const SUBSYM_REGEX: OnceCell<Regex> = OnceCell::new();
3019        // DEC
3020        const OFF_REGEX: OnceCell<Regex> = OnceCell::new();
3021        // DEC
3022        const BASE_REGEX: OnceCell<Regex> = OnceCell::new();
3023        // DEC
3024        const MINLEN_REGEX: OnceCell<Regex> = OnceCell::new();
3025        // DEC
3026        const INDEX_REGEX: OnceCell<Regex> = OnceCell::new();
3027        // BOOLEAN
3028        const CODE_REGEX: OnceCell<Regex> = OnceCell::new();
3029    }
3030
3031    #[derive(TypedBuilder, Debug, PartialEq)]
3032    pub struct OperandSymbol {
3033        #[rust_sitter::leaf(pattern = r#"<\s*operand_sym"#)]
3034        #[builder(default, setter(skip))]
3035        _start: (),
3036        header: SymbolHeader,
3037        #[rust_sitter::leaf(
3038            pattern = r#"subsym\s*=\s*"0x([0-9a-fA-F]+)""#,
3039            transform = |v| {
3040                Integer::from_string_base(16, OperandSymbol::SUBSYM_REGEX
3041                    .get_or_init(|| {
3042                        Regex::new(r#"subsym\s*=\s*"0x([0-9a-fA-F]+)""#)
3043                            .expect("Invalid regular expression")
3044                    })
3045                    .captures(v)
3046                    .expect("No captures or no capture group")
3047                    .get(1)
3048                    .expect("No capture group").as_str()).expect("Invalid integer")
3049            }
3050        )]
3051        #[builder(setter(transform = |v: impl Into<Integer>| {
3052            Some(v.into())
3053        }))]
3054        subsym: Option<Integer>,
3055        #[rust_sitter::leaf(
3056            pattern = r#"off\s*=\s*"(-?[0-9]+)""#,
3057            transform = |v| {
3058                OperandSymbol::OFF_REGEX
3059                    .get_or_init(|| {
3060                        Regex::new(r#"off\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
3061                    })
3062                    .captures(v)
3063                    .expect("No captures or no capture group")
3064                    .get(1)
3065                    .expect("No capture group").as_str().parse().expect("Invalid integer")
3066            }
3067        )]
3068        #[builder(setter(transform = |v: impl Into<Integer>| {
3069            v.into()
3070        }))]
3071        off: Integer,
3072        #[rust_sitter::leaf(
3073            pattern = r#"base\s*=\s*"(-?[0-9]+)""#,
3074            transform = |v| {
3075                OperandSymbol::BASE_REGEX
3076                    .get_or_init(|| {
3077                        Regex::new(r#"base\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
3078                    })
3079                    .captures(v)
3080                    .expect("No captures or no capture group").get(1).expect("No capture group").as_str().parse().expect("Invalid integer")
3081            }
3082        )]
3083        #[builder(setter(transform = |v: impl Into<Integer>| {
3084            v.into()
3085        }))]
3086        base: Integer,
3087        #[rust_sitter::leaf(
3088            pattern = r#"minlen\s*=\s*"(-?[0-9]+)""#,
3089            transform = |v| {
3090                OperandSymbol::MINLEN_REGEX
3091                    .get_or_init(|| {
3092                        Regex::new(r#"minlen\s*=\s*"(-?[0-9]+)""#)
3093                            .expect("Invalid regular expression")
3094                    })
3095                    .captures(v)
3096                    .expect("No captures or no capture group").get(1).expect("No capture group").as_str().parse().expect("Invalid integer")
3097            }
3098        )]
3099        #[builder(setter(transform = |v: impl Into<Integer>| {
3100            v.into()
3101        }))]
3102        minlen: Integer,
3103        #[rust_sitter::leaf(
3104            pattern = r#"code\s*=\s*"([a-z]+)""#,
3105            transform = |v| {
3106                OperandSymbol::CODE_REGEX
3107                    .get_or_init(|| {
3108                        Regex::new(r#"code\s*=\s*"([a-z]+)""#).expect("Invalid regular expression")
3109                    })
3110                    .captures(v)
3111                    .expect("No captures or no capture group").get(1).expect("No capture group").as_str().parse().expect("Invalid boolean")
3112            }
3113        )]
3114        code: Option<bool>,
3115        #[rust_sitter::leaf(
3116            pattern = r#"index\s*=\s*"(-?[0-9]+)""#,
3117            transform = |v| {
3118                OperandSymbol::INDEX_REGEX
3119                    .get_or_init(|| {
3120                        Regex::new(r#"index\s*=\s*"(-?[0-9]+)""#).expect("Invalid regular expression")
3121                    })
3122                    .captures(v)
3123                    .expect("No captures or no capture group").get(1).expect("No capture group").as_str().parse().expect("Invalid integer")
3124            }
3125        )]
3126        #[builder(setter(transform = |v: impl Into<Integer>| {
3127            v.into()
3128        }))]
3129        index: Integer,
3130        #[rust_sitter::leaf(pattern = r#">"#)]
3131        #[builder(default, setter(skip))]
3132        _close: (),
3133        localexp: OperandValue,
3134        defexp: Option<PatternExpressionType>,
3135        #[rust_sitter::leaf(pattern = r#"<\s*/\s*operand_sym\s*>"#)]
3136        #[builder(default, setter(skip))]
3137        _end: (),
3138    }
3139
3140    #[derive(TypedBuilder, Debug, PartialEq)]
3141    pub struct StartSymbol {
3142        #[rust_sitter::leaf(pattern = r#"<\s*start_sym"#)]
3143        #[builder(default, setter(skip))]
3144        _start: (),
3145        header: SymbolHeader,
3146        #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
3147        #[builder(default, setter(skip))]
3148        _end: (),
3149    }
3150
3151    #[derive(TypedBuilder, Debug, PartialEq)]
3152    pub struct EndSymbol {
3153        #[rust_sitter::leaf(pattern = r#"<\s*end_sym"#)]
3154        #[builder(default, setter(skip))]
3155        _start: (),
3156        header: SymbolHeader,
3157        #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
3158        #[builder(default, setter(skip))]
3159        _end: (),
3160    }
3161
3162    #[derive(TypedBuilder, Debug, PartialEq)]
3163    pub struct Next2Symbol {
3164        #[rust_sitter::leaf(pattern = r#"<\s*next2_sym"#)]
3165        #[builder(default, setter(skip))]
3166        _start: (),
3167        header: SymbolHeader,
3168        #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
3169        #[builder(default, setter(skip))]
3170        _end: (),
3171    }
3172
3173    #[derive(TypedBuilder, Debug, PartialEq)]
3174    pub struct FlowDestSymbol {
3175        #[rust_sitter::leaf(pattern = r#"<\s*flowdest_sym"#)]
3176        #[builder(default, setter(skip))]
3177        _start: (),
3178        header: SymbolHeader,
3179        #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
3180        #[builder(default, setter(skip))]
3181        _end: (),
3182    }
3183
3184    #[derive(TypedBuilder, Debug, PartialEq)]
3185    pub struct FlowRefSymbol {
3186        #[rust_sitter::leaf(pattern = r#"<\s*flowref_sym"#)]
3187        #[builder(default, setter(skip))]
3188        _start: (),
3189        header: SymbolHeader,
3190        #[rust_sitter::leaf(pattern = r#"/\s*>"#)]
3191        #[builder(default, setter(skip))]
3192        _end: (),
3193    }
3194
3195    #[derive(Debug, PartialEq)]
3196    pub enum SpecificSymbol {
3197        PatternlessSymbol(PatternlessSymbol),
3198        OperandSymbol(OperandSymbol),
3199        StartSymbol(StartSymbol),
3200        EndSymbol(EndSymbol),
3201        Next2Symbol(Next2Symbol),
3202        FlowDestSymbol(FlowDestSymbol),
3203        FlowRefSymbol(FlowRefSymbol),
3204    }
3205
3206    #[derive(Debug, PartialEq)]
3207    pub enum TripleSymbol {
3208        FamilySymbol(FamilySymbol),
3209        SpecificSymbol(SpecificSymbol),
3210        SubtableSymbol {
3211            #[rust_sitter::leaf(pattern = r#"<\s*subtable_sym"#)]
3212            _start: (),
3213            subtable: SubtableSymbol,
3214            #[rust_sitter::leaf(pattern = r#"<\s*/\s*subtable_sym\s*>"#)]
3215            _end: (),
3216        },
3217    }
3218
3219    #[rust_sitter::extra]
3220    #[derive(Debug)]
3221    pub struct Whitespace {
3222        #[rust_sitter::leaf(pattern = r"\s")]
3223        _whitespace: (),
3224    }
3225}
3226
3227#[allow(non_upper_case_globals)]
3228#[cfg(test)]
3229mod test {
3230    use crate::parse;
3231
3232    #[test]
3233    fn test_6502() {
3234        const SLA_6502: &str = include_str!("../Processors/6502/data/languages/6502.sla");
3235        let slgh = parse(SLA_6502).expect("Failed to parse 6502 sla");
3236        println!("{slgh:#?}");
3237    }
3238    #[test]
3239    fn test_65c02() {
3240        const SLA_65c02: &str = include_str!("../Processors/6502/data/languages/65c02.sla");
3241        parse(SLA_65c02).expect("Failed to parse 65c02 sla");
3242    }
3243    #[test]
3244    fn test_68020() {
3245        const SLA_68020: &str = include_str!("../Processors/68000/data/languages/68020.sla");
3246        parse(SLA_68020).expect("Failed to parse 68020 sla");
3247    }
3248    #[test]
3249    fn test_68030() {
3250        const SLA_68030: &str = include_str!("../Processors/68000/data/languages/68030.sla");
3251        parse(SLA_68030).expect("Failed to parse 68030 sla");
3252    }
3253    #[test]
3254    fn test_68040() {
3255        const SLA_68040: &str = include_str!("../Processors/68000/data/languages/68040.sla");
3256        parse(SLA_68040).expect("Failed to parse 68040 sla");
3257    }
3258    #[test]
3259    fn test_coldfire() {
3260        const coldfire: &str = include_str!("../Processors/68000/data/languages/coldfire.sla");
3261        parse(coldfire).expect("Failed to parse coldfire sla");
3262    }
3263    #[test]
3264    fn test_8048() {
3265        const SLA_8048: &str = include_str!("../Processors/8048/data/languages/8048.sla");
3266        parse(SLA_8048).expect("Failed to parse 8048 sla");
3267    }
3268    #[test]
3269    fn test_80251() {
3270        const SLA_80251: &str = include_str!("../Processors/8051/data/languages/80251.sla");
3271        parse(SLA_80251).expect("Failed to parse 80251 sla");
3272    }
3273    #[test]
3274    fn test_80390() {
3275        const SLA_80390: &str = include_str!("../Processors/8051/data/languages/80390.sla");
3276        parse(SLA_80390).expect("Failed to parse 80390 sla");
3277    }
3278    #[test]
3279    fn test_8051() {
3280        const SLA_8051: &str = include_str!("../Processors/8051/data/languages/8051.sla");
3281        parse(SLA_8051).expect("Failed to parse 8051 sla");
3282    }
3283    #[test]
3284    fn test_mx51() {
3285        const mx51: &str = include_str!("../Processors/8051/data/languages/mx51.sla");
3286        parse(mx51).expect("Failed to parse mx51 sla");
3287    }
3288    #[test]
3289    fn test_8085() {
3290        const SLA_8085: &str = include_str!("../Processors/8085/data/languages/8085.sla");
3291        parse(SLA_8085).expect("Failed to parse 8085 sla");
3292    }
3293    #[test]
3294    fn test_AARCH64() {
3295        const AARCH64: &str = include_str!("../Processors/AARCH64/data/languages/AARCH64.sla");
3296        parse(AARCH64).expect("Failed to parse AARCH64 sla");
3297    }
3298    #[test]
3299    fn test_AARCH64BE() {
3300        const AARCH64BE: &str = include_str!("../Processors/AARCH64/data/languages/AARCH64BE.sla");
3301        parse(AARCH64BE).expect("Failed to parse AARCH64BE sla");
3302    }
3303    #[test]
3304    fn test_AARCH64_AppleSilicon() {
3305        const AARCH64_AppleSilicon: &str =
3306            include_str!("../Processors/AARCH64/data/languages/AARCH64_AppleSilicon.sla");
3307        parse(AARCH64_AppleSilicon).expect("Failed to parse AARCH64_AppleSilicon sla");
3308    }
3309    #[test]
3310    fn test_ARM4_be() {
3311        const ARM4_be: &str = include_str!("../Processors/ARM/data/languages/ARM4_be.sla");
3312        parse(ARM4_be).expect("Failed to parse ARM4_be sla");
3313    }
3314    #[test]
3315    fn test_ARM4_le() {
3316        const ARM4_le: &str = include_str!("../Processors/ARM/data/languages/ARM4_le.sla");
3317        parse(ARM4_le).expect("Failed to parse ARM4_le sla");
3318    }
3319    #[test]
3320    fn test_ARM4t_be() {
3321        const ARM4t_be: &str = include_str!("../Processors/ARM/data/languages/ARM4t_be.sla");
3322        parse(ARM4t_be).expect("Failed to parse ARM4t_be sla");
3323    }
3324    #[test]
3325    fn test_ARM4t_le() {
3326        const ARM4t_le: &str = include_str!("../Processors/ARM/data/languages/ARM4t_le.sla");
3327        parse(ARM4t_le).expect("Failed to parse ARM4t_le sla");
3328    }
3329    #[test]
3330    fn test_ARM5_be() {
3331        const ARM5_be: &str = include_str!("../Processors/ARM/data/languages/ARM5_be.sla");
3332        parse(ARM5_be).expect("Failed to parse ARM5_be sla");
3333    }
3334    #[test]
3335    fn test_ARM5_le() {
3336        const ARM5_le: &str = include_str!("../Processors/ARM/data/languages/ARM5_le.sla");
3337        parse(ARM5_le).expect("Failed to parse ARM5_le sla");
3338    }
3339    #[test]
3340    fn test_ARM5t_be() {
3341        const ARM5t_be: &str = include_str!("../Processors/ARM/data/languages/ARM5t_be.sla");
3342        parse(ARM5t_be).expect("Failed to parse ARM5t_be sla");
3343    }
3344    #[test]
3345    fn test_ARM5t_le() {
3346        const ARM5t_le: &str = include_str!("../Processors/ARM/data/languages/ARM5t_le.sla");
3347        parse(ARM5t_le).expect("Failed to parse ARM5t_le sla");
3348    }
3349    #[test]
3350    fn test_ARM6_be() {
3351        const ARM6_be: &str = include_str!("../Processors/ARM/data/languages/ARM6_be.sla");
3352        parse(ARM6_be).expect("Failed to parse ARM6_be sla");
3353    }
3354    #[test]
3355    fn test_ARM6_le() {
3356        const ARM6_le: &str = include_str!("../Processors/ARM/data/languages/ARM6_le.sla");
3357        parse(ARM6_le).expect("Failed to parse ARM6_le sla");
3358    }
3359    #[test]
3360    fn test_ARM7_be() {
3361        const ARM7_be: &str = include_str!("../Processors/ARM/data/languages/ARM7_be.sla");
3362        parse(ARM7_be).expect("Failed to parse ARM7_be sla");
3363    }
3364    #[test]
3365    fn test_ARM7_le() {
3366        const ARM7_le: &str = include_str!("../Processors/ARM/data/languages/ARM7_le.sla");
3367        parse(ARM7_le).expect("Failed to parse ARM7_le sla");
3368    }
3369    #[test]
3370    fn test_ARM8_be() {
3371        const ARM8_be: &str = include_str!("../Processors/ARM/data/languages/ARM8_be.sla");
3372        parse(ARM8_be).expect("Failed to parse ARM8_be sla");
3373    }
3374    #[test]
3375    fn test_ARM8_le() {
3376        const ARM8_le: &str = include_str!("../Processors/ARM/data/languages/ARM8_le.sla");
3377        parse(ARM8_le).expect("Failed to parse ARM8_le sla");
3378    }
3379    #[test]
3380    fn test_avr32a() {
3381        const avr32a: &str = include_str!("../Processors/Atmel/data/languages/avr32a.sla");
3382        parse(avr32a).expect("Failed to parse avr32a sla");
3383    }
3384    #[test]
3385    fn test_avr8() {
3386        const avr8: &str = include_str!("../Processors/Atmel/data/languages/avr8.sla");
3387        parse(avr8).expect("Failed to parse avr8 sla");
3388    }
3389    #[test]
3390    fn test_avr8e() {
3391        const avr8e: &str = include_str!("../Processors/Atmel/data/languages/avr8e.sla");
3392        parse(avr8e).expect("Failed to parse avr8e sla");
3393    }
3394    #[test]
3395    fn test_avr8eind() {
3396        const avr8eind: &str = include_str!("../Processors/Atmel/data/languages/avr8eind.sla");
3397        parse(avr8eind).expect("Failed to parse avr8eind sla");
3398    }
3399    #[test]
3400    fn test_avr8xmega() {
3401        const avr8xmega: &str = include_str!("../Processors/Atmel/data/languages/avr8xmega.sla");
3402        parse(avr8xmega).expect("Failed to parse avr8xmega sla");
3403    }
3404    #[test]
3405    fn test_BPF_le() {
3406        const BPF_le: &str = include_str!("../Processors/BPF/data/languages/BPF_le.sla");
3407        parse(BPF_le).expect("Failed to parse BPF_le sla");
3408    }
3409    #[test]
3410    fn test_CP1600() {
3411        const CP1600: &str = include_str!("../Processors/CP1600/data/languages/CP1600.sla");
3412        parse(CP1600).expect("Failed to parse CP1600 sla");
3413    }
3414    #[test]
3415    fn test_CR16B() {
3416        const CR16B: &str = include_str!("../Processors/CR16/data/languages/CR16B.sla");
3417        parse(CR16B).expect("Failed to parse CR16B sla");
3418    }
3419    #[test]
3420    fn test_CR16C() {
3421        const CR16C: &str = include_str!("../Processors/CR16/data/languages/CR16C.sla");
3422        parse(CR16C).expect("Failed to parse CR16C sla");
3423    }
3424    #[test]
3425    fn test_data_be_64() {
3426        const data_be_64: &str = include_str!("../Processors/DATA/data/languages/data-be-64.sla");
3427        parse(data_be_64).expect("Failed to parse data-be-64 sla");
3428    }
3429    #[test]
3430    fn test_data_le_64() {
3431        const data_le_64: &str = include_str!("../Processors/DATA/data/languages/data-le-64.sla");
3432        parse(data_le_64).expect("Failed to parse data-le-64 sla");
3433    }
3434    #[test]
3435    fn test_Dalvik_Base() {
3436        const Dalvik_Base: &str =
3437            include_str!("../Processors/Dalvik/data/languages/Dalvik_Base.sla");
3438        parse(Dalvik_Base).expect("Failed to parse Dalvik_Base sla");
3439    }
3440    #[test]
3441    fn test_Dalvik_DEX_Android10() {
3442        const Dalvik_DEX_Android10: &str =
3443            include_str!("../Processors/Dalvik/data/languages/Dalvik_DEX_Android10.sla");
3444        parse(Dalvik_DEX_Android10).expect("Failed to parse Dalvik_DEX_Android10 sla");
3445    }
3446    #[test]
3447    fn test_Dalvik_DEX_Android11() {
3448        const Dalvik_DEX_Android11: &str =
3449            include_str!("../Processors/Dalvik/data/languages/Dalvik_DEX_Android11.sla");
3450        parse(Dalvik_DEX_Android11).expect("Failed to parse Dalvik_DEX_Android11 sla");
3451    }
3452    #[test]
3453    fn test_Dalvik_DEX_Android12() {
3454        const Dalvik_DEX_Android12: &str =
3455            include_str!("../Processors/Dalvik/data/languages/Dalvik_DEX_Android12.sla");
3456        parse(Dalvik_DEX_Android12).expect("Failed to parse Dalvik_DEX_Android12 sla");
3457    }
3458    #[test]
3459    fn test_Dalvik_DEX_KitKat() {
3460        const Dalvik_DEX_KitKat: &str =
3461            include_str!("../Processors/Dalvik/data/languages/Dalvik_DEX_KitKat.sla");
3462        parse(Dalvik_DEX_KitKat).expect("Failed to parse Dalvik_DEX_KitKat sla");
3463    }
3464    #[test]
3465    fn test_Dalvik_DEX_Lollipop() {
3466        const Dalvik_DEX_Lollipop: &str =
3467            include_str!("../Processors/Dalvik/data/languages/Dalvik_DEX_Lollipop.sla");
3468        parse(Dalvik_DEX_Lollipop).expect("Failed to parse Dalvik_DEX_Lollipop sla");
3469    }
3470    #[test]
3471    fn test_Dalvik_DEX_Marshmallow() {
3472        const Dalvik_DEX_Marshmallow: &str =
3473            include_str!("../Processors/Dalvik/data/languages/Dalvik_DEX_Marshmallow.sla");
3474        parse(Dalvik_DEX_Marshmallow).expect("Failed to parse Dalvik_DEX_Marshmallow sla");
3475    }
3476    #[test]
3477    fn test_Dalvik_DEX_Nougat() {
3478        const Dalvik_DEX_Nougat: &str =
3479            include_str!("../Processors/Dalvik/data/languages/Dalvik_DEX_Nougat.sla");
3480        parse(Dalvik_DEX_Nougat).expect("Failed to parse Dalvik_DEX_Nougat sla");
3481    }
3482    #[test]
3483    fn test_Dalvik_DEX_Oreo() {
3484        const Dalvik_DEX_Oreo: &str =
3485            include_str!("../Processors/Dalvik/data/languages/Dalvik_DEX_Oreo.sla");
3486        parse(Dalvik_DEX_Oreo).expect("Failed to parse Dalvik_DEX_Oreo sla");
3487    }
3488    #[test]
3489    fn test_Dalvik_DEX_Pie() {
3490        const Dalvik_DEX_Pie: &str =
3491            include_str!("../Processors/Dalvik/data/languages/Dalvik_DEX_Pie.sla");
3492        parse(Dalvik_DEX_Pie).expect("Failed to parse Dalvik_DEX_Pie sla");
3493    }
3494    #[test]
3495    fn test_Dalvik_ODEX_KitKat() {
3496        const Dalvik_ODEX_KitKat: &str =
3497            include_str!("../Processors/Dalvik/data/languages/Dalvik_ODEX_KitKat.sla");
3498        parse(Dalvik_ODEX_KitKat).expect("Failed to parse Dalvik_ODEX_KitKat sla");
3499    }
3500    #[test]
3501    fn test_HC05() {
3502        const HC05: &str = include_str!("../Processors/HCS08/data/languages/HC05.sla");
3503        parse(HC05).expect("Failed to parse HC05 sla");
3504    }
3505    #[test]
3506    fn test_HC08() {
3507        const HC08: &str = include_str!("../Processors/HCS08/data/languages/HC08.sla");
3508        parse(HC08).expect("Failed to parse HC08 sla");
3509    }
3510    #[test]
3511    fn test_HCS08() {
3512        const HCS08: &str = include_str!("../Processors/HCS08/data/languages/HCS08.sla");
3513        parse(HCS08).expect("Failed to parse HCS08 sla");
3514    }
3515    #[test]
3516    fn test_HC12() {
3517        const HC12: &str = include_str!("../Processors/HCS12/data/languages/HC12.sla");
3518        parse(HC12).expect("Failed to parse HC12 sla");
3519    }
3520    #[test]
3521    fn test_HCS12() {
3522        const HCS12: &str = include_str!("../Processors/HCS12/data/languages/HCS12.sla");
3523        parse(HCS12).expect("Failed to parse HCS12 sla");
3524    }
3525    #[test]
3526    fn test_HCS12X() {
3527        const HCS12X: &str = include_str!("../Processors/HCS12/data/languages/HCS12X.sla");
3528        parse(HCS12X).expect("Failed to parse HCS12X sla");
3529    }
3530    #[test]
3531    fn test_JVM() {
3532        const JVM: &str = include_str!("../Processors/JVM/data/languages/JVM.sla");
3533        parse(JVM).expect("Failed to parse JVM sla");
3534    }
3535    #[test]
3536    fn test_m8c() {
3537        const m8c: &str = include_str!("../Processors/M8C/data/languages/m8c.sla");
3538        parse(m8c).expect("Failed to parse m8c sla");
3539    }
3540    #[test]
3541    fn test_6805() {
3542        const SLA_6805: &str = include_str!("../Processors/MC6800/data/languages/6805.sla");
3543        parse(SLA_6805).expect("Failed to parse 6805 sla");
3544    }
3545    #[test]
3546    fn test_6809() {
3547        const SLA_6809: &str = include_str!("../Processors/MC6800/data/languages/6809.sla");
3548        parse(SLA_6809).expect("Failed to parse 6809 sla");
3549    }
3550    #[test]
3551    fn test_H6309() {
3552        const H6309: &str = include_str!("../Processors/MC6800/data/languages/H6309.sla");
3553        parse(H6309).expect("Failed to parse H6309 sla");
3554    }
3555    #[test]
3556    fn test_MCS96() {
3557        const MCS96: &str = include_str!("../Processors/MCS96/data/languages/MCS96.sla");
3558        parse(MCS96).expect("Failed to parse MCS96 sla");
3559    }
3560    #[test]
3561    fn test_mips32R6be() {
3562        const mips32R6be: &str = include_str!("../Processors/MIPS/data/languages/mips32R6be.sla");
3563        parse(mips32R6be).expect("Failed to parse mips32R6be sla");
3564    }
3565    #[test]
3566    fn test_mips32R6le() {
3567        const mips32R6le: &str = include_str!("../Processors/MIPS/data/languages/mips32R6le.sla");
3568        parse(mips32R6le).expect("Failed to parse mips32R6le sla");
3569    }
3570    #[test]
3571    fn test_mips32be() {
3572        const mips32be: &str = include_str!("../Processors/MIPS/data/languages/mips32be.sla");
3573        parse(mips32be).expect("Failed to parse mips32be sla");
3574    }
3575    #[test]
3576    fn test_mips32le() {
3577        const mips32le: &str = include_str!("../Processors/MIPS/data/languages/mips32le.sla");
3578        parse(mips32le).expect("Failed to parse mips32le sla");
3579    }
3580    #[test]
3581    fn test_mips64be() {
3582        const mips64be: &str = include_str!("../Processors/MIPS/data/languages/mips64be.sla");
3583        parse(mips64be).expect("Failed to parse mips64be sla");
3584    }
3585    #[test]
3586    fn test_mips64le() {
3587        const mips64le: &str = include_str!("../Processors/MIPS/data/languages/mips64le.sla");
3588        parse(mips64le).expect("Failed to parse mips64le sla");
3589    }
3590    #[test]
3591    fn test_pa_risc32be() {
3592        const pa_risc32be: &str =
3593            include_str!("../Processors/PA-RISC/data/languages/pa-risc32be.sla");
3594        parse(pa_risc32be).expect("Failed to parse pa-risc32be sla");
3595    }
3596    #[test]
3597    fn test_PIC24E() {
3598        const PIC24E: &str = include_str!("../Processors/PIC/data/languages/PIC24E.sla");
3599        parse(PIC24E).expect("Failed to parse PIC24E sla");
3600    }
3601    #[test]
3602    fn test_PIC24F() {
3603        const PIC24F: &str = include_str!("../Processors/PIC/data/languages/PIC24F.sla");
3604        parse(PIC24F).expect("Failed to parse PIC24F sla");
3605    }
3606    #[test]
3607    fn test_PIC24H() {
3608        const PIC24H: &str = include_str!("../Processors/PIC/data/languages/PIC24H.sla");
3609        parse(PIC24H).expect("Failed to parse PIC24H sla");
3610    }
3611    #[test]
3612    fn test_dsPIC30F() {
3613        const dsPIC30F: &str = include_str!("../Processors/PIC/data/languages/dsPIC30F.sla");
3614        parse(dsPIC30F).expect("Failed to parse dsPIC30F sla");
3615    }
3616    #[test]
3617    fn test_dsPIC33C() {
3618        const dsPIC33C: &str = include_str!("../Processors/PIC/data/languages/dsPIC33C.sla");
3619        parse(dsPIC33C).expect("Failed to parse dsPIC33C sla");
3620    }
3621    #[test]
3622    fn test_dsPIC33E() {
3623        const dsPIC33E: &str = include_str!("../Processors/PIC/data/languages/dsPIC33E.sla");
3624        parse(dsPIC33E).expect("Failed to parse dsPIC33E sla");
3625    }
3626    #[test]
3627    fn test_dsPIC33F() {
3628        const dsPIC33F: &str = include_str!("../Processors/PIC/data/languages/dsPIC33F.sla");
3629        parse(dsPIC33F).expect("Failed to parse dsPIC33F sla");
3630    }
3631    #[test]
3632    fn test_pic12c5xx() {
3633        const pic12c5xx: &str = include_str!("../Processors/PIC/data/languages/pic12c5xx.sla");
3634        parse(pic12c5xx).expect("Failed to parse pic12c5xx sla");
3635    }
3636    #[test]
3637    fn test_pic16() {
3638        const pic16: &str = include_str!("../Processors/PIC/data/languages/pic16.sla");
3639        parse(pic16).expect("Failed to parse pic16 sla");
3640    }
3641    #[test]
3642    fn test_pic16c5x() {
3643        const pic16c5x: &str = include_str!("../Processors/PIC/data/languages/pic16c5x.sla");
3644        parse(pic16c5x).expect("Failed to parse pic16c5x sla");
3645    }
3646    #[test]
3647    fn test_pic16f() {
3648        const pic16f: &str = include_str!("../Processors/PIC/data/languages/pic16f.sla");
3649        parse(pic16f).expect("Failed to parse pic16f sla");
3650    }
3651    #[test]
3652    fn test_pic17c7xx() {
3653        const pic17c7xx: &str = include_str!("../Processors/PIC/data/languages/pic17c7xx.sla");
3654        parse(pic17c7xx).expect("Failed to parse pic17c7xx sla");
3655    }
3656    #[test]
3657    fn test_pic18() {
3658        const pic18: &str = include_str!("../Processors/PIC/data/languages/pic18.sla");
3659        parse(pic18).expect("Failed to parse pic18 sla");
3660    }
3661    #[test]
3662    fn test_ppc_32_4xx_be() {
3663        const ppc_32_4xx_be: &str =
3664            include_str!("../Processors/PowerPC/data/languages/ppc_32_4xx_be.sla");
3665        parse(ppc_32_4xx_be).expect("Failed to parse ppc_32_4xx_be sla");
3666    }
3667    #[test]
3668    fn test_ppc_32_4xx_le() {
3669        const ppc_32_4xx_le: &str =
3670            include_str!("../Processors/PowerPC/data/languages/ppc_32_4xx_le.sla");
3671        parse(ppc_32_4xx_le).expect("Failed to parse ppc_32_4xx_le sla");
3672    }
3673    #[test]
3674    fn test_ppc_32_be() {
3675        const ppc_32_be: &str = include_str!("../Processors/PowerPC/data/languages/ppc_32_be.sla");
3676        parse(ppc_32_be).expect("Failed to parse ppc_32_be sla");
3677    }
3678    #[test]
3679    fn test_ppc_32_e500_be() {
3680        const ppc_32_e500_be: &str =
3681            include_str!("../Processors/PowerPC/data/languages/ppc_32_e500_be.sla");
3682        parse(ppc_32_e500_be).expect("Failed to parse ppc_32_e500_be sla");
3683    }
3684    #[test]
3685    fn test_ppc_32_e500_le() {
3686        const ppc_32_e500_le: &str =
3687            include_str!("../Processors/PowerPC/data/languages/ppc_32_e500_le.sla");
3688        parse(ppc_32_e500_le).expect("Failed to parse ppc_32_e500_le sla");
3689    }
3690    #[test]
3691    fn test_ppc_32_le() {
3692        const ppc_32_le: &str = include_str!("../Processors/PowerPC/data/languages/ppc_32_le.sla");
3693        parse(ppc_32_le).expect("Failed to parse ppc_32_le sla");
3694    }
3695    #[test]
3696    fn test_ppc_32_quicciii_be() {
3697        const ppc_32_quicciii_be: &str =
3698            include_str!("../Processors/PowerPC/data/languages/ppc_32_quicciii_be.sla");
3699        parse(ppc_32_quicciii_be).expect("Failed to parse ppc_32_quicciii_be sla");
3700    }
3701    #[test]
3702    fn test_ppc_32_quicciii_le() {
3703        const ppc_32_quicciii_le: &str =
3704            include_str!("../Processors/PowerPC/data/languages/ppc_32_quicciii_le.sla");
3705        parse(ppc_32_quicciii_le).expect("Failed to parse ppc_32_quicciii_le sla");
3706    }
3707    #[test]
3708    fn test_ppc_64_be() {
3709        const ppc_64_be: &str = include_str!("../Processors/PowerPC/data/languages/ppc_64_be.sla");
3710        parse(ppc_64_be).expect("Failed to parse ppc_64_be sla");
3711    }
3712    #[test]
3713    fn test_ppc_64_isa_altivec_be() {
3714        const ppc_64_isa_altivec_be: &str =
3715            include_str!("../Processors/PowerPC/data/languages/ppc_64_isa_altivec_be.sla");
3716        parse(ppc_64_isa_altivec_be).expect("Failed to parse ppc_64_isa_altivec_be sla");
3717    }
3718    #[test]
3719    fn test_ppc_64_isa_altivec_le() {
3720        const ppc_64_isa_altivec_le: &str =
3721            include_str!("../Processors/PowerPC/data/languages/ppc_64_isa_altivec_le.sla");
3722        parse(ppc_64_isa_altivec_le).expect("Failed to parse ppc_64_isa_altivec_le sla");
3723    }
3724    #[test]
3725    fn test_ppc_64_isa_altivec_vle_be() {
3726        const ppc_64_isa_altivec_vle_be: &str =
3727            include_str!("../Processors/PowerPC/data/languages/ppc_64_isa_altivec_vle_be.sla");
3728        parse(ppc_64_isa_altivec_vle_be).expect("Failed to parse ppc_64_isa_altivec_vle_be sla");
3729    }
3730    #[test]
3731    fn test_ppc_64_isa_be() {
3732        const ppc_64_isa_be: &str =
3733            include_str!("../Processors/PowerPC/data/languages/ppc_64_isa_be.sla");
3734        parse(ppc_64_isa_be).expect("Failed to parse ppc_64_isa_be sla");
3735    }
3736    #[test]
3737    fn test_ppc_64_isa_le() {
3738        const ppc_64_isa_le: &str =
3739            include_str!("../Processors/PowerPC/data/languages/ppc_64_isa_le.sla");
3740        parse(ppc_64_isa_le).expect("Failed to parse ppc_64_isa_le sla");
3741    }
3742    #[test]
3743    fn test_ppc_64_isa_vle_be() {
3744        const ppc_64_isa_vle_be: &str =
3745            include_str!("../Processors/PowerPC/data/languages/ppc_64_isa_vle_be.sla");
3746        parse(ppc_64_isa_vle_be).expect("Failed to parse ppc_64_isa_vle_be sla");
3747    }
3748    #[test]
3749    fn test_ppc_64_le() {
3750        const ppc_64_le: &str = include_str!("../Processors/PowerPC/data/languages/ppc_64_le.sla");
3751        parse(ppc_64_le).expect("Failed to parse ppc_64_le sla");
3752    }
3753
3754    #[test]
3755    fn test_riscv_ilp32d() {
3756        const riscv_ilp32d: &str =
3757            include_str!("../Processors/RISCV/data/languages/riscv.ilp32d.sla");
3758        parse(riscv_ilp32d).expect("Failed to parse riscv_ilp32d sla");
3759    }
3760
3761    #[test]
3762    fn test_riscv_lp64d() {
3763        const riscv_lp64d: &str =
3764            include_str!("../Processors/RISCV/data/languages/riscv.lp64d.sla");
3765        parse(riscv_lp64d).expect("Failed to parse riscv_lp64d sla");
3766    }
3767
3768    #[test]
3769    fn test_SparcV9_32() {
3770        const SparcV9_32: &str = include_str!("../Processors/Sparc/data/languages/SparcV9_32.sla");
3771        parse(SparcV9_32).expect("Failed to parse SparcV9_32 sla");
3772    }
3773    #[test]
3774    fn test_SparcV9_64() {
3775        const SparcV9_64: &str = include_str!("../Processors/Sparc/data/languages/SparcV9_64.sla");
3776        parse(SparcV9_64).expect("Failed to parse SparcV9_64 sla");
3777    }
3778    #[test]
3779    fn test_sh_1() {
3780        const sh_1: &str = include_str!("../Processors/SuperH/data/languages/sh-1.sla");
3781        parse(sh_1).expect("Failed to parse sh-1 sla");
3782    }
3783    #[test]
3784    fn test_sh_2() {
3785        const sh_2: &str = include_str!("../Processors/SuperH/data/languages/sh-2.sla");
3786        parse(sh_2).expect("Failed to parse sh-2 sla");
3787    }
3788    #[test]
3789    fn test_sh_2a() {
3790        const sh_2a: &str = include_str!("../Processors/SuperH/data/languages/sh-2a.sla");
3791        parse(sh_2a).expect("Failed to parse sh-2a sla");
3792    }
3793    #[test]
3794    fn test_SuperH4_be() {
3795        const SuperH4_be: &str =
3796            include_str!("../Processors/SuperH4/data/languages/SuperH4_be.sla");
3797        parse(SuperH4_be).expect("Failed to parse SuperH4_be sla");
3798    }
3799    #[test]
3800    fn test_SuperH4_le() {
3801        const SuperH4_le: &str =
3802            include_str!("../Processors/SuperH4/data/languages/SuperH4_le.sla");
3803        parse(SuperH4_le).expect("Failed to parse SuperH4_le sla");
3804    }
3805    #[test]
3806    fn test_TI_MSP430() {
3807        const TI_MSP430: &str =
3808            include_str!("../Processors/TI_MSP430/data/languages/TI_MSP430.sla");
3809        parse(TI_MSP430).expect("Failed to parse TI_MSP430 sla");
3810    }
3811    #[test]
3812    fn test_TI_MSP430X() {
3813        const TI_MSP430X: &str =
3814            include_str!("../Processors/TI_MSP430/data/languages/TI_MSP430X.sla");
3815        parse(TI_MSP430X).expect("Failed to parse TI_MSP430X sla");
3816    }
3817    #[test]
3818    fn test_toy64_be() {
3819        const toy64_be: &str = include_str!("../Processors/Toy/data/languages/toy64_be.sla");
3820        parse(toy64_be).expect("Failed to parse toy64_be sla");
3821    }
3822    #[test]
3823    fn test_toy64_be_harvard() {
3824        const toy64_be_harvard: &str =
3825            include_str!("../Processors/Toy/data/languages/toy64_be_harvard.sla");
3826        parse(toy64_be_harvard).expect("Failed to parse toy64_be_harvard sla");
3827    }
3828    #[test]
3829    fn test_toy64_le() {
3830        const toy64_le: &str = include_str!("../Processors/Toy/data/languages/toy64_le.sla");
3831        parse(toy64_le).expect("Failed to parse toy64_le sla");
3832    }
3833    #[test]
3834    fn test_toy_be() {
3835        const toy_be: &str = include_str!("../Processors/Toy/data/languages/toy_be.sla");
3836        parse(toy_be).expect("Failed to parse toy_be sla");
3837    }
3838    #[test]
3839    fn test_toy_be_posStack() {
3840        const toy_be_posStack: &str =
3841            include_str!("../Processors/Toy/data/languages/toy_be_posStack.sla");
3842        parse(toy_be_posStack).expect("Failed to parse toy_be_posStack sla");
3843    }
3844    #[test]
3845    fn test_toy_builder_be() {
3846        const toy_builder_be: &str =
3847            include_str!("../Processors/Toy/data/languages/toy_builder_be.sla");
3848        parse(toy_builder_be).expect("Failed to parse toy_builder_be sla");
3849    }
3850    #[test]
3851    fn test_toy_builder_be_align2() {
3852        const toy_builder_be_align2: &str =
3853            include_str!("../Processors/Toy/data/languages/toy_builder_be_align2.sla");
3854        parse(toy_builder_be_align2).expect("Failed to parse toy_builder_be_align2 sla");
3855    }
3856    #[test]
3857    fn test_toy_builder_le() {
3858        const toy_builder_le: &str =
3859            include_str!("../Processors/Toy/data/languages/toy_builder_le.sla");
3860        parse(toy_builder_le).expect("Failed to parse toy_builder_le sla");
3861    }
3862    #[test]
3863    fn test_toy_builder_le_align2() {
3864        const toy_builder_le_align2: &str =
3865            include_str!("../Processors/Toy/data/languages/toy_builder_le_align2.sla");
3866        parse(toy_builder_le_align2).expect("Failed to parse toy_builder_le_align2 sla");
3867    }
3868    #[test]
3869    fn test_toy_le() {
3870        const toy_le: &str = include_str!("../Processors/Toy/data/languages/toy_le.sla");
3871        parse(toy_le).expect("Failed to parse toy_le sla");
3872    }
3873    #[test]
3874    fn test_toy_wsz_be() {
3875        const toy_wsz_be: &str = include_str!("../Processors/Toy/data/languages/toy_wsz_be.sla");
3876        parse(toy_wsz_be).expect("Failed to parse toy_wsz_be sla");
3877    }
3878    #[test]
3879    fn test_toy_wsz_le() {
3880        const toy_wsz_le: &str = include_str!("../Processors/Toy/data/languages/toy_wsz_le.sla");
3881        parse(toy_wsz_le).expect("Failed to parse toy_wsz_le sla");
3882    }
3883    #[test]
3884    fn test_V850() {
3885        const V850: &str = include_str!("../Processors/V850/data/languages/V850.sla");
3886        parse(V850).expect("Failed to parse V850 sla");
3887    }
3888    #[test]
3889    fn test_z180() {
3890        const z180: &str = include_str!("../Processors/Z80/data/languages/z180.sla");
3891        parse(z180).expect("Failed to parse z180 sla");
3892    }
3893    #[test]
3894    fn test_z80() {
3895        const z80: &str = include_str!("../Processors/Z80/data/languages/z80.sla");
3896        parse(z80).expect("Failed to parse z80 sla");
3897    }
3898    #[test]
3899    fn test_eBPF_le() {
3900        const E_BPF_LE: &str = include_str!("../Processors/eBPF/data/languages/eBPF_le.sla");
3901        parse(E_BPF_LE).expect("Failed to parse eBPF_le sla");
3902    }
3903    #[test]
3904    fn test_tricore() {
3905        const TRICORE: &str = include_str!("../Processors/tricore/data/languages/tricore.sla");
3906        parse(TRICORE).expect("Failed to parse tricore sla");
3907    }
3908    #[test]
3909    fn test_x86_64() {
3910        const x86_64: &str = include_str!("../Processors/x86/data/languages/x86-64.sla");
3911        let parsed = parse(x86_64).expect("Failed to parse x86-64 sla");
3912        println!("{:#?}", parsed);
3913    }
3914    #[test]
3915    fn test_x86() {
3916        const X86: &str = include_str!("../Processors/x86/data/languages/x86.sla");
3917        parse(X86).expect("Failed to parse x86 sla");
3918    }
3919}
tree_sitter_sleigh/lib.rs

tree_sitter_sleigh/
lib.rs
