Skip to main content

dbt_antlr_runtime/
lib.rs

1#![crate_type = "lib"]
2// #![warn(missing_docs)] // warn if there is missing docs
3// #![warn(missing_debug_implementations)]
4// #![warn(trivial_numeric_casts)]
5
6//! # dbt-antlr-runtime runtime
7//!
8//! This is a Rust runtime for [ANTLR4] parser generator.
9//! It is required to use parsers and lexers generated by [ANTLR4] parser generator
10//!
11//! This documentation refers to particular api used by generated parsers,lexers and syntax trees.
12//!
13//! For info on what is [ANTLR4] and how to generate parser please refer to:
14//!  - [ANTLR4] main repository
15//!  - [README] for Rust target
16//!
17//! [ANTLR4]: https://github.com/antlr/antlr4
18//! [README]: https://github.com/sdf-labs/antlr4/blob/dev/runtime/Rust/README.md
19//!
20//! Documentation for this crate is still a work in progress, but you can find
21//! some docs in the source code, and also refer to the Java runtime
22//! documentation for general concepts and architecture of the runtime, as well
23//! as for documentation of internal modules that are not yet documented in
24//! Rust.
25//!
26//! [`CharStream`]: crate::char_stream::CharStream
27//! [`TokenFactory`]: crate::token_factory::TokenFactory
28//! [`Token`]: crate::token::Token
29//! [`TokenStream`]: crate::token_stream::TokenStream
30//! [`ParserRuleContext`]: crate::parser_rule_context::ParserRuleContext
31
32#[doc(inline)]
33pub use error_strategy::{BailErrorStrategy, DefaultErrorStrategy, ErrorStrategy};
34
35pub use input_stream::InputStream;
36
37#[doc(inline)]
38pub use lexer::{BaseLexer, Lexer};
39#[doc(inline)]
40pub use parser::{BaseParser, ListenerId, Parser};
41#[doc(inline)]
42pub use token_source::TokenSource;
43//extern crate uuid;
44#[doc(hidden)]
45pub use prediction_context::PredictionContextCache;
46
47#[doc(inline)]
48pub use prediction_mode::PredictionMode;
49
50#[doc(inline)]
51pub use arena::Arena;
52#[cfg(feature = "arena-allocation-limit")]
53#[doc(inline)]
54pub use arena::{get_default_arena_alloc_limit, set_default_arena_alloc_limit};
55
56mod arena;
57#[doc(hidden)]
58pub mod atn_config;
59#[doc(hidden)]
60pub mod atn_simulator;
61pub mod int_stream;
62mod lexer_action;
63mod ll1_analyzer;
64#[doc(hidden)]
65pub mod recognizer;
66pub mod token_factory;
67//pub mod tokenstream_rewriter;
68#[doc(hidden)]
69pub mod atn_deserialization_options;
70#[doc(hidden)]
71pub mod atn_state;
72pub mod char_stream;
73#[doc(hidden)]
74pub mod interval_set;
75pub mod parser_rule_context;
76mod prediction_context;
77#[doc(hidden)]
78pub mod semantic_context;
79mod token_source;
80pub mod token_stream;
81//pub mod trace_listener;
82#[doc(hidden)]
83pub mod dfa;
84#[doc(hidden)]
85pub mod transition;
86pub mod tree;
87//pub mod file_stream;
88#[doc(hidden)]
89pub mod atn;
90#[doc(hidden)]
91pub mod atn_config_set;
92#[doc(hidden)]
93pub mod atn_deserializer;
94#[cfg(feature = "atn-dump")]
95#[doc(hidden)]
96pub mod atn_dump;
97#[doc(hidden)]
98pub mod atn_packed_deserializer;
99pub mod common_token_stream;
100pub mod error_listener;
101pub mod error_strategy;
102pub mod errors;
103pub mod input_stream;
104pub mod interpreter_rule_context;
105pub mod lexer;
106#[doc(hidden)]
107pub mod lexer_action_executor;
108pub mod lexer_atn_simulator;
109pub mod lexer_interpreter;
110pub mod parser;
111pub mod parser_atn_simulator;
112pub mod parser_interpreter;
113mod prediction_mode;
114pub mod token;
115pub mod trees;
116mod utils;
117//pub mod tokenstream_rewriter_test;
118mod atn_type;
119// mod context_factory;
120pub mod rule_context;
121pub mod vocabulary;
122
123// ======= Re-exports ========
124#[cfg(feature = "stacker")]
125pub use stacker;
126
127pub const VERSION_MAJOR: &str = env!("CARGO_PKG_VERSION_MAJOR");
128pub const VERSION_MINOR: &str = env!("CARGO_PKG_VERSION_MINOR");
129
130// ======= Macros =======
131
132pub const fn version_str_eq(a: &str, b: &str) -> bool {
133    if a.len() != b.len() {
134        return false;
135    }
136    let (a, b) = (a.as_bytes(), b.as_bytes());
137    let mut i = 0;
138    while i < a.len() {
139        if a[i] != b[i] {
140            return false;
141        }
142        i += 1;
143    }
144    true
145}
146/// Parses a numeric version component (e.g. `"13"`) in const context.
147///
148/// Public only so [`check_version!`] can reference it from downstream crates.
149#[doc(hidden)]
150pub const fn version_str_to_u64(s: &str) -> u64 {
151    let bytes = s.as_bytes();
152    let mut n: u64 = 0;
153    let mut i = 0;
154    while i < bytes.len() {
155        let b = bytes[i];
156        assert!(b >= b'0' && b <= b'9', "version component is not numeric");
157        n = n * 10 + (b - b'0') as u64;
158        i += 1;
159    }
160    n
161}
162
163/// Compile-time compatibility gate between generated code and the runtime.
164///
165/// Generated parsers embed `check_version!("<major>", "<minor>")` naming the
166/// runtime version the generating tool was built against. The check passes
167/// when the linked runtime has the same major version and a minor version
168/// greater than or equal to the generated one: additive runtime releases never
169/// break previously generated code, while a runtime older than the generator
170/// (or a different major) fails to compile with a clear message.
171#[macro_export]
172macro_rules! check_version {
173    ($major:literal, $minor:literal) => {
174        const _: () = assert!(
175            $crate::version_str_eq($major, $crate::VERSION_MAJOR)
176                && $crate::version_str_to_u64($crate::VERSION_MINOR)
177                    >= $crate::version_str_to_u64($minor),
178            "Generated parser is not compatible with the current runtime version: \
179             it requires the same major version of dbt-antlr-runtime and at least \
180             the minor version used at generation time. Update the runtime \
181             dependency, or regenerate using an older ANTLR tool version."
182        );
183    };
184}
185#[macro_export]
186macro_rules! impl_tree {
187    // Pattern: EnumName { Variant1, Variant2, ... }
188    ($enum_name:ident { $($variant:ident,)+ }) => {
189        impl<'input, 'arena> Tree<'arena> for $enum_name<'input, 'arena> {
190            fn get_parent(&self) -> Option<&'arena Self> {
191                match self {
192                    $( $enum_name::$variant(inner) => inner.get_parent(), )+
193                    _ => None,
194                }
195            }
196
197            fn has_parent(&self) -> bool {
198                match self {
199                    $( $enum_name::$variant(inner) => inner.has_parent(), )+
200                    _ => false,
201                }
202            }
203
204            // fn get_payload(&self) -> Box<dyn std::any::Any> {
205            //     match self {
206            //         $( $enum_name::$variant(inner) => Tree::get_payload(inner), )+
207            //     }
208            // }
209
210            fn get_child(&self, i: usize) -> Option<&'arena Self> {
211                match self {
212                    $( $enum_name::$variant(inner) => inner.get_child(i), )+
213                    _ => None,
214                }
215            }
216
217            fn get_child_count(&self) -> usize {
218                match self {
219                    $( $enum_name::$variant(inner) => inner.get_child_count(), )+
220                    _ => 0,
221                }
222            }
223
224            fn get_children<'a>(&'a self) -> Box<dyn Iterator<Item = &'arena Self> + 'a> {
225                match self {
226                    $( $enum_name::$variant(inner) => inner.get_children(), )+
227                    _ => Box::new(std::iter::empty()) as Box<dyn Iterator<Item = &'arena Self>>,
228                }
229            }
230
231            // fn to_string_tree(&self) -> String {
232            //     match self {
233            //         $( $enum_name::$variant(inner) => Tree::to_string_tree(inner), )+
234            //     }
235            // }
236        }
237    };
238}
239
240#[macro_export]
241macro_rules! impl_node_kind_common {
242    // Pattern: EnumName { Variant1, Variant2, ... }
243    ($node_kind:ident { $($labeled_variant:ident($inner:ident),)* ; $($variant:ident),* }) => {
244        fn cast_to_ctx<'n, 'input: 'arena>(
245            node: &'n TreeNode<'input, 'arena, Self, Tok>,
246        ) -> &'n dyn ParserRuleContext<'input, 'arena> {
247            match node.node_tag() {
248                $( $node_kind::$labeled_variant => $crate::cast_unchecked!(node => $inner<'input, 'arena, Tok>), )*
249                $( $node_kind::$variant => $crate::cast_unchecked!(node.ctx_ptr() => $variant<'input, 'arena, Tok>), )*
250                $node_kind::Terminal => $crate::cast_unchecked!(node.ctx_ptr() => TerminalNode<'input, 'arena, Tok>),
251                $node_kind::Error => $crate::cast_unchecked!(node.ctx_ptr() => ErrorNode<'input, 'arena, Tok>),
252            }
253        }
254
255        fn cast_to_ctx_mut<'n, 'input: 'arena>(
256            node: &'n mut TreeNode<'input, 'arena, Self, Tok>,
257        ) -> &'n mut dyn ParserRuleContext<'input, 'arena> {
258            match node.node_tag() {
259                $( $node_kind::$labeled_variant => $crate::cast_unchecked!(node => mut $inner<'input, 'arena, Tok>), )*
260                $( $node_kind::$variant => $crate::cast_unchecked!(node.ctx_ptr() => mut $variant<'input, 'arena, Tok>), )*
261                $node_kind::Terminal => $crate::cast_unchecked!(node.ctx_ptr() => mut TerminalNode<'input, 'arena, Tok>),
262                $node_kind::Error => $crate::cast_unchecked!(node.ctx_ptr() => mut ErrorNode<'input, 'arena, Tok>),
263            }
264        }
265
266        fn set_alt_number<'input: 'arena>(node: &mut TreeNode<'input, 'arena, Self, Tok>, alt_number: i32) {
267            match node.node_tag() {
268                $( $node_kind::$labeled_variant => $crate::cast_unchecked!(node => mut $inner<'input, 'arena, Tok>).set_alt_number(alt_number), )*
269                $( $node_kind::$variant => $crate::cast_unchecked!(node.ctx_ptr() => mut $variant<'input, 'arena, Tok>).set_alt_number(alt_number), )*
270                _ => {}
271            }
272        }
273
274        fn get_rule_index<'input: 'arena>(node: &TreeNode<'input, 'arena, Self, Tok>) -> usize {
275            match node.node_tag() {
276                $( $node_kind::$labeled_variant => $crate::cast_unchecked!(node => $inner<'input, 'arena, Tok>).get_rule_index(), )*
277                $( $node_kind::$variant => $crate::cast_unchecked!(node.ctx_ptr() => $variant<'input, 'arena, Tok>).get_rule_index(), )*
278                _ => 0,
279            }
280        }
281
282        fn get_alt_number<'input: 'arena>(node: &TreeNode<'input, 'arena, Self, Tok>) -> i32 {
283            match node.node_tag() {
284                $( $node_kind::$labeled_variant => $crate::cast_unchecked!(node => $inner<'input, 'arena, Tok>).get_alt_number(), )*
285                $( $node_kind::$variant => $crate::cast_unchecked!(node.ctx_ptr() => $variant<'input, 'arena, Tok>).get_alt_number(), )*
286                _ => INVALID_ALT,
287            }
288        }
289
290        #[inline]
291        fn terminal() -> Self {
292            Self::Terminal
293        }
294
295        #[inline]
296        fn error() -> Self {
297            Self::Error
298        }
299
300        #[inline]
301        fn is_context(&self) -> bool {
302            !matches!(self, Self::Terminal | Self::Error)
303        }
304    };
305}
306
307#[macro_export]
308macro_rules! impl_node_kind {
309    // No Listener and no Visitor
310    ($enum_name:ident { $($labeled_variant:ident($inner:ident),)* ; $($variant:ident),* }; ) => {
311        impl<'arena, Tok: Token + 'arena> NodeKindType<'arena, Tok> for $enum_name {
312            type Listener = dyn ParseTreeListener<'arena, Self, Tok>;
313
314            $crate::impl_node_kind_common! { $enum_name { $($labeled_variant($inner),)* ; $($variant),* } }
315
316            fn enter_rule<'input: 'arena>(_node: &TreeNode<'input, 'arena, Self, Tok>, _listener: &mut Self::Listener) -> Result<(), ANTLRError> {
317                Ok(())
318            }
319
320            fn exit_rule<'input: 'arena>(_node: &TreeNode<'input, 'arena, Self, Tok>, _listener: &mut Self::Listener) -> Result<(), ANTLRError> {
321                Ok(())
322            }
323        }
324    };
325
326    // Just Visitor
327    ($enum_name:ident { $($labeled_variant:ident($inner:ident),)*; $($variant:ident($visit_method:ident),)* }; visitor = $visitor:ty, ) => {
328        impl<'arena, Tok: Token + 'arena> NodeKindType<'arena, Tok> for $enum_name {
329            type Listener = dyn ParseTreeListener<'arena, Self, Tok>;
330
331            $crate::impl_node_kind_common! { $enum_name { $( $labeled_variant($inner),)*; $($variant),* } }
332
333            fn enter_rule(_node: &TreeNode<'input, 'arena, Self, Tok>, _listener: &mut Self::Listener) -> Result<(), ANTLRError> {
334                Ok(())
335            }
336
337            fn exit_rule(_node: &TreeNode<'input, 'arena, Self, Tok>, _listener: &mut Self::Listener) -> Result<(), ANTLRError> {
338                Ok(())
339            }
340
341            // fn accept(&self, visitor: &mut Self::Visitor) -> Result<<Self::Visitor as ParseTreeVisitor<'input, 'arena, Self>>::Return, ANTLRError>
342            // {
343            //     match self {
344            //         $( $enum_name::$labeled_variant(inner) => inner.dispatch_visit(visitor), )*
345            //         $( $enum_name::$variant(inner) => visitor.$visit_method(inner), )*
346            //         $enum_name::Terminal(inner) => { visitor.visit_terminal(inner) },
347            //         $enum_name::Error(inner) => { visitor.visit_error_node(inner) },
348            //     }
349            // }
350        }
351    };
352
353    // Just Listener
354    ($enum_name:ident { $($labeled_variant:ident($inner:ident),)*; $($variant:ident($enter_method:ident, $exit_method:ident, ),)* }; listener = $listener:ty, ) => {
355        impl<'arena, Tok: Token + 'arena> NodeKindType<'arena, Tok> for $enum_name {
356            type Listener = $listener;
357
358            $crate::impl_node_kind_common! { $enum_name { $( $labeled_variant($inner),)*; $($variant),* } }
359
360            fn enter_rule<'input: 'arena>(node: &TreeNode<'input, 'arena, Self, Tok>, listener: &mut Self::Listener) -> Result<(), ANTLRError> {
361                match node.node_tag() {
362                    $( $enum_name::$labeled_variant => $crate::cast_unchecked!(node => $inner<'input, 'arena, Tok>).dispatch_enter(listener), )*
363                    $( $enum_name::$variant => listener.$enter_method($crate::cast_unchecked!(node.ctx_ptr() => $variant<'input, 'arena, Tok>)), )*
364                    $enum_name::Terminal => { listener.visit_terminal($crate::cast_unchecked!(node.ctx_ptr() => TerminalNode<'input, 'arena, Tok>)) },
365                    $enum_name::Error => { listener.visit_error_node($crate::cast_unchecked!(node.ctx_ptr() => ErrorNode<'input, 'arena, Tok>)) },
366                }
367            }
368
369            fn exit_rule<'input: 'arena>(node: &TreeNode<'input, 'arena, Self, Tok>, listener: &mut Self::Listener) -> Result<(), ANTLRError> {
370                match node.node_tag() {
371                    $( $enum_name::$labeled_variant => $crate::cast_unchecked!(node => $inner<'input, 'arena, Tok>).dispatch_exit(listener), )*
372                    $( $enum_name::$variant => listener.$exit_method($crate::cast_unchecked!(node.ctx_ptr() => $variant<'input, 'arena, Tok>)), )*
373                    $enum_name::Terminal => { listener.visit_terminal($crate::cast_unchecked!(node.ctx_ptr() => TerminalNode<'input, 'arena, Tok>)) },
374                    $enum_name::Error => { listener.visit_error_node($crate::cast_unchecked!(node.ctx_ptr() => ErrorNode<'input, 'arena, Tok>)) },
375                }
376            }
377        }
378    };
379
380    // Both listener and visitor
381    ($enum_name:ident { $($labeled_variant:ident($inner:ident),)*; $($variant:ident($enter_method:ident, $exit_method:ident, $visit_method:ident),)* }; listener = $listener:ty, visitor = $visitor:ident, ) => {
382        impl<'arena, Tok: Token + 'arena> NodeKindType<'arena, Tok> for $enum_name {
383            type Listener = $listener;
384
385            $crate::impl_node_kind_common! { $enum_name { $($labeled_variant($inner),)*; $($variant),* } }
386
387            fn enter_rule<'input: 'arena>(node: &TreeNode<'input, 'arena, Self, Tok>, listener: &mut Self::Listener) -> Result<(), ANTLRError> {
388                match node.node_tag() {
389                    $( $enum_name::$labeled_variant => $crate::cast_unchecked!(node => $inner<'input, 'arena, Tok>).dispatch_enter(listener), )*
390                    $( $enum_name::$variant => listener.$enter_method($crate::cast_unchecked!(node.ctx_ptr() => $variant<'input, 'arena, Tok>)), )*
391                    $enum_name::Terminal => { listener.visit_terminal($crate::cast_unchecked!(node.ctx_ptr() => TerminalNode<'input, 'arena, Tok>)) },
392                    $enum_name::Error => { listener.visit_error_node($crate::cast_unchecked!(node.ctx_ptr() => ErrorNode<'input, 'arena, Tok>)) },
393                }
394            }
395
396            fn exit_rule<'input: 'arena>(node: &TreeNode<'input, 'arena, Self, Tok>, listener: &mut Self::Listener) -> Result<(), ANTLRError> {
397                match node.node_tag() {
398                    $( $enum_name::$labeled_variant => $crate::cast_unchecked!(node => $inner<'input, 'arena, Tok>).dispatch_exit(listener), )*
399                    $( $enum_name::$variant => listener.$exit_method($crate::cast_unchecked!(node.ctx_ptr() => $variant<'input, 'arena, Tok>)), )*
400                    $enum_name::Terminal => { listener.visit_terminal($crate::cast_unchecked!(node.ctx_ptr() => TerminalNode<'input, 'arena, Tok>)) },
401                    $enum_name::Error => { listener.visit_error_node($crate::cast_unchecked!(node.ctx_ptr() => ErrorNode<'input, 'arena, Tok>)) },
402                }
403            }
404        }
405
406        impl<'input, 'arena, Tok: Token + 'arena> Visitable<'input, 'arena, Tok> for TreeNode<'input, 'arena, $enum_name, Tok>
407        where
408            'input: 'arena,
409        {
410            fn accept<V>(&'arena self, visitor: &mut V) -> Result<V::Return, ANTLRError>
411            where
412                V: $visitor<'input, 'arena, Tok> + ?Sized,
413            {
414                match self.node_tag() {
415                    $( $enum_name::$labeled_variant => $crate::cast_unchecked!(self => $inner<'input, 'arena, Tok>).accept(visitor), )*
416                    $( $enum_name::$variant => visitor.$visit_method($crate::cast_unchecked!(self.ctx_ptr() => $variant<'input, 'arena, Tok>)), )+
417                    $enum_name::Terminal => { visitor.visit_terminal($crate::cast_unchecked!(self.ctx_ptr() => TerminalNode<'input, 'arena, Tok>)) },
418                    $enum_name::Error => { visitor.visit_error_node($crate::cast_unchecked!(self.ctx_ptr() => ErrorNode<'input, 'arena, Tok>)) },
419                }
420            }
421        }
422    };
423}
424
425#[macro_export]
426macro_rules! impl_listener_dispatch {
427    // Pattern: EnumName { Variant1, Variant2, ... }
428    ($listener:ident::$node_name:ident::$enum_name:ident { $($variant:ident($enter_method:ident, $exit_method:ident),)+ }) => {
429        impl<'input, 'arena, Tok: Token + 'input> $enum_name<'input, 'arena, Tok>
430        where
431            'input: 'arena,
432        {
433            fn dispatch_enter(&self, listener: &mut (dyn $listener<'arena, Tok> + 'static)) -> Result<(), ANTLRError>
434            {
435                match self {
436                    $( $enum_name::$variant(inner) => listener.$enter_method(inner), )+
437                    $enum_name::Error(_) => Ok(()),
438                }
439            }
440
441            fn dispatch_exit(&self, listener: &mut (dyn $listener<'arena, Tok> + 'static)) -> Result<(), ANTLRError>
442            {
443                match self {
444                    $( $enum_name::$variant(inner) => listener.$exit_method(inner), )+
445                    $enum_name::Error(_) => Ok(()),
446                }
447            }
448        }
449    };
450}
451
452#[macro_export]
453macro_rules! impl_visitable {
454    // Pattern: EnumName { Variant1, Variant2, ... }
455    ($visitor:ident::$enum_name:ident { $($variant:ident($visit_method:ident),)+ }) => {
456        impl<'input, 'arena, Tok: Token + 'input> Visitable<'input, 'arena, Tok> for $enum_name<'input, 'arena, Tok> {
457            fn accept<V>(&'arena self, visitor: &mut V) -> Result<V::Return, ANTLRError>
458            where
459                V: $visitor<'input, 'arena, Tok> + ?Sized,
460            {
461                match self {
462                    $( $enum_name::$variant(inner) => visitor.$visit_method(inner), )+
463                    $enum_name::Error(_) => Ok(Default::default()),
464                }
465            }
466        }
467    };
468    ($visitor:ident::$ctx_name:ident($visit_method:ident)) => {
469        impl<'input, 'arena, Tok: Token + 'input> Visitable<'input, 'arena, Tok> for $ctx_name<'input, 'arena, Tok> {
470            fn accept<V>(&'arena self, visitor: &mut V) -> Result<V::Return, ANTLRError>
471            where
472                V: $visitor<'input, 'arena, Tok> + ?Sized,
473            {
474                visitor.$visit_method(self)
475            }
476        }
477    };
478}
479
480#[macro_export]
481macro_rules! impl_rule_context {
482    // Pattern: EnumName { Variant1, Variant2, ... }
483    ($enum_name:ident { $($ref_variant:ident,)* } $({ $($inline_variant:ident,)+ })?) => {
484        impl<'input, 'arena, Tok> RuleContext<'arena> for $enum_name<'input, 'arena, Tok>
485        where
486            'input: 'arena,
487            Tok: Token + 'input,
488        {
489            fn get_rule_index(&self) -> usize {
490                match self {
491                    // Generate a match arm for every variant
492                    $( $enum_name::$ref_variant(inner) => RuleContext::get_rule_index(&**inner), )*
493                    $($( $enum_name::$inline_variant(inner) => RuleContext::get_rule_index(inner), )+)?
494                }
495            }
496
497            fn get_alt_number(&self) -> i32 {
498                match self {
499                    $( $enum_name::$ref_variant(inner) => RuleContext::get_alt_number(&**inner), )*
500                    $($( $enum_name::$inline_variant(inner) => RuleContext::get_alt_number(inner), )+)?
501                }
502            }
503
504            fn get_invoking_state(&self) -> i32 {
505                match self {
506                    $( $enum_name::$ref_variant(inner) => RuleContext::get_invoking_state(&**inner), )*
507                    $($( $enum_name::$inline_variant(inner) => RuleContext::get_invoking_state(inner), )+)?
508                }
509            }
510
511            fn get_parent_ctx(&self) -> Option<&'arena dyn RuleContext<'arena>> {
512                match self {
513                    $( $enum_name::$ref_variant(inner) => RuleContext::get_parent_ctx(&**inner), )*
514                    $($( $enum_name::$inline_variant(inner) => RuleContext::get_parent_ctx(inner), )+)?
515                }
516            }
517
518            fn get_node_text(&self, rule_names: &[&str]) -> String {
519                match self {
520                    $( $enum_name::$ref_variant(inner) => RuleContext::get_node_text(&**inner, rule_names), )*
521                    $($( $enum_name::$inline_variant(inner) => RuleContext::get_node_text(inner, rule_names), )+)?
522                }
523            }
524
525        }
526    };
527}
528
529#[macro_export]
530macro_rules! impl_parser_rule_context {
531    // Pattern: EnumName { Variant1, Variant2, ... }
532    ($enum_name:ident { $($ref_variant:ident,)* } $({ $($inline_variant:ident,)+ })?) => {
533        impl<'input, 'arena, Tok> ParserRuleContext<'input, 'arena> for $enum_name<'input, 'arena, Tok>
534        where
535            'input: 'arena,
536            Tok: Token + 'input,
537        {
538            fn start(&self) -> &'arena dyn $crate::token::Token {
539                match self {
540                    $( $enum_name::$ref_variant(inner) => ParserRuleContext::start(&**inner), )*
541                    $($( $enum_name::$inline_variant(inner) => ParserRuleContext::start(inner), )+)?
542                }
543            }
544
545            fn stop(&self) -> &'arena dyn $crate::token::Token {
546                match self {
547                    $( $enum_name::$ref_variant(inner) => ParserRuleContext::stop(&**inner), )*
548                    $($( $enum_name::$inline_variant(inner) => ParserRuleContext::stop(inner), )+)?
549                }
550            }
551
552            fn get_parent_ctx(&self) -> Option<&'arena dyn ParserRuleContext<'input, 'arena>> {
553                match self {
554                    $( $enum_name::$ref_variant(inner) => ParserRuleContext::get_parent_ctx(&**inner), )*
555                    $($( $enum_name::$inline_variant(inner) => ParserRuleContext::get_parent_ctx(inner), )+)?
556                }
557            }
558
559            fn get_child_ctx(&self, _i: usize) -> Option<&'arena dyn ParserRuleContext<'input, 'arena>> {
560                match self {
561                    $( $enum_name::$ref_variant(inner) => ParserRuleContext::get_child_ctx(&**inner, _i), )*
562                    $($( $enum_name::$inline_variant(inner) => ParserRuleContext::get_child_ctx(inner, _i), )+)?
563                }
564            }
565
566            fn get_child_count(&self) -> usize {
567                match self {
568                    $( $enum_name::$ref_variant(inner) => ParserRuleContext::get_child_count(&**inner), )*
569                    $($( $enum_name::$inline_variant(inner) => ParserRuleContext::get_child_count(inner), )+)?
570                }
571            }
572
573            fn iter_children<'a>(
574                &'a self,
575            ) -> Box<dyn Iterator<Item = &'arena dyn ParserRuleContext<'input, 'arena>> + 'a>
576            where
577                'input: 'a,
578                'arena: 'a,
579            {
580                match self {
581                    $( $enum_name::$ref_variant(inner) => ParserRuleContext::iter_children(&**inner), )*
582                    $($( $enum_name::$inline_variant(inner) => ParserRuleContext::iter_children(inner), )+)?
583                }
584            }
585
586            fn get_token(&self, _ttype: i32, _pos: usize) -> Option<&dyn $crate::token::Token> {
587                match self {
588                    $( $enum_name::$ref_variant(inner) => ParserRuleContext::get_token(&**inner, _ttype, _pos), )*
589                    $($( $enum_name::$inline_variant(inner) => ParserRuleContext::get_token(inner, _ttype, _pos), )+)?
590                }
591            }
592
593            fn get_tokens(&self, _ttype: i32) -> Vec<&dyn $crate::token::Token> {
594                match self {
595                    $( $enum_name::$ref_variant(inner) => ParserRuleContext::get_tokens(&**inner, _ttype), )*
596                    $($( $enum_name::$inline_variant(inner) => ParserRuleContext::get_tokens(inner, _ttype), )+)?
597                }
598            }
599
600            fn get_text(&self) -> String {
601                match self {
602                    $( $enum_name::$ref_variant(inner) => ParserRuleContext::get_text(&**inner), )*
603                    $($( $enum_name::$inline_variant(inner) => ParserRuleContext::get_text(inner), )+)?
604                }
605            }
606       }
607    };
608}
609
610#[macro_export]
611macro_rules! impl_tree_trait_delegates {
612    ($node_kind:ident::$enum_name:ident { $($variant:ident),+ $(,)? }) => {
613        impl<'input, 'arena, Tok> $enum_name<'input, 'arena, Tok>
614        where
615            'input: 'arena,
616            Tok: Token + 'input,
617        {
618            // fn get_parent(&self) -> Option<&'arena TreeNode<'input, 'arena, $node_kind>> {
619            //     match self {
620            //         $( $enum_name::$variant(inner) => inner.get_parent(), )+
621            //     }
622            // }
623
624            // fn has_parent(&self) -> bool {
625            //     match self {
626            //         $( $enum_name::$variant(inner) => inner.has_parent(), )+
627            //     }
628            // }
629
630            // fn get_child(&self, i: usize) -> Option<&'arena TreeNode<'input, 'arena, $node_kind>> {
631            //     match self {
632            //         $( $enum_name::$variant(inner) => inner.get_child(i), )+
633            //     }
634            // }
635
636            // fn get_child_count(&self) -> usize {
637            //     match self {
638            //         $( $enum_name::$variant(inner) => inner.get_child_count(), )+
639            //     }
640            // }
641
642            // fn get_children<'a>(&'a self) -> Box<dyn Iterator<Item = &'arena TreeNode<'input, 'arena, $node_kind>> + 'a> {
643            //     match self {
644            //         $( $enum_name::$variant(inner) => inner.get_children(), )+
645            //     }
646            // }
647
648            // fn set_start(&mut self, t: Option<&'arena dyn $crate::token::Token>) {
649            //     match self {
650            //         $( $enum_name::$variant(inner) => inner.set_start(t), )+
651            //     }
652            // }
653
654            // fn set_stop(&mut self, t: Option<&'arena dyn $crate::token::Token>) {
655            //     match self {
656            //         $( $enum_name::$variant(inner) => inner.set_stop(t), )+
657            //     }
658            // }
659
660            // fn set_parent(&mut self, parent: Option<&'arena TreeNode<'input, 'arena, $node_kind>>) {
661            //     match self {
662            //         $( $enum_name::$variant(inner) => inner.set_parent(parent), )+
663            //     }
664            // }
665
666            // fn set_invoking_state(&mut self, t: i32) {
667            //     match self {
668            //         $( $enum_name::$variant(inner) => inner.set_invoking_state(t), )+
669            //     }
670            // }
671
672            fn set_alt_number(&mut self, alt_number: i32) {
673                match self {
674                    $( $enum_name::$variant(inner) => inner.set_alt_number(alt_number), )+
675                }
676            }
677
678            // fn set_exception(&self, e: $crate::errors::ANTLRError, arena: &'arena $crate::Arena) {
679            //     match self {
680            //         $( $enum_name::$variant(inner) => inner.set_exception(e, arena), )+
681            //     }
682            // }
683
684            // fn remove_last_child(&mut self) {
685            //     match self {
686            //         $( $enum_name::$variant(inner) => inner.remove_last_child(), )+
687            //     }
688            // }
689
690            // fn add_child(&mut self, child: &'arena TreeNode<'input, 'arena, $node_kind>) {
691            //     match self {
692            //         $( $enum_name::$variant(inner) => inner.add_child(child), )+
693            //     }
694            // }
695        }
696    };
697}
698
699#[macro_export]
700macro_rules! impl_node_inner {
701    ($node_kind:ident::$node_variant:ident::$context_all:ident { $($variant:ident),+ $(,)? }) => {
702        impl<'input, 'arena, Tok> NodeInner<'input, 'arena, $node_kind, Tok>
703            for $context_all<'input, 'arena, Tok>
704        where
705            'input: 'arena,
706            Tok: Token + 'input,
707        {
708            fn cast_from<'a>(node: &'a TreeNode<'input, 'arena, $node_kind, Tok>) -> Option<&'a Self> {
709                match node.node_tag() {
710                    $node_kind::$node_variant => Some($crate::cast_unchecked!(node => Self)),
711                    _ => None,
712                }
713            }
714
715            fn cast_from_mut<'a>(node: &'a mut TreeNode<'input, 'arena, $node_kind, Tok>) -> Option<&'a mut Self>
716            where
717                Self: Sized,
718            {
719                match node.node_tag() {
720                    $node_kind::$node_variant => Some($crate::cast_unchecked!(node => mut Self)),
721                    _ => None,
722                }
723            }
724
725            fn as_node(&self) -> &TreeNode<'input, 'arena, $node_kind, Tok> {
726                $crate::cast_unchecked!(self => TreeNode<'input, 'arena, $node_kind, Tok>)
727            }
728
729            fn as_node_mut(&mut self) -> &mut TreeNode<'input, 'arena, $node_kind, Tok> {
730                $crate::cast_unchecked!(self => mut TreeNode<'input, 'arena, $node_kind, Tok>)
731            }
732
733            fn iter_child_nodes<'a>(&'a self) -> Box<dyn Iterator<Item = &'arena TreeNode<'input, 'arena, $node_kind, Tok>> + 'a> {
734                match self {
735                    $( $context_all::$variant(inner) => inner.get_children(), )+
736                }
737            }
738        }
739    };
740}
741
742#[macro_export]
743macro_rules! impl_token_source {
744    ($lexer:ident) => {
745        impl<'input, 'arena, Input, TF> $crate::TokenSource<'input, 'arena, TF>
746            for $lexer<'input, 'arena, Input, TF>
747        where
748            TF: $crate::token_factory::TokenFactory<'input, 'arena> + 'arena,
749            Input: $crate::char_stream::CharStream<'input>,
750        {
751            fn next_token(&mut self) -> &'arena mut TF::Tok {
752                self.base.next_token()
753            }
754
755            fn get_line(&self) -> u32 {
756                self.base.get_line()
757            }
758
759            fn get_char_position_in_line(&self) -> i32 {
760                self.base.get_char_position_in_line()
761            }
762
763            fn get_input_stream(&mut self) -> Option<&mut dyn $crate::int_stream::IntStream> {
764                self.base.get_input_stream()
765            }
766
767            fn get_source_name(&self) -> String {
768                self.base.get_source_name()
769            }
770
771            fn get_token_factory(&self) -> &TF {
772                self.base.get_token_factory()
773            }
774
775            fn get_dfa_string(&self) -> String {
776                self.base.get_dfa_string()
777            }
778        }
779    };
780}
781
782#[macro_export]
783macro_rules! impl_deref {
784    (parser => $parser_name:ident) => {
785        impl<'input, 'arena, Input, TF> Deref for $parser_name<'input, 'arena, Input, TF>
786        where
787            'input: 'arena,
788            TF: TokenFactory<'input, 'arena> + 'arena,
789            Input: TokenStream<'input, 'arena, TF> + 'arena,
790        {
791            type Target = BaseParserType<'input, 'arena, Input, TF>;
792            fn deref(&self) -> &Self::Target {
793                &self.base
794            }
795        }
796
797        impl<'input, 'arena, Input, TF> DerefMut for $parser_name<'input, 'arena, Input, TF>
798        where
799            'input: 'arena,
800            TF: TokenFactory<'input, 'arena> + 'arena,
801            Input: TokenStream<'input, 'arena, TF> + 'arena,
802        {
803            fn deref_mut(&mut self) -> &mut Self::Target {
804                &mut self.base
805            }
806        }
807    };
808    (lexer => $lexer_name:ident) => {
809        impl<'input, 'arena, Input, TF> Deref for $lexer_name<'input, 'arena, Input, TF>
810        where
811            'input: 'arena,
812            TF: TokenFactory<'input, 'arena> + 'arena,
813            Input: CharStream<'input> + 'arena,
814        {
815            type Target = BaseLexerType<'input, 'arena, Input, TF>;
816            fn deref(&self) -> &Self::Target {
817                &self.base
818            }
819        }
820
821        impl<'input, 'arena, Input, TF> DerefMut for $lexer_name<'input, 'arena, Input, TF>
822        where
823            'input: 'arena,
824            TF: TokenFactory<'input, 'arena> + 'arena,
825            Input: CharStream<'input> + 'arena,
826        {
827            fn deref_mut(&mut self) -> &mut Self::Target {
828                &mut self.base
829            }
830        }
831    };
832}
833
834pub const STACKER_RED_ZONE_BYTES: usize = 64 * 1024;
835pub const STACKER_GROWTH_BYTES: usize = 1024 * 1024;
836
837#[cfg(feature = "stacker")]
838#[macro_export]
839macro_rules! maybe_grow_stack {
840    ($body:block) => {
841        $crate::stacker::maybe_grow(
842            $crate::STACKER_RED_ZONE_BYTES,
843            $crate::STACKER_GROWTH_BYTES,
844            || $body,
845        )
846    };
847}
848#[cfg(not(feature = "stacker"))]
849#[macro_export]
850macro_rules! maybe_grow_stack {
851    ($body:block) => {
852        $body
853    };
854}
855
856#[macro_export]
857macro_rules! cast_unchecked {
858    ($ptr:expr => $target:ty) => {{
859        let ptr = ($ptr as *const _ as *const ()).cast::<$target>();
860        unsafe { &*ptr }
861    }};
862    ($ptr:expr => mut $target:ty) => {{
863        let ptr = ($ptr as *mut _ as *mut ()).cast::<$target>();
864        unsafe { &mut *ptr }
865    }};
866}