#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub(crate) enum SemUnknownPolicy {
#[default]
AssumeTrue,
AssumeFalse,
Hook,
Error,
}
impl SemUnknownPolicy {
const fn manifest_name(self) -> &'static str {
match self {
Self::AssumeTrue => "assume-true",
Self::AssumeFalse => "assume-false",
Self::Hook => "hook",
Self::Error => "error",
}
}
const fn unknown_predicate_disposition(self) -> SemanticsDisposition {
match self {
Self::AssumeTrue | Self::Error => SemanticsDisposition::AssumeTrue,
Self::AssumeFalse => SemanticsDisposition::AssumeFalse,
Self::Hook => SemanticsDisposition::Hooked,
}
}
const fn unknown_action_disposition(self) -> SemanticsDisposition {
match self {
Self::Hook => SemanticsDisposition::Hooked,
Self::AssumeTrue | Self::AssumeFalse | Self::Error => SemanticsDisposition::Ignored,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum SemanticsKind {
LexerAction,
LexerPredicate,
ParserPredicate,
ParserAction,
}
impl SemanticsKind {
const fn manifest_name(self) -> &'static str {
match self {
Self::LexerAction => "lexer-action",
Self::LexerPredicate => "lexer-predicate",
Self::ParserPredicate => "parser-predicate",
Self::ParserAction => "parser-action",
}
}
const fn error_label(self) -> &'static str {
match self {
Self::LexerAction => "unsupported grammar action",
Self::LexerPredicate | Self::ParserPredicate => "unsupported semantic predicate",
Self::ParserAction => "unsupported grammar action",
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum SemanticsDisposition {
Translated,
AssumeTrue,
AssumeFalse,
Hooked,
Error,
Ignored,
Synthetic,
}
impl SemanticsDisposition {
const fn manifest_name(self) -> &'static str {
match self {
Self::Translated => "translated",
Self::AssumeTrue => "assume-true",
Self::AssumeFalse => "assume-false",
Self::Hooked => "hooked",
Self::Error => "error",
Self::Ignored => "ignored",
Self::Synthetic => "synthetic",
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum GrammarOptionDisposition {
Metadata,
ToolHandled,
Hooked,
Unsupported,
}
impl GrammarOptionDisposition {
pub(crate) const fn manifest_name(self) -> &'static str {
match self {
Self::Metadata => "metadata",
Self::ToolHandled => "tool-handled",
Self::Hooked => "hooked",
Self::Unsupported => "unsupported",
}
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct GrammarOptionEntry {
pub(crate) key: String,
pub(crate) value: String,
pub(crate) line: usize,
pub(crate) column: usize,
pub(crate) disposition: GrammarOptionDisposition,
}
impl GrammarOptionEntry {
fn assignment(&self) -> String {
format!("{}={}", self.key, self.value)
}
fn describe_unsupported(&self) -> String {
format!(
"unsupported grammar option: {} at {}:{} is accepted by ANTLR but is not \
automatically implemented by antlr4-rust-gen; target-specific behavior may be \
missing (see #98)",
self.assignment(),
self.line,
self.column
)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum CoordinateDispose {
Hook,
AssumeTrue,
AssumeFalse,
Error,
}
impl CoordinateDispose {
fn parse(value: &str) -> io::Result<Self> {
match value {
"hook" => Ok(Self::Hook),
"assume-true" => Ok(Self::AssumeTrue),
"assume-false" => Ok(Self::AssumeFalse),
"error" => Ok(Self::Error),
other => Err(io::Error::new(
io::ErrorKind::InvalidData,
format!("unknown coordinate dispose {other}"),
)),
}
}
pub(crate) const fn disposition(self) -> SemanticsDisposition {
match self {
Self::Hook => SemanticsDisposition::Hooked,
Self::AssumeTrue => SemanticsDisposition::AssumeTrue,
Self::AssumeFalse => SemanticsDisposition::AssumeFalse,
Self::Error => SemanticsDisposition::Error,
}
}
pub(crate) const fn predicate_template(self) -> Option<PredicateTemplate> {
match self {
Self::Hook => Some(PredicateTemplate::Hook),
Self::AssumeTrue => Some(PredicateTemplate::True),
Self::AssumeFalse => Some(PredicateTemplate::False),
Self::Error => None,
}
}
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub(crate) struct SemPatternFile {
patterns: Vec<SemPatternRule>,
helpers: Vec<SemHelperRule>,
coordinates: Vec<SemCoordinateOverride>,
members: Vec<stack_member::MemberDeclaration>,
}
impl SemPatternFile {
fn member_slots_for(
&self,
recognizer: stack_member::MemberScope,
) -> io::Result<stack_member::MemberSlots> {
stack_member::MemberSlots::assign_scoped(&self.members, recognizer)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
struct SemPatternRule {
id: String,
match_body: String,
lower: String,
}
#[derive(Clone, Debug, Eq, PartialEq)]
struct SemHelperRule {
kind: Option<SemanticsKind>,
receiver: Option<String>,
name: String,
arguments: Vec<SemanticLiteralKind>,
lower: String,
}
#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
enum SemanticLiteralKind {
String,
Bool,
Integer,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) enum SemanticLiteral {
String(String),
Bool(bool),
Integer(i64),
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct SemanticHelperCall {
pub(crate) name: String,
pub(crate) arguments: Vec<SemanticLiteral>,
pub(crate) negated: bool,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct SemCoordinateOverride {
pub(crate) kind: SemanticsKind,
pub(crate) rule: Option<String>,
pub(crate) index: Option<usize>,
pub(crate) atn_state: Option<usize>,
pub(crate) dispose: CoordinateDispose,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) enum ActionTemplate {
LexerPopMode,
Hook(SemanticHelperCall),
MemberStmt(stack_member::MemberStmt),
UnsupportedLexerAction {
rule_name: String,
body: String,
},
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) enum PredicateTemplate {
Hook,
UnknownWithFailMessage {
message: String,
},
Unknown,
True,
False,
FalseWithMessage {
message: String,
},
WithFailMessage {
inner: Box<Self>,
message: String,
},
Invoke {
value: bool,
},
LocalIntEquals {
value: i64,
},
LocalIntLessOrEqual {
value: i64,
},
LookaheadTextEquals {
offset: isize,
text: String,
},
TextEquals(String),
TokenStartColumnEquals(usize),
ColumnLessThan(usize),
ColumnGreaterOrEqual(usize),
LookaheadNotEquals {
offset: isize,
token_name: String,
},
TokenPairAdjacent,
ContextChildRuleTextNotEquals {
rule_name: String,
text: String,
},
MemberExpr(stack_member::MemberExpr),
}
pub(crate) fn can_generate_parser_predicate(predicate: &PredicateTemplate) -> bool {
matches!(
predicate_effective_template(predicate),
PredicateTemplate::Hook
| PredicateTemplate::UnknownWithFailMessage { .. }
| PredicateTemplate::Unknown
| PredicateTemplate::True
| PredicateTemplate::False
| PredicateTemplate::FalseWithMessage { .. }
| PredicateTemplate::Invoke { .. }
| PredicateTemplate::LocalIntEquals { .. }
| PredicateTemplate::LocalIntLessOrEqual { .. }
| PredicateTemplate::LookaheadTextEquals { .. }
| PredicateTemplate::LookaheadNotEquals { .. }
| PredicateTemplate::TokenPairAdjacent
| PredicateTemplate::ContextChildRuleTextNotEquals { .. }
| PredicateTemplate::MemberExpr(_)
)
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum RuleArgTemplate {
Literal(i64),
InheritLocal,
}