1#![crate_type = "lib"]
2#[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#[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#[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#[doc(hidden)]
83pub mod dfa;
84#[doc(hidden)]
85pub mod transition;
86pub mod tree;
87#[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;
117mod atn_type;
119pub mod rule_context;
121pub mod vocabulary;
122
123#[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
130pub 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#[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#[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 ($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_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 }
237 };
238}
239
240#[macro_export]
241macro_rules! impl_node_kind_common {
242 ($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 ($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 ($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 }
351 };
352
353 ($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 ($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 ($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 ($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 ($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 $( $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 ($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 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 }
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}