mod action_translator;
mod lexer_factory;
mod listener_factory;
pub mod model;
mod parser_factory;
pub mod template;
use std::path::{Path, PathBuf};
use crate::emission::lexer_factory::build_lexer_file_context;
use crate::emission::listener_factory::build_tree_walk_file_contexts;
use crate::emission::model::StaticLexerTablesModel;
use crate::emission::parser_factory::build_parser_file_context;
use crate::emission::template::render_template;
use crate::error::Diagnostic;
use crate::grammar::compiler::{self, Compilation};
use crate::grammar::loader::LoadOptions;
use crate::optimization::{OptimizationOptions, OptimizationPlan};
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct EmittedFile {
pub name: String,
pub content: String,
}
pub use crate::error::EmitError;
fn compile_grammar(
grammar_path: &Path,
library_dirs: &[PathBuf],
) -> Result<Compilation, EmitError> {
compile_grammar_with(grammar_path, library_dirs, &OptimizationPlan::default())
}
pub(crate) fn compile_grammar_with(
grammar_path: &Path,
library_dirs: &[PathBuf],
plan: &OptimizationPlan,
) -> Result<Compilation, EmitError> {
let roots = vec![grammar_path.to_path_buf()];
compiler::compile_with_plan(
LoadOptions {
roots: roots.clone(),
library_directories: library_dirs.to_vec(),
},
plan,
)
.map_err(|error| crate::compile_error::compilation_error(&error, &roots))
.map_err(EmitError::from)
}
fn bare_file_name(grammar_path: &Path) -> String {
grammar_path.file_name().map_or_else(
|| grammar_path.display().to_string(),
|name| name.to_string_lossy().into_owned(),
)
}
pub fn emit_lexer_files(
grammar_path: &Path,
library_dirs: &[PathBuf],
) -> Result<Vec<EmittedFile>, EmitError> {
let compilation = compile_grammar(grammar_path, library_dirs)?;
let grammar_file_name = bare_file_name(grammar_path);
let mut files = Vec::new();
for root in &compilation.roots {
let Some(lexer_id) = root.lexer else {
continue;
};
let compiled = &compilation.lexers[&lexer_id];
let context = build_lexer_file_context(compiled, &grammar_file_name, None);
let content = render_template(&minijinja::Value::from_serialize(&context))?;
let name = format!("{}.rs", compiled.semantic.unit.name.to_lowercase());
files.push(EmittedFile { name, content });
}
Ok(files)
}
pub fn emit_files(
grammar_path: &Path,
library_dirs: &[PathBuf],
) -> Result<Vec<EmittedFile>, EmitError> {
emit_files_with_flags(grammar_path, library_dirs, true, true)
}
pub fn emit_files_with_flags(
grammar_path: &Path,
library_dirs: &[PathBuf],
gen_listener: bool,
gen_visitor: bool,
) -> Result<Vec<EmittedFile>, EmitError> {
let compilation = compile_grammar(grammar_path, library_dirs)?;
render_recognizer_files(&compilation, grammar_path, gen_listener, gen_visitor)
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct EmittedOutput {
pub files: Vec<EmittedFile>,
pub diagnostics: Vec<Diagnostic>,
pub optimization_messages: Vec<String>,
pub optimization_manifest: Option<String>,
pub reports: Vec<String>,
}
pub fn emit_files_with_options(
grammar_path: &Path,
library_dirs: &[PathBuf],
gen_listener: bool,
gen_visitor: bool,
optimization: &OptimizationOptions,
) -> Result<EmittedOutput, EmitError> {
let plan = OptimizationPlan::from_options(optimization)?;
let compilation = compile_grammar_with(grammar_path, library_dirs, &plan)?;
let mut diagnostics = crate::compile_error::non_fatal_diagnostics(&compilation);
let optimization_messages =
plan.diagnostic_messages(compilation.optimization_report(), &compilation.sources);
let optimization_manifest =
plan.render_manifest(compilation.optimization_report(), &compilation.sources);
let reports = plan.rendered_reports(compilation.optimization_report());
diagnostics.extend(reports.diagnostics.iter().map(|diagnostic| {
crate::compile_error::public_diagnostic(diagnostic, &compilation.sources)
}));
let files = if plan.report_only() {
Vec::new()
} else {
render_recognizer_files(&compilation, grammar_path, gen_listener, gen_visitor)?
};
Ok(EmittedOutput {
files,
diagnostics,
optimization_messages,
optimization_manifest,
reports: reports.reports,
})
}
fn render_recognizer_files(
compilation: &Compilation,
grammar_path: &Path,
gen_listener: bool,
gen_visitor: bool,
) -> Result<Vec<EmittedFile>, EmitError> {
let grammar_file_name = bare_file_name(grammar_path);
let grammar_name = grammar_path.file_stem().map_or_else(
|| grammar_file_name.clone(),
|stem| stem.to_string_lossy().into_owned(),
);
let mut files = Vec::new();
for root in &compilation.roots {
if let Some(lexer_id) = root.lexer {
let compiled = &compilation.lexers[&lexer_id];
let static_tables = compilation
.static_lexer_tables(lexer_id)
.map(StaticLexerTablesModel::from_pass);
let context = build_lexer_file_context(compiled, &grammar_file_name, static_tables);
let content = render_template(&minijinja::Value::from_serialize(&context))?;
let name = format!("{}.rs", compiled.semantic.unit.name.to_lowercase());
files.push(EmittedFile { name, content });
}
if let Some(parser_id) = root.parser {
let compiled = &compilation.parsers[&parser_id];
let context = build_parser_file_context(
compiled,
&compilation.sources,
&grammar_name,
&grammar_file_name,
gen_listener,
gen_visitor,
compilation.static_parser_tables(parser_id),
)?;
let content = render_template(&minijinja::Value::from_serialize(&context))?;
let name = format!("{}.rs", context.parser.name.to_lowercase());
files.push(EmittedFile { name, content });
files.extend(emit_tree_walk_files(
&compiled.semantic.unit,
&grammar_name,
&grammar_file_name,
gen_listener,
gen_visitor,
)?);
}
}
Ok(files)
}
pub fn emit_listener_visitor_files(
grammar_path: &Path,
library_dirs: &[PathBuf],
gen_listener: bool,
gen_visitor: bool,
) -> Result<Vec<EmittedFile>, EmitError> {
let compilation = compile_grammar(grammar_path, library_dirs)?;
let grammar_file_name = bare_file_name(grammar_path);
let grammar_name = grammar_path.file_stem().map_or_else(
|| grammar_file_name.clone(),
|stem| stem.to_string_lossy().into_owned(),
);
let mut files = Vec::new();
for root in &compilation.roots {
if let Some(parser_id) = root.parser {
let compiled = &compilation.parsers[&parser_id];
files.extend(emit_tree_walk_files(
&compiled.semantic.unit,
&grammar_name,
&grammar_file_name,
gen_listener,
gen_visitor,
)?);
}
}
Ok(files)
}
fn emit_tree_walk_files(
unit: &crate::grammar::model::GrammarUnit,
grammar_name: &str,
grammar_file_name: &str,
gen_listener: bool,
gen_visitor: bool,
) -> Result<Vec<EmittedFile>, EmitError> {
let contexts = build_tree_walk_file_contexts(unit, grammar_name, grammar_file_name);
let base_name = grammar_name.to_lowercase();
let mut files = Vec::new();
if gen_listener {
files.push(render_tree_walk_file(
&contexts.listener,
&base_name,
"listener",
)?);
files.push(render_tree_walk_file(
&contexts.base_listener,
&base_name,
"baselistener",
)?);
}
if gen_visitor {
files.push(render_tree_walk_file(
&contexts.visitor,
&base_name,
"visitor",
)?);
files.push(render_tree_walk_file(
&contexts.base_visitor,
&base_name,
"basevisitor",
)?);
}
Ok(files)
}
fn render_tree_walk_file<T: serde::Serialize>(
context: &T,
base_name: &str,
suffix: &str,
) -> Result<EmittedFile, EmitError> {
let content = render_template(&minijinja::Value::from_serialize(context))?;
Ok(EmittedFile {
name: format!("{base_name}{suffix}.rs"),
content,
})
}