use std::collections::BTreeMap;
use serde::Serialize;
use crate::optimization::StaticLexerTables;
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct LexerFileContext {
pub lexer_file: OutputFileModel,
pub lexer: LexerModel,
pub named_actions: NamedActionsModel,
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct OutputFileModel {
pub grammar_file_name: String,
#[serde(rename = "ANTLRVersion")]
pub antlr_version: String,
}
#[derive(Clone, Debug, Default, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct NamedActionsModel {
pub header: Option<String>,
pub init: Option<String>,
pub fields: Option<String>,
pub members: Option<String>,
pub definitions: Option<String>,
pub extend: Option<String>,
pub after: Option<String>,
}
#[derive(Clone, Debug, Default, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RuleNamedActionsModel {
pub init: Option<Vec<ActionChunkModel>>,
pub after: Option<Vec<ActionChunkModel>>,
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TokenConstantModel {
pub key: String,
pub value: i32,
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct IndexedActionModel {
pub index: usize,
pub chunks: Vec<ActionChunkModel>,
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RuleActionFunctionModel {
pub name: String,
pub escaped_name: String,
pub ctx_type: String,
pub rule_index: usize,
pub is_lexer: bool,
pub actions: Vec<IndexedActionModel>,
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ListenerFileContext {
pub kind: &'static str,
pub file: ListenerFileModel,
pub header: Option<String>,
pub named_actions: NamedActionsModel,
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ListenerFileModel {
pub grammar_file_name: String,
#[serde(rename = "ANTLRVersion")]
pub antlr_version: String,
pub grammar_name: String,
pub parser_name: String,
pub listener_names: Vec<String>,
pub listener_label_rule_names: BTreeMap<String, String>,
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VisitorFileContext {
pub kind: &'static str,
pub file: VisitorFileModel,
pub header: Option<String>,
pub named_actions: NamedActionsModel,
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VisitorFileModel {
pub grammar_file_name: String,
#[serde(rename = "ANTLRVersion")]
pub antlr_version: String,
pub grammar_name: String,
pub parser_name: String,
pub visitor_names: Vec<String>,
pub visitor_label_rule_names: BTreeMap<String, String>,
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SerializedAtnModel {
pub serialized: Vec<i32>,
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct StaticLexerTablesModel {
pub words: Vec<u32>,
pub omit_atn: bool,
}
impl StaticLexerTablesModel {
pub(crate) fn from_pass(tables: &StaticLexerTables) -> Self {
Self {
words: tables.words.clone(),
omit_atn: tables.omit_atn,
}
}
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PackedAtnModel {
pub serialized: Vec<u32>,
pub static_tables: Option<StaticParserTablesModel>,
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct StaticParserTablesModel {
pub words: Vec<u32>,
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParserFileContext {
pub file: ParserFileModel,
pub parser: ParserModel,
pub named_actions: NamedActionsModel,
pub context_super_class: Option<String>,
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParserFileModel {
pub grammar_file_name: String,
#[serde(rename = "ANTLRVersion")]
pub antlr_version: String,
pub grammar_name: String,
pub gen_listener: bool,
pub gen_visitor: bool,
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RuleRefModel {
pub name: String,
pub index: usize,
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParserModel {
pub name: String,
pub grammar_name: String,
pub grammar_file_name: String,
pub tokens: Vec<TokenConstantModel>,
pub rules: Vec<RuleRefModel>,
pub rule_names: Vec<String>,
pub literal_names: Vec<Option<String>>,
pub symbolic_names: Vec<Option<String>>,
pub funcs: Vec<RuleFunctionModel>,
pub sempred_funcs: Vec<RuleActionFunctionModel>,
pub atn: PackedAtnModel,
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RuleFunctionModel {
pub name: String,
pub escaped_name: String,
pub modifiers: Vec<String>,
pub ctx_type: String,
pub index: usize,
pub start_state: i32,
pub has_lookahead_block: bool,
pub left_recursive: bool,
pub resume_target: bool,
pub args: Vec<DeclModel>,
pub locals: Vec<DeclModel>,
pub code: Vec<SrcOpModel>,
pub rule_ctx: StructDeclModel,
pub alt_label_ctxs: Vec<StructDeclModel>,
pub named_actions: RuleNamedActionsModel,
pub finally_action: Option<String>,
pub postamble: Vec<SrcOpModel>,
pub exceptions: Vec<String>,
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TokenInfoModel {
pub ttype: i32,
pub name: String,
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ChoiceModel {
pub state_number: i32,
pub decision: i32,
pub exit_alt: i32,
pub block_start_state_number: i32,
pub loop_back_state_number: i32,
pub greedy: bool,
pub alt_look: Vec<Vec<TokenInfoModel>>,
pub table_can_defer: bool,
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DescentGroupModel {
pub virtual_alt: i32,
pub call_sites: Vec<i32>,
pub prefix_len: usize,
pub rule_name: String,
pub invoke: String,
pub tails: Vec<DescentTailModel>,
pub default_alt: i32,
pub static_fallback: Option<i32>,
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DescentTailModel {
pub alt: i32,
pub tokens: Vec<TokenInfoModel>,
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BitsetModel {
pub shift: i32,
pub tokens: Vec<TokenInfoModel>,
pub calculated: i64,
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ChunkContextModel {
pub escaped_name: String,
}
impl ChunkContextModel {
pub fn new(escaped_name: impl Into<String>) -> Self {
Self {
escaped_name: escaped_name.into(),
}
}
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct OpLabelModel {
pub name: String,
pub escaped_name: String,
pub ctx: ChunkContextModel,
}
#[derive(Clone, Debug, Serialize)]
#[serde(tag = "kind", rename_all_fields = "camelCase")]
pub enum ActionChunkModel {
ActionText {
ctx: ChunkContextModel,
text: String,
},
ArgRef {
ctx: ChunkContextModel,
name: String,
escaped_name: String,
},
LocalRef {
ctx: ChunkContextModel,
name: String,
escaped_name: String,
},
RetValueRef {
ctx: ChunkContextModel,
name: String,
escaped_name: String,
},
QRetValueRef {
ctx: ChunkContextModel,
dict: String,
name: String,
escaped_name: String,
},
TokenRef {
ctx: ChunkContextModel,
name: String,
escaped_name: String,
},
LabelRef {
ctx: ChunkContextModel,
name: String,
escaped_name: String,
},
ListLabelRef {
ctx: ChunkContextModel,
name: String,
escaped_name: String,
},
#[serde(rename = "TokenPropertyRef_text")]
TokenPropertyRefText {
ctx: ChunkContextModel,
label: String,
},
#[serde(rename = "TokenPropertyRef_type")]
TokenPropertyRefType {
ctx: ChunkContextModel,
label: String,
},
#[serde(rename = "TokenPropertyRef_line")]
TokenPropertyRefLine {
ctx: ChunkContextModel,
label: String,
},
#[serde(rename = "TokenPropertyRef_pos")]
TokenPropertyRefPos {
ctx: ChunkContextModel,
label: String,
},
#[serde(rename = "TokenPropertyRef_channel")]
TokenPropertyRefChannel {
ctx: ChunkContextModel,
label: String,
},
#[serde(rename = "TokenPropertyRef_index")]
TokenPropertyRefIndex {
ctx: ChunkContextModel,
label: String,
},
#[serde(rename = "TokenPropertyRef_int")]
TokenPropertyRefInt {
ctx: ChunkContextModel,
label: String,
},
#[serde(rename = "RulePropertyRef_start")]
RulePropertyRefStart {
ctx: ChunkContextModel,
label: String,
},
#[serde(rename = "RulePropertyRef_stop")]
RulePropertyRefStop {
ctx: ChunkContextModel,
label: String,
},
#[serde(rename = "RulePropertyRef_text")]
RulePropertyRefText {
ctx: ChunkContextModel,
label: String,
},
#[serde(rename = "RulePropertyRef_ctx")]
RulePropertyRefCtx {
ctx: ChunkContextModel,
label: String,
},
#[serde(rename = "RulePropertyRef_parser")]
RulePropertyRefParser {
ctx: ChunkContextModel,
label: String,
},
#[serde(rename = "ThisRulePropertyRef_start")]
ThisRulePropertyRefStart { ctx: ChunkContextModel },
#[serde(rename = "ThisRulePropertyRef_stop")]
ThisRulePropertyRefStop { ctx: ChunkContextModel },
#[serde(rename = "ThisRulePropertyRef_text")]
ThisRulePropertyRefText { ctx: ChunkContextModel },
#[serde(rename = "ThisRulePropertyRef_ctx")]
ThisRulePropertyRefCtx { ctx: ChunkContextModel },
#[serde(rename = "ThisRulePropertyRef_parser")]
ThisRulePropertyRefParser { ctx: ChunkContextModel },
SetAttr {
ctx: ChunkContextModel,
name: String,
escaped_name: String,
rhs_chunks: Vec<Self>,
},
}
#[derive(Clone, Debug, Serialize)]
#[serde(tag = "kind", rename_all_fields = "camelCase")]
pub enum SrcOpModel {
CodeBlockForOuterMostAlt {
alt_num: usize,
alt_label: Option<String>,
locals: Vec<DeclModel>,
preamble: Vec<Self>,
ops: Vec<Self>,
},
CodeBlockForAlt {
locals: Vec<DeclModel>,
preamble: Vec<Self>,
ops: Vec<Self>,
},
LL1AltBlock {
choice: ChoiceModel,
preamble: Vec<Self>,
alts: Vec<Self>,
error: Box<Self>,
},
LL1OptionalBlock {
choice: ChoiceModel,
alts: Vec<Self>,
error: Box<Self>,
},
LL1OptionalBlockSingleAlt {
choice: ChoiceModel,
expr: Box<Self>,
alts: Vec<Self>,
preamble: Vec<Self>,
error: Box<Self>,
follow_expr: Box<Self>,
},
LL1StarBlockSingleAlt {
choice: ChoiceModel,
loop_expr: Box<Self>,
alts: Vec<Self>,
preamble: Vec<Self>,
iteration: Vec<Self>,
},
LL1PlusBlockSingleAlt {
choice: ChoiceModel,
loop_expr: Box<Self>,
alts: Vec<Self>,
preamble: Vec<Self>,
iteration: Vec<Self>,
},
AltBlock {
choice: ChoiceModel,
preamble: Vec<Self>,
alts: Vec<Self>,
},
OptionalBlock {
choice: ChoiceModel,
alts: Vec<Self>,
},
StarBlock {
choice: ChoiceModel,
alts: Vec<Self>,
iteration: Vec<Self>,
},
PlusBlock {
choice: ChoiceModel,
alts: Vec<Self>,
error: Box<Self>,
},
DFAAltBlock {
choice: ChoiceModel,
preamble: Vec<Self>,
alts: Vec<Self>,
},
DescentAltBlock {
choice: ChoiceModel,
preamble: Vec<Self>,
alts: Vec<Self>,
groups: Vec<DescentGroupModel>,
},
DFAOptionalBlock {
choice: ChoiceModel,
alts: Vec<Self>,
},
DFAStarBlock {
choice: ChoiceModel,
alts: Vec<Self>,
iteration: Vec<Self>,
},
DFAPlusBlock {
choice: ChoiceModel,
alts: Vec<Self>,
error: Box<Self>,
},
InvokeRule {
name: String,
escaped_name: String,
state_number: i32,
ctx_name: String,
precedence: Option<u32>,
labels: Vec<OpLabelModel>,
arg_exprs_chunks: Vec<ActionChunkModel>,
},
MatchToken {
state_number: i32,
name: String,
escaped_name: String,
labels: Vec<OpLabelModel>,
},
AddToLabelList {
label: OpLabelModel,
list_name: String,
},
MatchSet {
state_number: i32,
var_name: String,
labels: Vec<OpLabelModel>,
expr: Box<Self>,
capture: Box<Self>,
},
MatchNotSet {
state_number: i32,
var_name: String,
labels: Vec<OpLabelModel>,
expr: Box<Self>,
capture: Box<Self>,
},
Wildcard {
state_number: i32,
labels: Vec<OpLabelModel>,
},
Action {
chunks: Vec<ActionChunkModel>,
},
TestSetInline {
var_name: String,
bitsets: Vec<BitsetModel>,
},
ThrowNoViableAlt,
SemPred {
state_number: i32,
chunks: Vec<ActionChunkModel>,
predicate: String,
fail_chunks: Option<Vec<ActionChunkModel>>,
msg: Option<String>,
},
RecRuleSetStopToken,
RecRuleSetPrevCtx,
RecRuleAltStartAction {
rule_name: String,
ctx_name: String,
label: Option<String>,
is_list_label: bool,
},
RecRuleLabeledAltStartAction {
rule_name: String,
current_alt_label: String,
label: Option<String>,
is_list_label: bool,
},
RecRuleReplaceContext {
ctx_name: String,
},
CaptureNextToken {
var_name: String,
},
CaptureNextTokenType {
var_name: String,
},
}
#[derive(Clone, Debug, Serialize)]
#[serde(tag = "kind", rename_all_fields = "camelCase")]
pub enum DeclModel {
TokenDecl {
name: String,
escaped_name: String,
},
TokenTypeDecl {
name: String,
escaped_name: String,
},
TokenListDecl {
name: String,
escaped_name: String,
},
RuleContextDecl {
name: String,
escaped_name: String,
ctx_name: String,
},
RuleContextListDecl {
name: String,
escaped_name: String,
ctx_name: String,
},
AttributeDecl {
name: String,
escaped_name: String,
#[serde(rename = "type")]
ty: String,
},
ContextTokenGetterDecl {
name: String,
signature: bool,
},
ContextTokenListGetterDecl {
name: String,
signature: bool,
},
ContextTokenListIndexedGetterDecl {
name: String,
signature: bool,
},
ContextRuleGetterDecl {
name: String,
escaped_name: String,
ctx_name: String,
signature: bool,
},
ContextRuleListGetterDecl {
name: String,
ctx_name: String,
signature: bool,
},
ContextRuleListIndexedGetterDecl {
name: String,
escaped_name: String,
ctx_name: String,
signature: bool,
},
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct StructDeclModel {
pub name: String,
pub escaped_name: String,
pub derived_from_name: String,
pub provide_copy_from: bool,
pub attrs: Vec<DeclModel>,
pub getters: Vec<DeclModel>,
pub signatures: Vec<DeclModel>,
pub ctor_attrs: Vec<DeclModel>,
pub token_decls: Vec<DeclModel>,
pub token_type_decls: Vec<DeclModel>,
pub token_list_decls: Vec<DeclModel>,
pub rule_context_decls: Vec<DeclModel>,
pub rule_context_list_decls: Vec<DeclModel>,
pub attribute_decls: Vec<DeclModel>,
}
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct LexerModel {
pub name: String,
pub grammar_name: String,
pub grammar_file_name: String,
pub tokens: Vec<TokenConstantModel>,
pub rule_names: Vec<String>,
pub literal_names: Vec<Option<String>>,
pub symbolic_names: Vec<Option<String>>,
pub channel_names: Vec<String>,
pub modes: Vec<String>,
pub action_funcs: Vec<RuleActionFunctionModel>,
pub sempred_funcs: Vec<RuleActionFunctionModel>,
pub atn: Option<SerializedAtnModel>,
pub static_tables: Option<StaticLexerTablesModel>,
}