use crate::parser::error_recovery::RecoveryState;
use crate::standard::VHDLStandard;
use crate::syntax::node::SyntaxNode;
use crate::syntax::{DesignFileSyntax, NodeKind};
use crate::tokens::TokenStream;
pub(crate) mod builder;
pub mod error;
pub(crate) mod marker;
#[cfg(test)]
#[macro_use]
mod test_utils;
#[macro_use]
mod util;
mod error_recovery;
mod list;
pub(crate) mod productions;
pub(crate) struct Parser {
token_stream: TokenStream,
builder: builder::NodeBuilder,
standard: VHDLStandard,
recovery: RecoveryState,
}
impl Parser {
pub(crate) fn new(token_stream: TokenStream, standard: VHDLStandard) -> Parser {
Parser {
token_stream,
builder: builder::NodeBuilder::new(),
standard,
recovery: RecoveryState::new(),
}
}
pub fn standard(&self) -> VHDLStandard {
self.standard
}
pub fn into_root(self) -> (SyntaxNode, Vec<error::SyntaxErr>) {
let (green, diagnostics) = self.end();
(SyntaxNode::new_root(green), diagnostics)
}
}
pub fn parse(token_stream: impl Into<TokenStream>) -> (DesignFileSyntax, Vec<error::SyntaxErr>) {
parse_with_standard(VHDLStandard::default(), token_stream)
}
pub fn parse_with_standard(
standard: VHDLStandard,
input: impl Into<TokenStream>,
) -> (DesignFileSyntax, Vec<error::SyntaxErr>) {
let mut parser = Parser::new(input.into(), standard);
parser.design_file();
let (syntax_node, diagnostics) = parser.into_root();
debug_assert!(syntax_node.kind() == NodeKind::DesignFile);
(DesignFileSyntax(syntax_node), diagnostics)
}
#[cfg(test)]
pub(crate) fn parse_syntax<T>(
token_stream: impl Into<TokenStream>,
parser_fn: impl FnOnce(&mut Parser) -> T,
) -> (SyntaxNode, Vec<error::SyntaxErr>) {
let mut parser = Parser::new(token_stream.into(), VHDLStandard::default());
parser_fn(&mut parser);
let (green, diagnostics) = parser.end();
(SyntaxNode::new_root(green), diagnostics)
}
#[cfg(test)]
pub(crate) fn parse_syntax_with_standard<T>(
standard: VHDLStandard,
input: impl IntoIterator<Item = u8>,
parser_fn: impl FnOnce(&mut Parser) -> T,
) -> (SyntaxNode, Vec<error::SyntaxErr>) {
let token_stream: TokenStream =
crate::tokens::Tokenizer::with_standard(standard, input.into_iter()).collect();
let mut parser = Parser::new(token_stream, standard);
parser_fn(&mut parser);
let (green, diagnostics) = parser.end();
(SyntaxNode::new_root(green), diagnostics)
}